2 * Copyright (C) 2005-2007 Red Hat GmbH
4 * A target that delays reads and/or writes and can send
5 * them to different devices.
7 * This file is released under the GPL.
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>
16 #include <linux/device-mapper.h>
18 #define DM_MSG_PREFIX "delay"
21 struct timer_list delay_timer
;
22 struct mutex timer_lock
;
23 struct workqueue_struct
*kdelayd_wq
;
24 struct work_struct flush_expired_bios
;
25 struct list_head delayed_bios
;
28 struct dm_dev
*dev_read
;
33 struct dm_dev
*dev_write
;
39 struct dm_delay_info
{
40 struct delay_c
*context
;
41 struct list_head list
;
42 unsigned long expires
;
45 static DEFINE_MUTEX(delayed_bios_lock
);
47 static void handle_delayed_timer(unsigned long data
)
49 struct delay_c
*dc
= (struct delay_c
*)data
;
51 queue_work(dc
->kdelayd_wq
, &dc
->flush_expired_bios
);
54 static void queue_timeout(struct delay_c
*dc
, unsigned long expires
)
56 mutex_lock(&dc
->timer_lock
);
58 if (!timer_pending(&dc
->delay_timer
) || expires
< dc
->delay_timer
.expires
)
59 mod_timer(&dc
->delay_timer
, expires
);
61 mutex_unlock(&dc
->timer_lock
);
64 static void flush_bios(struct bio
*bio
)
71 generic_make_request(bio
);
76 static struct bio
*flush_delayed_bios(struct delay_c
*dc
, int flush_all
)
78 struct dm_delay_info
*delayed
, *next
;
79 unsigned long next_expires
= 0;
81 struct bio_list flush_bios
= { };
83 mutex_lock(&delayed_bios_lock
);
84 list_for_each_entry_safe(delayed
, next
, &dc
->delayed_bios
, list
) {
85 if (flush_all
|| time_after_eq(jiffies
, delayed
->expires
)) {
86 struct bio
*bio
= dm_bio_from_per_bio_data(delayed
,
87 sizeof(struct dm_delay_info
));
88 list_del(&delayed
->list
);
89 bio_list_add(&flush_bios
, bio
);
90 if ((bio_data_dir(bio
) == WRITE
))
91 delayed
->context
->writes
--;
93 delayed
->context
->reads
--;
99 next_expires
= delayed
->expires
;
101 next_expires
= min(next_expires
, delayed
->expires
);
104 mutex_unlock(&delayed_bios_lock
);
107 queue_timeout(dc
, next_expires
);
109 return bio_list_get(&flush_bios
);
112 static void flush_expired_bios(struct work_struct
*work
)
116 dc
= container_of(work
, struct delay_c
, flush_expired_bios
);
117 flush_bios(flush_delayed_bios(dc
, 0));
121 * Mapping parameters:
122 * <device> <offset> <delay> [<write_device> <write_offset> <write_delay>]
124 * With separate write parameters, the first set is only used for reads.
125 * Delays are specified in milliseconds.
127 static int delay_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
130 unsigned long long tmpll
;
134 if (argc
!= 3 && argc
!= 6) {
135 ti
->error
= "requires exactly 3 or 6 arguments";
139 dc
= kmalloc(sizeof(*dc
), GFP_KERNEL
);
141 ti
->error
= "Cannot allocate context";
145 dc
->reads
= dc
->writes
= 0;
148 if (sscanf(argv
[1], "%llu%c", &tmpll
, &dummy
) != 1) {
149 ti
->error
= "Invalid device sector";
152 dc
->start_read
= tmpll
;
154 if (sscanf(argv
[2], "%u%c", &dc
->read_delay
, &dummy
) != 1) {
155 ti
->error
= "Invalid delay";
159 ret
= dm_get_device(ti
, argv
[0], dm_table_get_mode(ti
->table
),
162 ti
->error
= "Device lookup failed";
167 dc
->dev_write
= NULL
;
171 if (sscanf(argv
[4], "%llu%c", &tmpll
, &dummy
) != 1) {
172 ti
->error
= "Invalid write device sector";
175 dc
->start_write
= tmpll
;
177 if (sscanf(argv
[5], "%u%c", &dc
->write_delay
, &dummy
) != 1) {
178 ti
->error
= "Invalid write delay";
182 ret
= dm_get_device(ti
, argv
[3], dm_table_get_mode(ti
->table
),
185 ti
->error
= "Write device lookup failed";
191 dc
->kdelayd_wq
= alloc_workqueue("kdelayd", WQ_MEM_RECLAIM
, 0);
192 if (!dc
->kdelayd_wq
) {
193 DMERR("Couldn't start kdelayd");
197 setup_timer(&dc
->delay_timer
, handle_delayed_timer
, (unsigned long)dc
);
199 INIT_WORK(&dc
->flush_expired_bios
, flush_expired_bios
);
200 INIT_LIST_HEAD(&dc
->delayed_bios
);
201 mutex_init(&dc
->timer_lock
);
202 atomic_set(&dc
->may_delay
, 1);
204 ti
->num_flush_bios
= 1;
205 ti
->num_discard_bios
= 1;
206 ti
->per_bio_data_size
= sizeof(struct dm_delay_info
);
212 dm_put_device(ti
, dc
->dev_write
);
214 dm_put_device(ti
, dc
->dev_read
);
220 static void delay_dtr(struct dm_target
*ti
)
222 struct delay_c
*dc
= ti
->private;
224 destroy_workqueue(dc
->kdelayd_wq
);
226 dm_put_device(ti
, dc
->dev_read
);
229 dm_put_device(ti
, dc
->dev_write
);
234 static int delay_bio(struct delay_c
*dc
, int delay
, struct bio
*bio
)
236 struct dm_delay_info
*delayed
;
237 unsigned long expires
= 0;
239 if (!delay
|| !atomic_read(&dc
->may_delay
))
242 delayed
= dm_per_bio_data(bio
, sizeof(struct dm_delay_info
));
244 delayed
->context
= dc
;
245 delayed
->expires
= expires
= jiffies
+ msecs_to_jiffies(delay
);
247 mutex_lock(&delayed_bios_lock
);
249 if (bio_data_dir(bio
) == WRITE
)
254 list_add_tail(&delayed
->list
, &dc
->delayed_bios
);
256 mutex_unlock(&delayed_bios_lock
);
258 queue_timeout(dc
, expires
);
263 static void delay_presuspend(struct dm_target
*ti
)
265 struct delay_c
*dc
= ti
->private;
267 atomic_set(&dc
->may_delay
, 0);
268 del_timer_sync(&dc
->delay_timer
);
269 flush_bios(flush_delayed_bios(dc
, 1));
272 static void delay_resume(struct dm_target
*ti
)
274 struct delay_c
*dc
= ti
->private;
276 atomic_set(&dc
->may_delay
, 1);
279 static int delay_map(struct dm_target
*ti
, struct bio
*bio
)
281 struct delay_c
*dc
= ti
->private;
283 if ((bio_data_dir(bio
) == WRITE
) && (dc
->dev_write
)) {
284 bio
->bi_bdev
= dc
->dev_write
->bdev
;
285 if (bio_sectors(bio
))
286 bio
->bi_iter
.bi_sector
= dc
->start_write
+
287 dm_target_offset(ti
, bio
->bi_iter
.bi_sector
);
289 return delay_bio(dc
, dc
->write_delay
, bio
);
292 bio
->bi_bdev
= dc
->dev_read
->bdev
;
293 bio
->bi_iter
.bi_sector
= dc
->start_read
+
294 dm_target_offset(ti
, bio
->bi_iter
.bi_sector
);
296 return delay_bio(dc
, dc
->read_delay
, bio
);
299 static void delay_status(struct dm_target
*ti
, status_type_t type
,
300 unsigned status_flags
, char *result
, unsigned maxlen
)
302 struct delay_c
*dc
= ti
->private;
306 case STATUSTYPE_INFO
:
307 DMEMIT("%u %u", dc
->reads
, dc
->writes
);
310 case STATUSTYPE_TABLE
:
311 DMEMIT("%s %llu %u", dc
->dev_read
->name
,
312 (unsigned long long) dc
->start_read
,
315 DMEMIT(" %s %llu %u", dc
->dev_write
->name
,
316 (unsigned long long) dc
->start_write
,
322 static int delay_iterate_devices(struct dm_target
*ti
,
323 iterate_devices_callout_fn fn
, void *data
)
325 struct delay_c
*dc
= ti
->private;
328 ret
= fn(ti
, dc
->dev_read
, dc
->start_read
, ti
->len
, data
);
333 ret
= fn(ti
, dc
->dev_write
, dc
->start_write
, ti
->len
, data
);
339 static struct target_type delay_target
= {
341 .version
= {1, 2, 1},
342 .module
= THIS_MODULE
,
346 .presuspend
= delay_presuspend
,
347 .resume
= delay_resume
,
348 .status
= delay_status
,
349 .iterate_devices
= delay_iterate_devices
,
352 static int __init
dm_delay_init(void)
356 r
= dm_register_target(&delay_target
);
358 DMERR("register failed %d", r
);
368 static void __exit
dm_delay_exit(void)
370 dm_unregister_target(&delay_target
);
374 module_init(dm_delay_init
);
375 module_exit(dm_delay_exit
);
377 MODULE_DESCRIPTION(DM_NAME
" delay target");
378 MODULE_AUTHOR("Heinz Mauelshagen <mauelshagen@redhat.com>");
379 MODULE_LICENSE("GPL");