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_opf & (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
{
47 static int parse_features(struct dm_arg_set
*as
, struct flakey_c
*fc
,
54 static const struct dm_arg _args
[] = {
55 {0, 6, "Invalid number of feature args"},
56 {1, UINT_MAX
, "Invalid corrupt bio byte"},
57 {0, 255, "Invalid corrupt value to write into bio byte (0-255)"},
58 {0, UINT_MAX
, "Invalid corrupt bio flags mask"},
61 /* No feature arguments supplied. */
65 r
= dm_read_arg_group(_args
, as
, &argc
, &ti
->error
);
70 arg_name
= dm_shift_arg(as
);
74 ti
->error
= "Insufficient feature arguments";
81 if (!strcasecmp(arg_name
, "drop_writes")) {
82 if (test_and_set_bit(DROP_WRITES
, &fc
->flags
)) {
83 ti
->error
= "Feature drop_writes duplicated";
85 } else if (test_bit(ERROR_WRITES
, &fc
->flags
)) {
86 ti
->error
= "Feature drop_writes conflicts with feature error_writes";
96 if (!strcasecmp(arg_name
, "error_writes")) {
97 if (test_and_set_bit(ERROR_WRITES
, &fc
->flags
)) {
98 ti
->error
= "Feature error_writes duplicated";
101 } else if (test_bit(DROP_WRITES
, &fc
->flags
)) {
102 ti
->error
= "Feature error_writes conflicts with feature drop_writes";
110 * corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>
112 if (!strcasecmp(arg_name
, "corrupt_bio_byte")) {
114 ti
->error
= "Feature corrupt_bio_byte requires parameters";
118 r
= dm_read_arg(_args
+ 1, as
, &fc
->corrupt_bio_byte
, &ti
->error
);
126 arg_name
= dm_shift_arg(as
);
127 if (!strcasecmp(arg_name
, "w"))
128 fc
->corrupt_bio_rw
= WRITE
;
129 else if (!strcasecmp(arg_name
, "r"))
130 fc
->corrupt_bio_rw
= READ
;
132 ti
->error
= "Invalid corrupt bio direction (r or w)";
138 * Value of byte (0-255) to write in place of correct one.
140 r
= dm_read_arg(_args
+ 2, as
, &fc
->corrupt_bio_value
, &ti
->error
);
146 * Only corrupt bios with these flags set.
148 r
= dm_read_arg(_args
+ 3, as
, &fc
->corrupt_bio_flags
, &ti
->error
);
156 ti
->error
= "Unrecognised flakey feature requested";
160 if (test_bit(DROP_WRITES
, &fc
->flags
) && (fc
->corrupt_bio_rw
== WRITE
)) {
161 ti
->error
= "drop_writes is incompatible with corrupt_bio_byte with the WRITE flag set";
164 } else if (test_bit(ERROR_WRITES
, &fc
->flags
) && (fc
->corrupt_bio_rw
== WRITE
)) {
165 ti
->error
= "error_writes is incompatible with corrupt_bio_byte with the WRITE flag set";
173 * Construct a flakey mapping:
174 * <dev_path> <offset> <up interval> <down interval> [<#feature args> [<arg>]*]
178 * [corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>]
180 * Nth_byte starts from 1 for the first byte.
181 * Direction is r for READ or w for WRITE.
182 * bio_flags is ignored if 0.
184 static int flakey_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
186 static const struct dm_arg _args
[] = {
187 {0, UINT_MAX
, "Invalid up interval"},
188 {0, UINT_MAX
, "Invalid down interval"},
193 unsigned long long tmpll
;
194 struct dm_arg_set as
;
202 ti
->error
= "Invalid argument count";
206 fc
= kzalloc(sizeof(*fc
), GFP_KERNEL
);
208 ti
->error
= "Cannot allocate context";
211 fc
->start_time
= jiffies
;
213 devname
= dm_shift_arg(&as
);
216 if (sscanf(dm_shift_arg(&as
), "%llu%c", &tmpll
, &dummy
) != 1 || tmpll
!= (sector_t
)tmpll
) {
217 ti
->error
= "Invalid device sector";
222 r
= dm_read_arg(_args
, &as
, &fc
->up_interval
, &ti
->error
);
226 r
= dm_read_arg(_args
, &as
, &fc
->down_interval
, &ti
->error
);
230 if (!(fc
->up_interval
+ fc
->down_interval
)) {
231 ti
->error
= "Total (up + down) interval is zero";
236 if (fc
->up_interval
+ fc
->down_interval
< fc
->up_interval
) {
237 ti
->error
= "Interval overflow";
242 r
= parse_features(&as
, fc
, ti
);
246 r
= dm_get_device(ti
, devname
, dm_table_get_mode(ti
->table
), &fc
->dev
);
248 ti
->error
= "Device lookup failed";
252 ti
->num_flush_bios
= 1;
253 ti
->num_discard_bios
= 1;
254 ti
->per_io_data_size
= sizeof(struct per_bio_data
);
263 static void flakey_dtr(struct dm_target
*ti
)
265 struct flakey_c
*fc
= ti
->private;
267 dm_put_device(ti
, fc
->dev
);
271 static sector_t
flakey_map_sector(struct dm_target
*ti
, sector_t bi_sector
)
273 struct flakey_c
*fc
= ti
->private;
275 return fc
->start
+ dm_target_offset(ti
, bi_sector
);
278 static void flakey_map_bio(struct dm_target
*ti
, struct bio
*bio
)
280 struct flakey_c
*fc
= ti
->private;
282 bio_set_dev(bio
, fc
->dev
->bdev
);
283 if (bio_sectors(bio
) || bio_op(bio
) == REQ_OP_ZONE_RESET
)
284 bio
->bi_iter
.bi_sector
=
285 flakey_map_sector(ti
, bio
->bi_iter
.bi_sector
);
288 static void corrupt_bio_data(struct bio
*bio
, struct flakey_c
*fc
)
290 unsigned int corrupt_bio_byte
= fc
->corrupt_bio_byte
- 1;
292 struct bvec_iter iter
;
295 if (!bio_has_data(bio
))
299 * Overwrite the Nth byte of the bio's data, on whichever page
302 bio_for_each_segment(bvec
, bio
, iter
) {
303 if (bio_iter_len(bio
, iter
) > corrupt_bio_byte
) {
304 char *segment
= (page_address(bio_iter_page(bio
, iter
))
305 + bio_iter_offset(bio
, iter
));
306 segment
[corrupt_bio_byte
] = fc
->corrupt_bio_value
;
307 DMDEBUG("Corrupting data bio=%p by writing %u to byte %u "
308 "(rw=%c bi_opf=%u bi_sector=%llu size=%u)\n",
309 bio
, fc
->corrupt_bio_value
, fc
->corrupt_bio_byte
,
310 (bio_data_dir(bio
) == WRITE
) ? 'w' : 'r', bio
->bi_opf
,
311 (unsigned long long)bio
->bi_iter
.bi_sector
, bio
->bi_iter
.bi_size
);
314 corrupt_bio_byte
-= bio_iter_len(bio
, iter
);
318 static int flakey_map(struct dm_target
*ti
, struct bio
*bio
)
320 struct flakey_c
*fc
= ti
->private;
322 struct per_bio_data
*pb
= dm_per_bio_data(bio
, sizeof(struct per_bio_data
));
323 pb
->bio_submitted
= false;
325 /* Do not fail reset zone */
326 if (bio_op(bio
) == REQ_OP_ZONE_RESET
)
330 elapsed
= (jiffies
- fc
->start_time
) / HZ
;
331 if (elapsed
% (fc
->up_interval
+ fc
->down_interval
) >= fc
->up_interval
) {
333 * Flag this bio as submitted while down.
335 pb
->bio_submitted
= true;
338 * Error reads if neither corrupt_bio_byte or drop_writes or error_writes are set.
339 * Otherwise, flakey_end_io() will decide if the reads should be modified.
341 if (bio_data_dir(bio
) == READ
) {
342 if (!fc
->corrupt_bio_byte
&& !test_bit(DROP_WRITES
, &fc
->flags
) &&
343 !test_bit(ERROR_WRITES
, &fc
->flags
))
344 return DM_MAPIO_KILL
;
349 * Drop or error writes?
351 if (test_bit(DROP_WRITES
, &fc
->flags
)) {
353 return DM_MAPIO_SUBMITTED
;
355 else if (test_bit(ERROR_WRITES
, &fc
->flags
)) {
357 return DM_MAPIO_SUBMITTED
;
361 * Corrupt matching writes.
363 if (fc
->corrupt_bio_byte
&& (fc
->corrupt_bio_rw
== WRITE
)) {
364 if (all_corrupt_bio_flags_match(bio
, fc
))
365 corrupt_bio_data(bio
, fc
);
370 * By default, error all I/O.
372 return DM_MAPIO_KILL
;
376 flakey_map_bio(ti
, bio
);
378 return DM_MAPIO_REMAPPED
;
381 static int flakey_end_io(struct dm_target
*ti
, struct bio
*bio
,
384 struct flakey_c
*fc
= ti
->private;
385 struct per_bio_data
*pb
= dm_per_bio_data(bio
, sizeof(struct per_bio_data
));
387 if (bio_op(bio
) == REQ_OP_ZONE_RESET
)
388 return DM_ENDIO_DONE
;
390 if (!*error
&& pb
->bio_submitted
&& (bio_data_dir(bio
) == READ
)) {
391 if (fc
->corrupt_bio_byte
&& (fc
->corrupt_bio_rw
== READ
) &&
392 all_corrupt_bio_flags_match(bio
, fc
)) {
394 * Corrupt successful matching READs while in down state.
396 corrupt_bio_data(bio
, fc
);
398 } else if (!test_bit(DROP_WRITES
, &fc
->flags
) &&
399 !test_bit(ERROR_WRITES
, &fc
->flags
)) {
401 * Error read during the down_interval if drop_writes
402 * and error_writes were not configured.
404 *error
= BLK_STS_IOERR
;
408 return DM_ENDIO_DONE
;
411 static void flakey_status(struct dm_target
*ti
, status_type_t type
,
412 unsigned status_flags
, char *result
, unsigned maxlen
)
415 struct flakey_c
*fc
= ti
->private;
416 unsigned drop_writes
, error_writes
;
419 case STATUSTYPE_INFO
:
423 case STATUSTYPE_TABLE
:
424 DMEMIT("%s %llu %u %u ", fc
->dev
->name
,
425 (unsigned long long)fc
->start
, fc
->up_interval
,
428 drop_writes
= test_bit(DROP_WRITES
, &fc
->flags
);
429 error_writes
= test_bit(ERROR_WRITES
, &fc
->flags
);
430 DMEMIT("%u ", drop_writes
+ error_writes
+ (fc
->corrupt_bio_byte
> 0) * 5);
433 DMEMIT("drop_writes ");
434 else if (error_writes
)
435 DMEMIT("error_writes ");
437 if (fc
->corrupt_bio_byte
)
438 DMEMIT("corrupt_bio_byte %u %c %u %u ",
439 fc
->corrupt_bio_byte
,
440 (fc
->corrupt_bio_rw
== WRITE
) ? 'w' : 'r',
441 fc
->corrupt_bio_value
, fc
->corrupt_bio_flags
);
447 static int flakey_prepare_ioctl(struct dm_target
*ti
, struct block_device
**bdev
)
449 struct flakey_c
*fc
= ti
->private;
451 *bdev
= fc
->dev
->bdev
;
454 * Only pass ioctls through if the device sizes match exactly.
457 ti
->len
!= i_size_read((*bdev
)->bd_inode
) >> SECTOR_SHIFT
)
462 #ifdef CONFIG_BLK_DEV_ZONED
463 static int flakey_report_zones(struct dm_target
*ti
, sector_t sector
,
464 struct blk_zone
*zones
, unsigned int *nr_zones
,
467 struct flakey_c
*fc
= ti
->private;
470 /* Do report and remap it */
471 ret
= blkdev_report_zones(fc
->dev
->bdev
, flakey_map_sector(ti
, sector
),
472 zones
, nr_zones
, gfp_mask
);
477 dm_remap_zone_report(ti
, fc
->start
, zones
, nr_zones
);
482 static int flakey_iterate_devices(struct dm_target
*ti
, iterate_devices_callout_fn fn
, void *data
)
484 struct flakey_c
*fc
= ti
->private;
486 return fn(ti
, fc
->dev
, fc
->start
, ti
->len
, data
);
489 static struct target_type flakey_target
= {
491 .version
= {1, 5, 0},
492 #ifdef CONFIG_BLK_DEV_ZONED
493 .features
= DM_TARGET_ZONED_HM
,
494 .report_zones
= flakey_report_zones
,
496 .module
= THIS_MODULE
,
500 .end_io
= flakey_end_io
,
501 .status
= flakey_status
,
502 .prepare_ioctl
= flakey_prepare_ioctl
,
503 .iterate_devices
= flakey_iterate_devices
,
506 static int __init
dm_flakey_init(void)
508 int r
= dm_register_target(&flakey_target
);
511 DMERR("register failed %d", r
);
516 static void __exit
dm_flakey_exit(void)
518 dm_unregister_target(&flakey_target
);
522 module_init(dm_flakey_init
);
523 module_exit(dm_flakey_exit
);
525 MODULE_DESCRIPTION(DM_NAME
" flakey target");
526 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
527 MODULE_LICENSE("GPL");