2 * Copyright (C) 2003 Sistina Software (UK) Limited.
3 * Copyright (C) 2004, 2010-2011 Red Hat, Inc. All rights reserved.
5 * This file is released under the GPL.
8 #include <linux/device-mapper.h>
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 #define DM_MSG_PREFIX "flakey"
18 #define all_corrupt_bio_flags_match(bio, fc) \
19 (((bio)->bi_rw & (fc)->corrupt_bio_flags) == (fc)->corrupt_bio_flags)
22 * Flakey: Used for testing only, simulates intermittent,
23 * catastrophic device failure.
27 unsigned long start_time
;
30 unsigned down_interval
;
32 unsigned corrupt_bio_byte
;
33 unsigned corrupt_bio_rw
;
34 unsigned corrupt_bio_value
;
35 unsigned corrupt_bio_flags
;
38 enum feature_flag_bits
{
46 static int parse_features(struct dm_arg_set
*as
, struct flakey_c
*fc
,
53 static struct dm_arg _args
[] = {
54 {0, 6, "Invalid number of feature args"},
55 {1, UINT_MAX
, "Invalid corrupt bio byte"},
56 {0, 255, "Invalid corrupt value to write into bio byte (0-255)"},
57 {0, UINT_MAX
, "Invalid corrupt bio flags mask"},
60 /* No feature arguments supplied. */
64 r
= dm_read_arg_group(_args
, as
, &argc
, &ti
->error
);
69 arg_name
= dm_shift_arg(as
);
75 if (!strcasecmp(arg_name
, "drop_writes")) {
76 if (test_and_set_bit(DROP_WRITES
, &fc
->flags
)) {
77 ti
->error
= "Feature drop_writes duplicated";
85 * corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>
87 if (!strcasecmp(arg_name
, "corrupt_bio_byte")) {
89 ti
->error
= "Feature corrupt_bio_byte requires parameters";
93 r
= dm_read_arg(_args
+ 1, as
, &fc
->corrupt_bio_byte
, &ti
->error
);
101 arg_name
= dm_shift_arg(as
);
102 if (!strcasecmp(arg_name
, "w"))
103 fc
->corrupt_bio_rw
= WRITE
;
104 else if (!strcasecmp(arg_name
, "r"))
105 fc
->corrupt_bio_rw
= READ
;
107 ti
->error
= "Invalid corrupt bio direction (r or w)";
113 * Value of byte (0-255) to write in place of correct one.
115 r
= dm_read_arg(_args
+ 2, as
, &fc
->corrupt_bio_value
, &ti
->error
);
121 * Only corrupt bios with these flags set.
123 r
= dm_read_arg(_args
+ 3, as
, &fc
->corrupt_bio_flags
, &ti
->error
);
131 ti
->error
= "Unrecognised flakey feature requested";
135 if (test_bit(DROP_WRITES
, &fc
->flags
) && (fc
->corrupt_bio_rw
== WRITE
)) {
136 ti
->error
= "drop_writes is incompatible with corrupt_bio_byte with the WRITE flag set";
144 * Construct a flakey mapping:
145 * <dev_path> <offset> <up interval> <down interval> [<#feature args> [<arg>]*]
149 * [corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>]
151 * Nth_byte starts from 1 for the first byte.
152 * Direction is r for READ or w for WRITE.
153 * bio_flags is ignored if 0.
155 static int flakey_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
157 static struct dm_arg _args
[] = {
158 {0, UINT_MAX
, "Invalid up interval"},
159 {0, UINT_MAX
, "Invalid down interval"},
164 unsigned long long tmpll
;
165 struct dm_arg_set as
;
173 ti
->error
= "Invalid argument count";
177 fc
= kzalloc(sizeof(*fc
), GFP_KERNEL
);
179 ti
->error
= "Cannot allocate context";
182 fc
->start_time
= jiffies
;
184 devname
= dm_shift_arg(&as
);
187 if (sscanf(dm_shift_arg(&as
), "%llu%c", &tmpll
, &dummy
) != 1) {
188 ti
->error
= "Invalid device sector";
193 r
= dm_read_arg(_args
, &as
, &fc
->up_interval
, &ti
->error
);
197 r
= dm_read_arg(_args
, &as
, &fc
->down_interval
, &ti
->error
);
201 if (!(fc
->up_interval
+ fc
->down_interval
)) {
202 ti
->error
= "Total (up + down) interval is zero";
206 if (fc
->up_interval
+ fc
->down_interval
< fc
->up_interval
) {
207 ti
->error
= "Interval overflow";
211 r
= parse_features(&as
, fc
, ti
);
215 r
= dm_get_device(ti
, devname
, dm_table_get_mode(ti
->table
), &fc
->dev
);
217 ti
->error
= "Device lookup failed";
221 ti
->num_flush_bios
= 1;
222 ti
->num_discard_bios
= 1;
223 ti
->per_io_data_size
= sizeof(struct per_bio_data
);
232 static void flakey_dtr(struct dm_target
*ti
)
234 struct flakey_c
*fc
= ti
->private;
236 dm_put_device(ti
, fc
->dev
);
240 static sector_t
flakey_map_sector(struct dm_target
*ti
, sector_t bi_sector
)
242 struct flakey_c
*fc
= ti
->private;
244 return fc
->start
+ dm_target_offset(ti
, bi_sector
);
247 static void flakey_map_bio(struct dm_target
*ti
, struct bio
*bio
)
249 struct flakey_c
*fc
= ti
->private;
251 bio
->bi_bdev
= fc
->dev
->bdev
;
252 if (bio_sectors(bio
))
253 bio
->bi_iter
.bi_sector
=
254 flakey_map_sector(ti
, bio
->bi_iter
.bi_sector
);
257 static void corrupt_bio_data(struct bio
*bio
, struct flakey_c
*fc
)
259 unsigned bio_bytes
= bio_cur_bytes(bio
);
260 char *data
= bio_data(bio
);
263 * Overwrite the Nth byte of the data returned.
265 if (data
&& bio_bytes
>= fc
->corrupt_bio_byte
) {
266 data
[fc
->corrupt_bio_byte
- 1] = fc
->corrupt_bio_value
;
268 DMDEBUG("Corrupting data bio=%p by writing %u to byte %u "
269 "(rw=%c bi_rw=%lu bi_sector=%llu cur_bytes=%u)\n",
270 bio
, fc
->corrupt_bio_value
, fc
->corrupt_bio_byte
,
271 (bio_data_dir(bio
) == WRITE
) ? 'w' : 'r', bio
->bi_rw
,
272 (unsigned long long)bio
->bi_iter
.bi_sector
, bio_bytes
);
276 static int flakey_map(struct dm_target
*ti
, struct bio
*bio
)
278 struct flakey_c
*fc
= ti
->private;
280 struct per_bio_data
*pb
= dm_per_bio_data(bio
, sizeof(struct per_bio_data
));
281 pb
->bio_submitted
= false;
284 elapsed
= (jiffies
- fc
->start_time
) / HZ
;
285 if (elapsed
% (fc
->up_interval
+ fc
->down_interval
) >= fc
->up_interval
) {
287 * Flag this bio as submitted while down.
289 pb
->bio_submitted
= true;
292 * Map reads as normal.
294 if (bio_data_dir(bio
) == READ
)
300 if (test_bit(DROP_WRITES
, &fc
->flags
)) {
302 return DM_MAPIO_SUBMITTED
;
306 * Corrupt matching writes.
308 if (fc
->corrupt_bio_byte
&& (fc
->corrupt_bio_rw
== WRITE
)) {
309 if (all_corrupt_bio_flags_match(bio
, fc
))
310 corrupt_bio_data(bio
, fc
);
315 * By default, error all I/O.
321 flakey_map_bio(ti
, bio
);
323 return DM_MAPIO_REMAPPED
;
326 static int flakey_end_io(struct dm_target
*ti
, struct bio
*bio
, int error
)
328 struct flakey_c
*fc
= ti
->private;
329 struct per_bio_data
*pb
= dm_per_bio_data(bio
, sizeof(struct per_bio_data
));
332 * Corrupt successful READs while in down state.
333 * If flags were specified, only corrupt those that match.
335 if (fc
->corrupt_bio_byte
&& !error
&& pb
->bio_submitted
&&
336 (bio_data_dir(bio
) == READ
) && (fc
->corrupt_bio_rw
== READ
) &&
337 all_corrupt_bio_flags_match(bio
, fc
))
338 corrupt_bio_data(bio
, fc
);
343 static void flakey_status(struct dm_target
*ti
, status_type_t type
,
344 unsigned status_flags
, char *result
, unsigned maxlen
)
347 struct flakey_c
*fc
= ti
->private;
348 unsigned drop_writes
;
351 case STATUSTYPE_INFO
:
355 case STATUSTYPE_TABLE
:
356 DMEMIT("%s %llu %u %u ", fc
->dev
->name
,
357 (unsigned long long)fc
->start
, fc
->up_interval
,
360 drop_writes
= test_bit(DROP_WRITES
, &fc
->flags
);
361 DMEMIT("%u ", drop_writes
+ (fc
->corrupt_bio_byte
> 0) * 5);
364 DMEMIT("drop_writes ");
366 if (fc
->corrupt_bio_byte
)
367 DMEMIT("corrupt_bio_byte %u %c %u %u ",
368 fc
->corrupt_bio_byte
,
369 (fc
->corrupt_bio_rw
== WRITE
) ? 'w' : 'r',
370 fc
->corrupt_bio_value
, fc
->corrupt_bio_flags
);
376 static int flakey_prepare_ioctl(struct dm_target
*ti
,
377 struct block_device
**bdev
, fmode_t
*mode
)
379 struct flakey_c
*fc
= ti
->private;
381 *bdev
= fc
->dev
->bdev
;
384 * Only pass ioctls through if the device sizes match exactly.
387 ti
->len
!= i_size_read((*bdev
)->bd_inode
) >> SECTOR_SHIFT
)
392 static int flakey_iterate_devices(struct dm_target
*ti
, iterate_devices_callout_fn fn
, void *data
)
394 struct flakey_c
*fc
= ti
->private;
396 return fn(ti
, fc
->dev
, fc
->start
, ti
->len
, data
);
399 static struct target_type flakey_target
= {
401 .version
= {1, 3, 1},
402 .module
= THIS_MODULE
,
406 .end_io
= flakey_end_io
,
407 .status
= flakey_status
,
408 .prepare_ioctl
= flakey_prepare_ioctl
,
409 .iterate_devices
= flakey_iterate_devices
,
412 static int __init
dm_flakey_init(void)
414 int r
= dm_register_target(&flakey_target
);
417 DMERR("register failed %d", r
);
422 static void __exit
dm_flakey_exit(void)
424 dm_unregister_target(&flakey_target
);
428 module_init(dm_flakey_init
);
429 module_exit(dm_flakey_exit
);
431 MODULE_DESCRIPTION(DM_NAME
" flakey target");
432 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
433 MODULE_LICENSE("GPL");