1 /* 2 * Copyright (C) 2005-2007 Red Hat GmbH 3 * 4 * A target that delays reads and/or writes and can send 5 * them to different devices. 6 * 7 * This file is released under the GPL. 8 */ 9 10 #include <linux/module.h> 11 #include <linux/init.h> 12 #include <linux/blkdev.h> 13 #include <linux/bio.h> 14 #include <linux/slab.h> 15 16 #include <linux/device-mapper.h> 17 18 #define DM_MSG_PREFIX "delay" 19 20 struct delay_class { 21 struct dm_dev *dev; 22 sector_t start; 23 unsigned delay; 24 unsigned ops; 25 }; 26 27 struct delay_c { 28 struct timer_list delay_timer; 29 struct mutex timer_lock; 30 struct workqueue_struct *kdelayd_wq; 31 struct work_struct flush_expired_bios; 32 struct list_head delayed_bios; 33 atomic_t may_delay; 34 35 struct delay_class read; 36 struct delay_class write; 37 38 int argc; 39 }; 40 41 struct dm_delay_info { 42 struct delay_c *context; 43 struct delay_class *class; 44 struct list_head list; 45 unsigned long expires; 46 }; 47 48 static DEFINE_MUTEX(delayed_bios_lock); 49 50 static void handle_delayed_timer(struct timer_list *t) 51 { 52 struct delay_c *dc = from_timer(dc, t, delay_timer); 53 54 queue_work(dc->kdelayd_wq, &dc->flush_expired_bios); 55 } 56 57 static void queue_timeout(struct delay_c *dc, unsigned long expires) 58 { 59 mutex_lock(&dc->timer_lock); 60 61 if (!timer_pending(&dc->delay_timer) || expires < dc->delay_timer.expires) 62 mod_timer(&dc->delay_timer, expires); 63 64 mutex_unlock(&dc->timer_lock); 65 } 66 67 static void flush_bios(struct bio *bio) 68 { 69 struct bio *n; 70 71 while (bio) { 72 n = bio->bi_next; 73 bio->bi_next = NULL; 74 generic_make_request(bio); 75 bio = n; 76 } 77 } 78 79 static struct bio *flush_delayed_bios(struct delay_c *dc, int flush_all) 80 { 81 struct dm_delay_info *delayed, *next; 82 unsigned long next_expires = 0; 83 unsigned long start_timer = 0; 84 struct bio_list flush_bios = { }; 85 86 mutex_lock(&delayed_bios_lock); 87 list_for_each_entry_safe(delayed, next, &dc->delayed_bios, list) { 88 if (flush_all || time_after_eq(jiffies, delayed->expires)) { 89 struct bio *bio = dm_bio_from_per_bio_data(delayed, 90 sizeof(struct dm_delay_info)); 91 list_del(&delayed->list); 92 bio_list_add(&flush_bios, bio); 93 delayed->class->ops--; 94 continue; 95 } 96 97 if (!start_timer) { 98 start_timer = 1; 99 next_expires = delayed->expires; 100 } else 101 next_expires = min(next_expires, delayed->expires); 102 } 103 mutex_unlock(&delayed_bios_lock); 104 105 if (start_timer) 106 queue_timeout(dc, next_expires); 107 108 return bio_list_get(&flush_bios); 109 } 110 111 static void flush_expired_bios(struct work_struct *work) 112 { 113 struct delay_c *dc; 114 115 dc = container_of(work, struct delay_c, flush_expired_bios); 116 flush_bios(flush_delayed_bios(dc, 0)); 117 } 118 119 static void delay_dtr(struct dm_target *ti) 120 { 121 struct delay_c *dc = ti->private; 122 123 destroy_workqueue(dc->kdelayd_wq); 124 125 if (dc->read.dev) 126 dm_put_device(ti, dc->read.dev); 127 if (dc->write.dev) 128 dm_put_device(ti, dc->write.dev); 129 130 mutex_destroy(&dc->timer_lock); 131 132 kfree(dc); 133 } 134 135 static int delay_class_ctr(struct dm_target *ti, struct delay_class *c, char **argv) 136 { 137 int ret; 138 unsigned long long tmpll; 139 char dummy; 140 141 if (sscanf(argv[1], "%llu%c", &tmpll, &dummy) != 1) { 142 ti->error = "Invalid device sector"; 143 return -EINVAL; 144 } 145 c->start = tmpll; 146 147 if (sscanf(argv[2], "%u%c", &c->delay, &dummy) != 1) { 148 ti->error = "Invalid delay"; 149 return -EINVAL; 150 } 151 152 ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &c->dev); 153 if (ret) { 154 ti->error = "Device lookup failed"; 155 return ret; 156 } 157 158 return 0; 159 } 160 161 /* 162 * Mapping parameters: 163 * <device> <offset> <delay> [<write_device> <write_offset> <write_delay>] 164 * 165 * With separate write parameters, the first set is only used for reads. 166 * Offsets are specified in sectors. 167 * Delays are specified in milliseconds. 168 */ 169 static int delay_ctr(struct dm_target *ti, unsigned int argc, char **argv) 170 { 171 struct delay_c *dc; 172 int ret; 173 174 if (argc != 3 && argc != 6) { 175 ti->error = "Requires exactly 3 or 6 arguments"; 176 return -EINVAL; 177 } 178 179 dc = kzalloc(sizeof(*dc), GFP_KERNEL); 180 if (!dc) { 181 ti->error = "Cannot allocate context"; 182 return -ENOMEM; 183 } 184 185 ti->private = dc; 186 timer_setup(&dc->delay_timer, handle_delayed_timer, 0); 187 INIT_WORK(&dc->flush_expired_bios, flush_expired_bios); 188 INIT_LIST_HEAD(&dc->delayed_bios); 189 mutex_init(&dc->timer_lock); 190 atomic_set(&dc->may_delay, 1); 191 dc->argc = argc; 192 193 ret = delay_class_ctr(ti, &dc->read, argv); 194 if (ret) 195 goto bad; 196 197 if (argc == 3) { 198 ret = delay_class_ctr(ti, &dc->write, argv); 199 if (ret) 200 goto bad; 201 goto out; 202 } 203 204 ret = delay_class_ctr(ti, &dc->write, argv + 3); 205 if (ret) 206 goto bad; 207 208 out: 209 dc->kdelayd_wq = alloc_workqueue("kdelayd", WQ_MEM_RECLAIM, 0); 210 if (!dc->kdelayd_wq) { 211 ret = -EINVAL; 212 DMERR("Couldn't start kdelayd"); 213 goto bad; 214 } 215 216 ti->num_flush_bios = 1; 217 ti->num_discard_bios = 1; 218 ti->per_io_data_size = sizeof(struct dm_delay_info); 219 return 0; 220 221 bad: 222 delay_dtr(ti); 223 return ret; 224 } 225 226 static int delay_bio(struct delay_c *dc, struct delay_class *c, struct bio *bio) 227 { 228 struct dm_delay_info *delayed; 229 unsigned long expires = 0; 230 231 if (!c->delay || !atomic_read(&dc->may_delay)) 232 return DM_MAPIO_REMAPPED; 233 234 delayed = dm_per_bio_data(bio, sizeof(struct dm_delay_info)); 235 236 delayed->context = dc; 237 delayed->expires = expires = jiffies + msecs_to_jiffies(c->delay); 238 239 mutex_lock(&delayed_bios_lock); 240 c->ops++; 241 list_add_tail(&delayed->list, &dc->delayed_bios); 242 mutex_unlock(&delayed_bios_lock); 243 244 queue_timeout(dc, expires); 245 246 return DM_MAPIO_SUBMITTED; 247 } 248 249 static void delay_presuspend(struct dm_target *ti) 250 { 251 struct delay_c *dc = ti->private; 252 253 atomic_set(&dc->may_delay, 0); 254 del_timer_sync(&dc->delay_timer); 255 flush_bios(flush_delayed_bios(dc, 1)); 256 } 257 258 static void delay_resume(struct dm_target *ti) 259 { 260 struct delay_c *dc = ti->private; 261 262 atomic_set(&dc->may_delay, 1); 263 } 264 265 static int delay_map(struct dm_target *ti, struct bio *bio) 266 { 267 struct delay_c *dc = ti->private; 268 struct delay_class *c; 269 struct dm_delay_info *delayed = dm_per_bio_data(bio, sizeof(struct dm_delay_info)); 270 271 if (bio_data_dir(bio) == WRITE) { 272 c = &dc->write; 273 } else { 274 c = &dc->read; 275 } 276 delayed->class = c; 277 bio_set_dev(bio, c->dev->bdev); 278 if (bio_sectors(bio)) 279 bio->bi_iter.bi_sector = c->start + dm_target_offset(ti, bio->bi_iter.bi_sector); 280 281 return delay_bio(dc, c, bio); 282 } 283 284 #define DMEMIT_DELAY_CLASS(c) \ 285 DMEMIT("%s %llu %u", (c)->dev->name, (unsigned long long)(c)->start, (c)->delay) 286 287 static void delay_status(struct dm_target *ti, status_type_t type, 288 unsigned status_flags, char *result, unsigned maxlen) 289 { 290 struct delay_c *dc = ti->private; 291 int sz = 0; 292 293 switch (type) { 294 case STATUSTYPE_INFO: 295 DMEMIT("%u %u", dc->read.ops, dc->write.ops); 296 break; 297 298 case STATUSTYPE_TABLE: 299 DMEMIT_DELAY_CLASS(&dc->read); 300 if (dc->argc >= 6) { 301 DMEMIT(" "); 302 DMEMIT_DELAY_CLASS(&dc->write); 303 } 304 break; 305 } 306 } 307 308 static int delay_iterate_devices(struct dm_target *ti, 309 iterate_devices_callout_fn fn, void *data) 310 { 311 struct delay_c *dc = ti->private; 312 int ret = 0; 313 314 ret = fn(ti, dc->read.dev, dc->read.start, ti->len, data); 315 if (ret) 316 goto out; 317 ret = fn(ti, dc->write.dev, dc->write.start, ti->len, data); 318 if (ret) 319 goto out; 320 321 out: 322 return ret; 323 } 324 325 static struct target_type delay_target = { 326 .name = "delay", 327 .version = {1, 2, 1}, 328 .features = DM_TARGET_PASSES_INTEGRITY, 329 .module = THIS_MODULE, 330 .ctr = delay_ctr, 331 .dtr = delay_dtr, 332 .map = delay_map, 333 .presuspend = delay_presuspend, 334 .resume = delay_resume, 335 .status = delay_status, 336 .iterate_devices = delay_iterate_devices, 337 }; 338 339 static int __init dm_delay_init(void) 340 { 341 int r; 342 343 r = dm_register_target(&delay_target); 344 if (r < 0) { 345 DMERR("register failed %d", r); 346 goto bad_register; 347 } 348 349 return 0; 350 351 bad_register: 352 return r; 353 } 354 355 static void __exit dm_delay_exit(void) 356 { 357 dm_unregister_target(&delay_target); 358 } 359 360 /* Module hooks */ 361 module_init(dm_delay_init); 362 module_exit(dm_delay_exit); 363 364 MODULE_DESCRIPTION(DM_NAME " delay target"); 365 MODULE_AUTHOR("Heinz Mauelshagen <[email protected]>"); 366 MODULE_LICENSE("GPL"); 367