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