1 /* 2 * Copyright (C) 2003 Sistina Software (UK) Limited. 3 * Copyright (C) 2004, 2010-2011 Red Hat, Inc. All rights reserved. 4 * 5 * This file is released under the GPL. 6 */ 7 8 #include <linux/device-mapper.h> 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 #define DM_MSG_PREFIX "flakey" 17 18 #define all_corrupt_bio_flags_match(bio, fc) \ 19 (((bio)->bi_opf & (fc)->corrupt_bio_flags) == (fc)->corrupt_bio_flags) 20 21 /* 22 * Flakey: Used for testing only, simulates intermittent, 23 * catastrophic device failure. 24 */ 25 struct flakey_c { 26 struct dm_dev *dev; 27 unsigned long start_time; 28 sector_t start; 29 unsigned up_interval; 30 unsigned down_interval; 31 unsigned long flags; 32 unsigned corrupt_bio_byte; 33 unsigned corrupt_bio_rw; 34 unsigned corrupt_bio_value; 35 unsigned corrupt_bio_flags; 36 }; 37 38 enum feature_flag_bits { 39 DROP_WRITES, 40 ERROR_WRITES 41 }; 42 43 struct per_bio_data { 44 bool bio_submitted; 45 }; 46 47 static int parse_features(struct dm_arg_set *as, struct flakey_c *fc, 48 struct dm_target *ti) 49 { 50 int r; 51 unsigned argc; 52 const char *arg_name; 53 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"}, 59 }; 60 61 /* No feature arguments supplied. */ 62 if (!as->argc) 63 return 0; 64 65 r = dm_read_arg_group(_args, as, &argc, &ti->error); 66 if (r) 67 return r; 68 69 while (argc) { 70 arg_name = dm_shift_arg(as); 71 argc--; 72 73 if (!arg_name) { 74 ti->error = "Insufficient feature arguments"; 75 return -EINVAL; 76 } 77 78 /* 79 * drop_writes 80 */ 81 if (!strcasecmp(arg_name, "drop_writes")) { 82 if (test_and_set_bit(DROP_WRITES, &fc->flags)) { 83 ti->error = "Feature drop_writes duplicated"; 84 return -EINVAL; 85 } else if (test_bit(ERROR_WRITES, &fc->flags)) { 86 ti->error = "Feature drop_writes conflicts with feature error_writes"; 87 return -EINVAL; 88 } 89 90 continue; 91 } 92 93 /* 94 * error_writes 95 */ 96 if (!strcasecmp(arg_name, "error_writes")) { 97 if (test_and_set_bit(ERROR_WRITES, &fc->flags)) { 98 ti->error = "Feature error_writes duplicated"; 99 return -EINVAL; 100 101 } else if (test_bit(DROP_WRITES, &fc->flags)) { 102 ti->error = "Feature error_writes conflicts with feature drop_writes"; 103 return -EINVAL; 104 } 105 106 continue; 107 } 108 109 /* 110 * corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags> 111 */ 112 if (!strcasecmp(arg_name, "corrupt_bio_byte")) { 113 if (!argc) { 114 ti->error = "Feature corrupt_bio_byte requires parameters"; 115 return -EINVAL; 116 } 117 118 r = dm_read_arg(_args + 1, as, &fc->corrupt_bio_byte, &ti->error); 119 if (r) 120 return r; 121 argc--; 122 123 /* 124 * Direction r or w? 125 */ 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; 131 else { 132 ti->error = "Invalid corrupt bio direction (r or w)"; 133 return -EINVAL; 134 } 135 argc--; 136 137 /* 138 * Value of byte (0-255) to write in place of correct one. 139 */ 140 r = dm_read_arg(_args + 2, as, &fc->corrupt_bio_value, &ti->error); 141 if (r) 142 return r; 143 argc--; 144 145 /* 146 * Only corrupt bios with these flags set. 147 */ 148 r = dm_read_arg(_args + 3, as, &fc->corrupt_bio_flags, &ti->error); 149 if (r) 150 return r; 151 argc--; 152 153 continue; 154 } 155 156 ti->error = "Unrecognised flakey feature requested"; 157 return -EINVAL; 158 } 159 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"; 162 return -EINVAL; 163 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"; 166 return -EINVAL; 167 } 168 169 return 0; 170 } 171 172 /* 173 * Construct a flakey mapping: 174 * <dev_path> <offset> <up interval> <down interval> [<#feature args> [<arg>]*] 175 * 176 * Feature args: 177 * [drop_writes] 178 * [corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>] 179 * 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. 183 */ 184 static int flakey_ctr(struct dm_target *ti, unsigned int argc, char **argv) 185 { 186 static const struct dm_arg _args[] = { 187 {0, UINT_MAX, "Invalid up interval"}, 188 {0, UINT_MAX, "Invalid down interval"}, 189 }; 190 191 int r; 192 struct flakey_c *fc; 193 unsigned long long tmpll; 194 struct dm_arg_set as; 195 const char *devname; 196 char dummy; 197 198 as.argc = argc; 199 as.argv = argv; 200 201 if (argc < 4) { 202 ti->error = "Invalid argument count"; 203 return -EINVAL; 204 } 205 206 fc = kzalloc(sizeof(*fc), GFP_KERNEL); 207 if (!fc) { 208 ti->error = "Cannot allocate context"; 209 return -ENOMEM; 210 } 211 fc->start_time = jiffies; 212 213 devname = dm_shift_arg(&as); 214 215 r = -EINVAL; 216 if (sscanf(dm_shift_arg(&as), "%llu%c", &tmpll, &dummy) != 1) { 217 ti->error = "Invalid device sector"; 218 goto bad; 219 } 220 fc->start = tmpll; 221 222 r = dm_read_arg(_args, &as, &fc->up_interval, &ti->error); 223 if (r) 224 goto bad; 225 226 r = dm_read_arg(_args, &as, &fc->down_interval, &ti->error); 227 if (r) 228 goto bad; 229 230 if (!(fc->up_interval + fc->down_interval)) { 231 ti->error = "Total (up + down) interval is zero"; 232 r = -EINVAL; 233 goto bad; 234 } 235 236 if (fc->up_interval + fc->down_interval < fc->up_interval) { 237 ti->error = "Interval overflow"; 238 r = -EINVAL; 239 goto bad; 240 } 241 242 r = parse_features(&as, fc, ti); 243 if (r) 244 goto bad; 245 246 r = dm_get_device(ti, devname, dm_table_get_mode(ti->table), &fc->dev); 247 if (r) { 248 ti->error = "Device lookup failed"; 249 goto bad; 250 } 251 252 ti->num_flush_bios = 1; 253 ti->num_discard_bios = 1; 254 ti->per_io_data_size = sizeof(struct per_bio_data); 255 ti->private = fc; 256 return 0; 257 258 bad: 259 kfree(fc); 260 return r; 261 } 262 263 static void flakey_dtr(struct dm_target *ti) 264 { 265 struct flakey_c *fc = ti->private; 266 267 dm_put_device(ti, fc->dev); 268 kfree(fc); 269 } 270 271 static sector_t flakey_map_sector(struct dm_target *ti, sector_t bi_sector) 272 { 273 struct flakey_c *fc = ti->private; 274 275 return fc->start + dm_target_offset(ti, bi_sector); 276 } 277 278 static void flakey_map_bio(struct dm_target *ti, struct bio *bio) 279 { 280 struct flakey_c *fc = ti->private; 281 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); 286 } 287 288 static void corrupt_bio_data(struct bio *bio, struct flakey_c *fc) 289 { 290 unsigned bio_bytes = bio_cur_bytes(bio); 291 char *data = bio_data(bio); 292 293 /* 294 * Overwrite the Nth byte of the data returned. 295 */ 296 if (data && bio_bytes >= fc->corrupt_bio_byte) { 297 data[fc->corrupt_bio_byte - 1] = fc->corrupt_bio_value; 298 299 DMDEBUG("Corrupting data bio=%p by writing %u to byte %u " 300 "(rw=%c bi_opf=%u bi_sector=%llu cur_bytes=%u)\n", 301 bio, fc->corrupt_bio_value, fc->corrupt_bio_byte, 302 (bio_data_dir(bio) == WRITE) ? 'w' : 'r', bio->bi_opf, 303 (unsigned long long)bio->bi_iter.bi_sector, bio_bytes); 304 } 305 } 306 307 static int flakey_map(struct dm_target *ti, struct bio *bio) 308 { 309 struct flakey_c *fc = ti->private; 310 unsigned elapsed; 311 struct per_bio_data *pb = dm_per_bio_data(bio, sizeof(struct per_bio_data)); 312 pb->bio_submitted = false; 313 314 /* Do not fail reset zone */ 315 if (bio_op(bio) == REQ_OP_ZONE_RESET) 316 goto map_bio; 317 318 /* Are we alive ? */ 319 elapsed = (jiffies - fc->start_time) / HZ; 320 if (elapsed % (fc->up_interval + fc->down_interval) >= fc->up_interval) { 321 /* 322 * Flag this bio as submitted while down. 323 */ 324 pb->bio_submitted = true; 325 326 /* 327 * Error reads if neither corrupt_bio_byte or drop_writes or error_writes are set. 328 * Otherwise, flakey_end_io() will decide if the reads should be modified. 329 */ 330 if (bio_data_dir(bio) == READ) { 331 if (!fc->corrupt_bio_byte && !test_bit(DROP_WRITES, &fc->flags) && 332 !test_bit(ERROR_WRITES, &fc->flags)) 333 return DM_MAPIO_KILL; 334 goto map_bio; 335 } 336 337 /* 338 * Drop or error writes? 339 */ 340 if (test_bit(DROP_WRITES, &fc->flags)) { 341 bio_endio(bio); 342 return DM_MAPIO_SUBMITTED; 343 } 344 else if (test_bit(ERROR_WRITES, &fc->flags)) { 345 bio_io_error(bio); 346 return DM_MAPIO_SUBMITTED; 347 } 348 349 /* 350 * Corrupt matching writes. 351 */ 352 if (fc->corrupt_bio_byte && (fc->corrupt_bio_rw == WRITE)) { 353 if (all_corrupt_bio_flags_match(bio, fc)) 354 corrupt_bio_data(bio, fc); 355 goto map_bio; 356 } 357 358 /* 359 * By default, error all I/O. 360 */ 361 return DM_MAPIO_KILL; 362 } 363 364 map_bio: 365 flakey_map_bio(ti, bio); 366 367 return DM_MAPIO_REMAPPED; 368 } 369 370 static int flakey_end_io(struct dm_target *ti, struct bio *bio, 371 blk_status_t *error) 372 { 373 struct flakey_c *fc = ti->private; 374 struct per_bio_data *pb = dm_per_bio_data(bio, sizeof(struct per_bio_data)); 375 376 if (bio_op(bio) == REQ_OP_ZONE_RESET) 377 return DM_ENDIO_DONE; 378 379 if (!*error && pb->bio_submitted && (bio_data_dir(bio) == READ)) { 380 if (fc->corrupt_bio_byte && (fc->corrupt_bio_rw == READ) && 381 all_corrupt_bio_flags_match(bio, fc)) { 382 /* 383 * Corrupt successful matching READs while in down state. 384 */ 385 corrupt_bio_data(bio, fc); 386 387 } else if (!test_bit(DROP_WRITES, &fc->flags) && 388 !test_bit(ERROR_WRITES, &fc->flags)) { 389 /* 390 * Error read during the down_interval if drop_writes 391 * and error_writes were not configured. 392 */ 393 *error = BLK_STS_IOERR; 394 } 395 } 396 397 return DM_ENDIO_DONE; 398 } 399 400 static void flakey_status(struct dm_target *ti, status_type_t type, 401 unsigned status_flags, char *result, unsigned maxlen) 402 { 403 unsigned sz = 0; 404 struct flakey_c *fc = ti->private; 405 unsigned drop_writes, error_writes; 406 407 switch (type) { 408 case STATUSTYPE_INFO: 409 result[0] = '\0'; 410 break; 411 412 case STATUSTYPE_TABLE: 413 DMEMIT("%s %llu %u %u ", fc->dev->name, 414 (unsigned long long)fc->start, fc->up_interval, 415 fc->down_interval); 416 417 drop_writes = test_bit(DROP_WRITES, &fc->flags); 418 error_writes = test_bit(ERROR_WRITES, &fc->flags); 419 DMEMIT("%u ", drop_writes + error_writes + (fc->corrupt_bio_byte > 0) * 5); 420 421 if (drop_writes) 422 DMEMIT("drop_writes "); 423 else if (error_writes) 424 DMEMIT("error_writes "); 425 426 if (fc->corrupt_bio_byte) 427 DMEMIT("corrupt_bio_byte %u %c %u %u ", 428 fc->corrupt_bio_byte, 429 (fc->corrupt_bio_rw == WRITE) ? 'w' : 'r', 430 fc->corrupt_bio_value, fc->corrupt_bio_flags); 431 432 break; 433 } 434 } 435 436 static int flakey_prepare_ioctl(struct dm_target *ti, struct block_device **bdev) 437 { 438 struct flakey_c *fc = ti->private; 439 440 *bdev = fc->dev->bdev; 441 442 /* 443 * Only pass ioctls through if the device sizes match exactly. 444 */ 445 if (fc->start || 446 ti->len != i_size_read((*bdev)->bd_inode) >> SECTOR_SHIFT) 447 return 1; 448 return 0; 449 } 450 451 #ifdef CONFIG_BLK_DEV_ZONED 452 static int flakey_report_zones(struct dm_target *ti, sector_t sector, 453 struct blk_zone *zones, unsigned int *nr_zones, 454 gfp_t gfp_mask) 455 { 456 struct flakey_c *fc = ti->private; 457 int ret; 458 459 /* Do report and remap it */ 460 ret = blkdev_report_zones(fc->dev->bdev, flakey_map_sector(ti, sector), 461 zones, nr_zones, gfp_mask); 462 if (ret != 0) 463 return ret; 464 465 if (*nr_zones) 466 dm_remap_zone_report(ti, fc->start, zones, nr_zones); 467 return 0; 468 } 469 #endif 470 471 static int flakey_iterate_devices(struct dm_target *ti, iterate_devices_callout_fn fn, void *data) 472 { 473 struct flakey_c *fc = ti->private; 474 475 return fn(ti, fc->dev, fc->start, ti->len, data); 476 } 477 478 static struct target_type flakey_target = { 479 .name = "flakey", 480 .version = {1, 5, 0}, 481 #ifdef CONFIG_BLK_DEV_ZONED 482 .features = DM_TARGET_ZONED_HM, 483 .report_zones = flakey_report_zones, 484 #endif 485 .module = THIS_MODULE, 486 .ctr = flakey_ctr, 487 .dtr = flakey_dtr, 488 .map = flakey_map, 489 .end_io = flakey_end_io, 490 .status = flakey_status, 491 .prepare_ioctl = flakey_prepare_ioctl, 492 .iterate_devices = flakey_iterate_devices, 493 }; 494 495 static int __init dm_flakey_init(void) 496 { 497 int r = dm_register_target(&flakey_target); 498 499 if (r < 0) 500 DMERR("register failed %d", r); 501 502 return r; 503 } 504 505 static void __exit dm_flakey_exit(void) 506 { 507 dm_unregister_target(&flakey_target); 508 } 509 510 /* Module hooks */ 511 module_init(dm_flakey_init); 512 module_exit(dm_flakey_exit); 513 514 MODULE_DESCRIPTION(DM_NAME " flakey target"); 515 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>"); 516 MODULE_LICENSE("GPL"); 517