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