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