]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/md/dm-flakey.c
Merge git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf
[karo-tx-linux.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 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");