dm flakey: add corrupt_bio_byte feature
[linux-2.6.git] / drivers / md / dm-flakey.c
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");