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_rw & (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 }; 41 42 struct per_bio_data { 43 bool bio_submitted; 44 }; 45 46 static int parse_features(struct dm_arg_set *as, struct flakey_c *fc, 47 struct dm_target *ti) 48 { 49 int r; 50 unsigned argc; 51 const char *arg_name; 52 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"}, 58 }; 59 60 /* No feature arguments supplied. */ 61 if (!as->argc) 62 return 0; 63 64 r = dm_read_arg_group(_args, as, &argc, &ti->error); 65 if (r) 66 return r; 67 68 while (argc) { 69 arg_name = dm_shift_arg(as); 70 argc--; 71 72 /* 73 * drop_writes 74 */ 75 if (!strcasecmp(arg_name, "drop_writes")) { 76 if (test_and_set_bit(DROP_WRITES, &fc->flags)) { 77 ti->error = "Feature drop_writes duplicated"; 78 return -EINVAL; 79 } 80 81 continue; 82 } 83 84 /* 85 * corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags> 86 */ 87 if (!strcasecmp(arg_name, "corrupt_bio_byte")) { 88 if (!argc) { 89 ti->error = "Feature corrupt_bio_byte requires parameters"; 90 return -EINVAL; 91 } 92 93 r = dm_read_arg(_args + 1, as, &fc->corrupt_bio_byte, &ti->error); 94 if (r) 95 return r; 96 argc--; 97 98 /* 99 * Direction r or w? 100 */ 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; 106 else { 107 ti->error = "Invalid corrupt bio direction (r or w)"; 108 return -EINVAL; 109 } 110 argc--; 111 112 /* 113 * Value of byte (0-255) to write in place of correct one. 114 */ 115 r = dm_read_arg(_args + 2, as, &fc->corrupt_bio_value, &ti->error); 116 if (r) 117 return r; 118 argc--; 119 120 /* 121 * Only corrupt bios with these flags set. 122 */ 123 r = dm_read_arg(_args + 3, as, &fc->corrupt_bio_flags, &ti->error); 124 if (r) 125 return r; 126 argc--; 127 128 continue; 129 } 130 131 ti->error = "Unrecognised flakey feature requested"; 132 return -EINVAL; 133 } 134 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"; 137 return -EINVAL; 138 } 139 140 return 0; 141 } 142 143 /* 144 * Construct a flakey mapping: 145 * <dev_path> <offset> <up interval> <down interval> [<#feature args> [<arg>]*] 146 * 147 * Feature args: 148 * [drop_writes] 149 * [corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>] 150 * 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. 154 */ 155 static int flakey_ctr(struct dm_target *ti, unsigned int argc, char **argv) 156 { 157 static struct dm_arg _args[] = { 158 {0, UINT_MAX, "Invalid up interval"}, 159 {0, UINT_MAX, "Invalid down interval"}, 160 }; 161 162 int r; 163 struct flakey_c *fc; 164 unsigned long long tmpll; 165 struct dm_arg_set as; 166 const char *devname; 167 char dummy; 168 169 as.argc = argc; 170 as.argv = argv; 171 172 if (argc < 4) { 173 ti->error = "Invalid argument count"; 174 return -EINVAL; 175 } 176 177 fc = kzalloc(sizeof(*fc), GFP_KERNEL); 178 if (!fc) { 179 ti->error = "Cannot allocate context"; 180 return -ENOMEM; 181 } 182 fc->start_time = jiffies; 183 184 devname = dm_shift_arg(&as); 185 186 if (sscanf(dm_shift_arg(&as), "%llu%c", &tmpll, &dummy) != 1) { 187 ti->error = "Invalid device sector"; 188 goto bad; 189 } 190 fc->start = tmpll; 191 192 r = dm_read_arg(_args, &as, &fc->up_interval, &ti->error); 193 if (r) 194 goto bad; 195 196 r = dm_read_arg(_args, &as, &fc->down_interval, &ti->error); 197 if (r) 198 goto bad; 199 200 if (!(fc->up_interval + fc->down_interval)) { 201 ti->error = "Total (up + down) interval is zero"; 202 goto bad; 203 } 204 205 if (fc->up_interval + fc->down_interval < fc->up_interval) { 206 ti->error = "Interval overflow"; 207 goto bad; 208 } 209 210 r = parse_features(&as, fc, ti); 211 if (r) 212 goto bad; 213 214 if (dm_get_device(ti, devname, dm_table_get_mode(ti->table), &fc->dev)) { 215 ti->error = "Device lookup failed"; 216 goto bad; 217 } 218 219 ti->num_flush_bios = 1; 220 ti->num_discard_bios = 1; 221 ti->per_bio_data_size = sizeof(struct per_bio_data); 222 ti->private = fc; 223 return 0; 224 225 bad: 226 kfree(fc); 227 return -EINVAL; 228 } 229 230 static void flakey_dtr(struct dm_target *ti) 231 { 232 struct flakey_c *fc = ti->private; 233 234 dm_put_device(ti, fc->dev); 235 kfree(fc); 236 } 237 238 static sector_t flakey_map_sector(struct dm_target *ti, sector_t bi_sector) 239 { 240 struct flakey_c *fc = ti->private; 241 242 return fc->start + dm_target_offset(ti, bi_sector); 243 } 244 245 static void flakey_map_bio(struct dm_target *ti, struct bio *bio) 246 { 247 struct flakey_c *fc = ti->private; 248 249 bio->bi_bdev = fc->dev->bdev; 250 if (bio_sectors(bio)) 251 bio->bi_iter.bi_sector = 252 flakey_map_sector(ti, bio->bi_iter.bi_sector); 253 } 254 255 static void corrupt_bio_data(struct bio *bio, struct flakey_c *fc) 256 { 257 unsigned bio_bytes = bio_cur_bytes(bio); 258 char *data = bio_data(bio); 259 260 /* 261 * Overwrite the Nth byte of the data returned. 262 */ 263 if (data && bio_bytes >= fc->corrupt_bio_byte) { 264 data[fc->corrupt_bio_byte - 1] = fc->corrupt_bio_value; 265 266 DMDEBUG("Corrupting data bio=%p by writing %u to byte %u " 267 "(rw=%c bi_rw=%lu bi_sector=%llu cur_bytes=%u)\n", 268 bio, fc->corrupt_bio_value, fc->corrupt_bio_byte, 269 (bio_data_dir(bio) == WRITE) ? 'w' : 'r', bio->bi_rw, 270 (unsigned long long)bio->bi_iter.bi_sector, bio_bytes); 271 } 272 } 273 274 static int flakey_map(struct dm_target *ti, struct bio *bio) 275 { 276 struct flakey_c *fc = ti->private; 277 unsigned elapsed; 278 struct per_bio_data *pb = dm_per_bio_data(bio, sizeof(struct per_bio_data)); 279 pb->bio_submitted = false; 280 281 /* Are we alive ? */ 282 elapsed = (jiffies - fc->start_time) / HZ; 283 if (elapsed % (fc->up_interval + fc->down_interval) >= fc->up_interval) { 284 /* 285 * Flag this bio as submitted while down. 286 */ 287 pb->bio_submitted = true; 288 289 /* 290 * Map reads as normal. 291 */ 292 if (bio_data_dir(bio) == READ) 293 goto map_bio; 294 295 /* 296 * Drop writes? 297 */ 298 if (test_bit(DROP_WRITES, &fc->flags)) { 299 bio_endio(bio, 0); 300 return DM_MAPIO_SUBMITTED; 301 } 302 303 /* 304 * Corrupt matching writes. 305 */ 306 if (fc->corrupt_bio_byte && (fc->corrupt_bio_rw == WRITE)) { 307 if (all_corrupt_bio_flags_match(bio, fc)) 308 corrupt_bio_data(bio, fc); 309 goto map_bio; 310 } 311 312 /* 313 * By default, error all I/O. 314 */ 315 return -EIO; 316 } 317 318 map_bio: 319 flakey_map_bio(ti, bio); 320 321 return DM_MAPIO_REMAPPED; 322 } 323 324 static int flakey_end_io(struct dm_target *ti, struct bio *bio, int error) 325 { 326 struct flakey_c *fc = ti->private; 327 struct per_bio_data *pb = dm_per_bio_data(bio, sizeof(struct per_bio_data)); 328 329 /* 330 * Corrupt successful READs while in down state. 331 * If flags were specified, only corrupt those that match. 332 */ 333 if (fc->corrupt_bio_byte && !error && pb->bio_submitted && 334 (bio_data_dir(bio) == READ) && (fc->corrupt_bio_rw == READ) && 335 all_corrupt_bio_flags_match(bio, fc)) 336 corrupt_bio_data(bio, fc); 337 338 return error; 339 } 340 341 static void flakey_status(struct dm_target *ti, status_type_t type, 342 unsigned status_flags, char *result, unsigned maxlen) 343 { 344 unsigned sz = 0; 345 struct flakey_c *fc = ti->private; 346 unsigned drop_writes; 347 348 switch (type) { 349 case STATUSTYPE_INFO: 350 result[0] = '\0'; 351 break; 352 353 case STATUSTYPE_TABLE: 354 DMEMIT("%s %llu %u %u ", fc->dev->name, 355 (unsigned long long)fc->start, fc->up_interval, 356 fc->down_interval); 357 358 drop_writes = test_bit(DROP_WRITES, &fc->flags); 359 DMEMIT("%u ", drop_writes + (fc->corrupt_bio_byte > 0) * 5); 360 361 if (drop_writes) 362 DMEMIT("drop_writes "); 363 364 if (fc->corrupt_bio_byte) 365 DMEMIT("corrupt_bio_byte %u %c %u %u ", 366 fc->corrupt_bio_byte, 367 (fc->corrupt_bio_rw == WRITE) ? 'w' : 'r', 368 fc->corrupt_bio_value, fc->corrupt_bio_flags); 369 370 break; 371 } 372 } 373 374 static int flakey_ioctl(struct dm_target *ti, unsigned int cmd, unsigned long arg) 375 { 376 struct flakey_c *fc = ti->private; 377 struct dm_dev *dev = fc->dev; 378 int r = 0; 379 380 /* 381 * Only pass ioctls through if the device sizes match exactly. 382 */ 383 if (fc->start || 384 ti->len != i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT) 385 r = scsi_verify_blk_ioctl(NULL, cmd); 386 387 return r ? : __blkdev_driver_ioctl(dev->bdev, dev->mode, cmd, arg); 388 } 389 390 static int flakey_merge(struct dm_target *ti, struct bvec_merge_data *bvm, 391 struct bio_vec *biovec, int max_size) 392 { 393 struct flakey_c *fc = ti->private; 394 struct request_queue *q = bdev_get_queue(fc->dev->bdev); 395 396 if (!q->merge_bvec_fn) 397 return max_size; 398 399 bvm->bi_bdev = fc->dev->bdev; 400 bvm->bi_sector = flakey_map_sector(ti, bvm->bi_sector); 401 402 return min(max_size, q->merge_bvec_fn(q, bvm, biovec)); 403 } 404 405 static int flakey_iterate_devices(struct dm_target *ti, iterate_devices_callout_fn fn, void *data) 406 { 407 struct flakey_c *fc = ti->private; 408 409 return fn(ti, fc->dev, fc->start, ti->len, data); 410 } 411 412 static struct target_type flakey_target = { 413 .name = "flakey", 414 .version = {1, 3, 1}, 415 .module = THIS_MODULE, 416 .ctr = flakey_ctr, 417 .dtr = flakey_dtr, 418 .map = flakey_map, 419 .end_io = flakey_end_io, 420 .status = flakey_status, 421 .ioctl = flakey_ioctl, 422 .merge = flakey_merge, 423 .iterate_devices = flakey_iterate_devices, 424 }; 425 426 static int __init dm_flakey_init(void) 427 { 428 int r = dm_register_target(&flakey_target); 429 430 if (r < 0) 431 DMERR("register failed %d", r); 432 433 return r; 434 } 435 436 static void __exit dm_flakey_exit(void) 437 { 438 dm_unregister_target(&flakey_target); 439 } 440 441 /* Module hooks */ 442 module_init(dm_flakey_init); 443 module_exit(dm_flakey_exit); 444 445 MODULE_DESCRIPTION(DM_NAME " flakey target"); 446 MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>"); 447 MODULE_LICENSE("GPL"); 448