]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/md/dm-flakey.c
Merge tag 'for-f2fs-4.13' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk...
[mirror_ubuntu-artful-kernel.git] / drivers / md / dm-flakey.c
CommitLineData
3407ef52
JB
1/*
2 * Copyright (C) 2003 Sistina Software (UK) Limited.
a3998799 3 * Copyright (C) 2004, 2010-2011 Red Hat, Inc. All rights reserved.
3407ef52
JB
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
a3998799 18#define all_corrupt_bio_flags_match(bio, fc) \
1eff9d32 19 (((bio)->bi_opf & (fc)->corrupt_bio_flags) == (fc)->corrupt_bio_flags)
a3998799 20
3407ef52
JB
21/*
22 * Flakey: Used for testing only, simulates intermittent,
23 * catastrophic device failure.
24 */
25struct flakey_c {
26 struct dm_dev *dev;
27 unsigned long start_time;
28 sector_t start;
29 unsigned up_interval;
30 unsigned down_interval;
b26f5e3d 31 unsigned long flags;
a3998799
MS
32 unsigned corrupt_bio_byte;
33 unsigned corrupt_bio_rw;
34 unsigned corrupt_bio_value;
35 unsigned corrupt_bio_flags;
3407ef52
JB
36};
37
b26f5e3d 38enum feature_flag_bits {
ef548c55
MS
39 DROP_WRITES,
40 ERROR_WRITES
b26f5e3d
MS
41};
42
c7cfdf59
MP
43struct per_bio_data {
44 bool bio_submitted;
45};
46
b26f5e3d
MS
47static int parse_features(struct dm_arg_set *as, struct flakey_c *fc,
48 struct dm_target *ti)
dfd068b0
MS
49{
50 int r;
51 unsigned argc;
52 const char *arg_name;
53
54 static struct dm_arg _args[] = {
a3998799
MS
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"},
dfd068b0
MS
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)
a3998799 67 return r;
dfd068b0 68
a3998799 69 while (argc) {
dfd068b0
MS
70 arg_name = dm_shift_arg(as);
71 argc--;
72
b26f5e3d
MS
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;
ef548c55
MS
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;
b26f5e3d
MS
99 }
100
101 continue;
102 }
103
a3998799
MS
104 /*
105 * corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>
106 */
107 if (!strcasecmp(arg_name, "corrupt_bio_byte")) {
68e58a29 108 if (!argc) {
a3998799 109 ti->error = "Feature corrupt_bio_byte requires parameters";
68e58a29
MS
110 return -EINVAL;
111 }
a3998799
MS
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
dfd068b0 151 ti->error = "Unrecognised flakey feature requested";
a3998799 152 return -EINVAL;
dfd068b0
MS
153 }
154
a3998799
MS
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;
ef548c55
MS
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;
a3998799
MS
162 }
163
164 return 0;
dfd068b0
MS
165}
166
3407ef52 167/*
dfd068b0
MS
168 * Construct a flakey mapping:
169 * <dev_path> <offset> <up interval> <down interval> [<#feature args> [<arg>]*]
b26f5e3d
MS
170 *
171 * Feature args:
172 * [drop_writes]
a3998799
MS
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.
3407ef52
JB
178 */
179static int flakey_ctr(struct dm_target *ti, unsigned int argc, char **argv)
180{
dfd068b0
MS
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;
3407ef52 187 struct flakey_c *fc;
dfd068b0
MS
188 unsigned long long tmpll;
189 struct dm_arg_set as;
190 const char *devname;
31998ef1 191 char dummy;
3407ef52 192
dfd068b0
MS
193 as.argc = argc;
194 as.argv = argv;
195
196 if (argc < 4) {
197 ti->error = "Invalid argument count";
3407ef52
JB
198 return -EINVAL;
199 }
200
b26f5e3d 201 fc = kzalloc(sizeof(*fc), GFP_KERNEL);
3407ef52 202 if (!fc) {
75e3a0f5 203 ti->error = "Cannot allocate context";
3407ef52
JB
204 return -ENOMEM;
205 }
206 fc->start_time = jiffies;
207
dfd068b0
MS
208 devname = dm_shift_arg(&as);
209
e80d1c80 210 r = -EINVAL;
31998ef1 211 if (sscanf(dm_shift_arg(&as), "%llu%c", &tmpll, &dummy) != 1) {
dfd068b0 212 ti->error = "Invalid device sector";
3407ef52
JB
213 goto bad;
214 }
dfd068b0 215 fc->start = tmpll;
3407ef52 216
dfd068b0
MS
217 r = dm_read_arg(_args, &as, &fc->up_interval, &ti->error);
218 if (r)
3407ef52 219 goto bad;
3407ef52 220
dfd068b0
MS
221 r = dm_read_arg(_args, &as, &fc->down_interval, &ti->error);
222 if (r)
3407ef52 223 goto bad;
3407ef52
JB
224
225 if (!(fc->up_interval + fc->down_interval)) {
dfd068b0 226 ti->error = "Total (up + down) interval is zero";
bff7e067 227 r = -EINVAL;
3407ef52
JB
228 goto bad;
229 }
230
231 if (fc->up_interval + fc->down_interval < fc->up_interval) {
dfd068b0 232 ti->error = "Interval overflow";
bff7e067 233 r = -EINVAL;
3407ef52
JB
234 goto bad;
235 }
236
b26f5e3d 237 r = parse_features(&as, fc, ti);
dfd068b0
MS
238 if (r)
239 goto bad;
240
e80d1c80
VG
241 r = dm_get_device(ti, devname, dm_table_get_mode(ti->table), &fc->dev);
242 if (r) {
dfd068b0 243 ti->error = "Device lookup failed";
3407ef52
JB
244 goto bad;
245 }
246
55a62eef
AK
247 ti->num_flush_bios = 1;
248 ti->num_discard_bios = 1;
30187e1d 249 ti->per_io_data_size = sizeof(struct per_bio_data);
3407ef52
JB
250 ti->private = fc;
251 return 0;
252
253bad:
254 kfree(fc);
e80d1c80 255 return r;
3407ef52
JB
256}
257
258static 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
266static sector_t flakey_map_sector(struct dm_target *ti, sector_t bi_sector)
267{
268 struct flakey_c *fc = ti->private;
269
30e4171b 270 return fc->start + dm_target_offset(ti, bi_sector);
3407ef52
JB
271}
272
273static 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;
124c4454 278 if (bio_sectors(bio) || bio_op(bio) == REQ_OP_ZONE_RESET)
4f024f37
KO
279 bio->bi_iter.bi_sector =
280 flakey_map_sector(ti, bio->bi_iter.bi_sector);
3407ef52
JB
281}
282
a3998799
MS
283static 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 "
1eff9d32 295 "(rw=%c bi_opf=%u bi_sector=%llu cur_bytes=%u)\n",
a3998799 296 bio, fc->corrupt_bio_value, fc->corrupt_bio_byte,
1eff9d32 297 (bio_data_dir(bio) == WRITE) ? 'w' : 'r', bio->bi_opf,
4f024f37 298 (unsigned long long)bio->bi_iter.bi_sector, bio_bytes);
a3998799
MS
299 }
300}
301
7de3ee57 302static int flakey_map(struct dm_target *ti, struct bio *bio)
3407ef52
JB
303{
304 struct flakey_c *fc = ti->private;
305 unsigned elapsed;
c7cfdf59
MP
306 struct per_bio_data *pb = dm_per_bio_data(bio, sizeof(struct per_bio_data));
307 pb->bio_submitted = false;
3407ef52 308
124c4454
DLM
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
3407ef52
JB
317 /* Are we alive ? */
318 elapsed = (jiffies - fc->start_time) / HZ;
b26f5e3d 319 if (elapsed % (fc->up_interval + fc->down_interval) >= fc->up_interval) {
a3998799
MS
320 /*
321 * Flag this bio as submitted while down.
322 */
c7cfdf59 323 pb->bio_submitted = true;
a3998799
MS
324
325 /*
ef548c55 326 * Error reads if neither corrupt_bio_byte or drop_writes or error_writes are set.
299f6230 327 * Otherwise, flakey_end_io() will decide if the reads should be modified.
a3998799 328 */
99f3c90d 329 if (bio_data_dir(bio) == READ) {
ef548c55
MS
330 if (!fc->corrupt_bio_byte && !test_bit(DROP_WRITES, &fc->flags) &&
331 !test_bit(ERROR_WRITES, &fc->flags))
846785e6 332 return DM_MAPIO_KILL;
299f6230 333 goto map_bio;
99f3c90d 334 }
b26f5e3d
MS
335
336 /*
ef548c55 337 * Drop or error writes?
b26f5e3d
MS
338 */
339 if (test_bit(DROP_WRITES, &fc->flags)) {
4246a0b6 340 bio_endio(bio);
a3998799
MS
341 return DM_MAPIO_SUBMITTED;
342 }
ef548c55
MS
343 else if (test_bit(ERROR_WRITES, &fc->flags)) {
344 bio_io_error(bio);
345 return DM_MAPIO_SUBMITTED;
346 }
a3998799
MS
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);
b26f5e3d
MS
354 goto map_bio;
355 }
356
357 /*
a3998799 358 * By default, error all I/O.
b26f5e3d 359 */
846785e6 360 return DM_MAPIO_KILL;
b26f5e3d 361 }
3407ef52 362
b26f5e3d 363map_bio:
3407ef52
JB
364 flakey_map_bio(ti, bio);
365
366 return DM_MAPIO_REMAPPED;
367}
368
4e4cbee9 369static int flakey_end_io(struct dm_target *ti, struct bio *bio,
124c4454 370 blk_status_t *error)
a3998799
MS
371{
372 struct flakey_c *fc = ti->private;
c7cfdf59 373 struct per_bio_data *pb = dm_per_bio_data(bio, sizeof(struct per_bio_data));
a3998799 374
124c4454
DLM
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
1be56909 383 if (!*error && pb->bio_submitted && (bio_data_dir(bio) == READ)) {
299f6230
MS
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 */
99f3c90d 389 corrupt_bio_data(bio, fc);
299f6230 390
ef548c55
MS
391 } else if (!test_bit(DROP_WRITES, &fc->flags) &&
392 !test_bit(ERROR_WRITES, &fc->flags)) {
299f6230
MS
393 /*
394 * Error read during the down_interval if drop_writes
ef548c55 395 * and error_writes were not configured.
299f6230 396 */
4e4cbee9 397 *error = BLK_STS_IOERR;
299f6230 398 }
99f3c90d 399 }
a3998799 400
1be56909 401 return DM_ENDIO_DONE;
a3998799
MS
402}
403
fd7c092e
MP
404static void flakey_status(struct dm_target *ti, status_type_t type,
405 unsigned status_flags, char *result, unsigned maxlen)
3407ef52 406{
b26f5e3d 407 unsigned sz = 0;
3407ef52 408 struct flakey_c *fc = ti->private;
ef548c55 409 unsigned drop_writes, error_writes;
3407ef52
JB
410
411 switch (type) {
412 case STATUSTYPE_INFO:
413 result[0] = '\0';
414 break;
415
416 case STATUSTYPE_TABLE:
b26f5e3d
MS
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);
ef548c55
MS
422 error_writes = test_bit(ERROR_WRITES, &fc->flags);
423 DMEMIT("%u ", drop_writes + error_writes + (fc->corrupt_bio_byte > 0) * 5);
a3998799 424
b26f5e3d
MS
425 if (drop_writes)
426 DMEMIT("drop_writes ");
ef548c55
MS
427 else if (error_writes)
428 DMEMIT("error_writes ");
a3998799
MS
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
3407ef52
JB
436 break;
437 }
3407ef52
JB
438}
439
e56f81e0
CH
440static int flakey_prepare_ioctl(struct dm_target *ti,
441 struct block_device **bdev, fmode_t *mode)
3407ef52
JB
442{
443 struct flakey_c *fc = ti->private;
e56f81e0
CH
444
445 *bdev = fc->dev->bdev;
3407ef52 446
ec8013be
PB
447 /*
448 * Only pass ioctls through if the device sizes match exactly.
449 */
450 if (fc->start ||
e56f81e0
CH
451 ti->len != i_size_read((*bdev)->bd_inode) >> SECTOR_SHIFT)
452 return 1;
453 return 0;
3407ef52
JB
454}
455
3407ef52
JB
456static 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
463static struct target_type flakey_target = {
464 .name = "flakey",
124c4454
DLM
465 .version = {1, 5, 0},
466 .features = DM_TARGET_ZONED_HM,
3407ef52
JB
467 .module = THIS_MODULE,
468 .ctr = flakey_ctr,
469 .dtr = flakey_dtr,
470 .map = flakey_map,
a3998799 471 .end_io = flakey_end_io,
3407ef52 472 .status = flakey_status,
e56f81e0 473 .prepare_ioctl = flakey_prepare_ioctl,
3407ef52
JB
474 .iterate_devices = flakey_iterate_devices,
475};
476
477static 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
487static void __exit dm_flakey_exit(void)
488{
489 dm_unregister_target(&flakey_target);
490}
491
492/* Module hooks */
493module_init(dm_flakey_init);
494module_exit(dm_flakey_exit);
495
496MODULE_DESCRIPTION(DM_NAME " flakey target");
497MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
498MODULE_LICENSE("GPL");