]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * faulty.c : Multiple Devices driver for Linux | |
3 | * | |
4 | * Copyright (C) 2004 Neil Brown | |
5 | * | |
6 | * fautly-device-simulator personality for md | |
7 | * | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2, or (at your option) | |
12 | * any later version. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * (for example /usr/src/linux/COPYING); if not, write to the Free | |
16 | * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
17 | */ | |
18 | ||
19 | ||
20 | /* | |
21 | * The "faulty" personality causes some requests to fail. | |
22 | * | |
23 | * Possible failure modes are: | |
24 | * reads fail "randomly" but succeed on retry | |
25 | * writes fail "randomly" but succeed on retry | |
26 | * reads for some address fail and then persist until a write | |
27 | * reads for some address fail and then persist irrespective of write | |
28 | * writes for some address fail and persist | |
29 | * all writes fail | |
30 | * | |
31 | * Different modes can be active at a time, but only | |
32 | * one can be set at array creation. Others can be added later. | |
25985edc | 33 | * A mode can be one-shot or recurrent with the recurrence being |
1da177e4 LT |
34 | * once in every N requests. |
35 | * The bottom 5 bits of the "layout" indicate the mode. The | |
36 | * remainder indicate a period, or 0 for one-shot. | |
37 | * | |
38 | * There is an implementation limit on the number of concurrently | |
39 | * persisting-faulty blocks. When a new fault is requested that would | |
40 | * exceed the limit, it is ignored. | |
41 | * All current faults can be clear using a layout of "0". | |
42 | * | |
43 | * Requests are always sent to the device. If they are to fail, | |
44 | * we clone the bio and insert a new b_end_io into the chain. | |
45 | */ | |
46 | ||
47 | #define WriteTransient 0 | |
48 | #define ReadTransient 1 | |
49 | #define WritePersistent 2 | |
50 | #define ReadPersistent 3 | |
51 | #define WriteAll 4 /* doesn't go to device */ | |
52 | #define ReadFixable 5 | |
53 | #define Modes 6 | |
54 | ||
55 | #define ClearErrors 31 | |
56 | #define ClearFaults 30 | |
57 | ||
58 | #define AllPersist 100 /* internal use only */ | |
59 | #define NoPersist 101 | |
60 | ||
61 | #define ModeMask 0x1f | |
62 | #define ModeShift 5 | |
63 | ||
64 | #define MaxFault 50 | |
bff61975 | 65 | #include <linux/blkdev.h> |
056075c7 | 66 | #include <linux/module.h> |
bff61975 | 67 | #include <linux/raid/md_u.h> |
5a0e3ad6 | 68 | #include <linux/slab.h> |
43b2e5d8 | 69 | #include "md.h" |
bff61975 | 70 | #include <linux/seq_file.h> |
1da177e4 LT |
71 | |
72 | ||
6712ecf8 | 73 | static void faulty_fail(struct bio *bio, int error) |
1da177e4 LT |
74 | { |
75 | struct bio *b = bio->bi_private; | |
76 | ||
77 | b->bi_size = bio->bi_size; | |
78 | b->bi_sector = bio->bi_sector; | |
79 | ||
6712ecf8 | 80 | bio_put(bio); |
1da177e4 | 81 | |
6712ecf8 | 82 | bio_io_error(b); |
1da177e4 LT |
83 | } |
84 | ||
8f1ae43d | 85 | struct faulty_conf { |
1da177e4 LT |
86 | int period[Modes]; |
87 | atomic_t counters[Modes]; | |
88 | sector_t faults[MaxFault]; | |
89 | int modes[MaxFault]; | |
90 | int nfaults; | |
3cb03002 | 91 | struct md_rdev *rdev; |
8f1ae43d | 92 | }; |
1da177e4 | 93 | |
8f1ae43d | 94 | static int check_mode(struct faulty_conf *conf, int mode) |
1da177e4 LT |
95 | { |
96 | if (conf->period[mode] == 0 && | |
97 | atomic_read(&conf->counters[mode]) <= 0) | |
98 | return 0; /* no failure, no decrement */ | |
99 | ||
100 | ||
101 | if (atomic_dec_and_test(&conf->counters[mode])) { | |
102 | if (conf->period[mode]) | |
103 | atomic_set(&conf->counters[mode], conf->period[mode]); | |
104 | return 1; | |
105 | } | |
106 | return 0; | |
107 | } | |
108 | ||
8f1ae43d | 109 | static int check_sector(struct faulty_conf *conf, sector_t start, sector_t end, int dir) |
1da177e4 LT |
110 | { |
111 | /* If we find a ReadFixable sector, we fix it ... */ | |
112 | int i; | |
113 | for (i=0; i<conf->nfaults; i++) | |
114 | if (conf->faults[i] >= start && | |
115 | conf->faults[i] < end) { | |
116 | /* found it ... */ | |
117 | switch (conf->modes[i] * 2 + dir) { | |
118 | case WritePersistent*2+WRITE: return 1; | |
119 | case ReadPersistent*2+READ: return 1; | |
120 | case ReadFixable*2+READ: return 1; | |
121 | case ReadFixable*2+WRITE: | |
122 | conf->modes[i] = NoPersist; | |
123 | return 0; | |
124 | case AllPersist*2+READ: | |
125 | case AllPersist*2+WRITE: return 1; | |
126 | default: | |
127 | return 0; | |
128 | } | |
129 | } | |
130 | return 0; | |
131 | } | |
132 | ||
8f1ae43d | 133 | static void add_sector(struct faulty_conf *conf, sector_t start, int mode) |
1da177e4 LT |
134 | { |
135 | int i; | |
136 | int n = conf->nfaults; | |
137 | for (i=0; i<conf->nfaults; i++) | |
138 | if (conf->faults[i] == start) { | |
139 | switch(mode) { | |
140 | case NoPersist: conf->modes[i] = mode; return; | |
141 | case WritePersistent: | |
142 | if (conf->modes[i] == ReadPersistent || | |
143 | conf->modes[i] == ReadFixable) | |
144 | conf->modes[i] = AllPersist; | |
145 | else | |
146 | conf->modes[i] = WritePersistent; | |
147 | return; | |
148 | case ReadPersistent: | |
149 | if (conf->modes[i] == WritePersistent) | |
150 | conf->modes[i] = AllPersist; | |
151 | else | |
152 | conf->modes[i] = ReadPersistent; | |
153 | return; | |
154 | case ReadFixable: | |
155 | if (conf->modes[i] == WritePersistent || | |
156 | conf->modes[i] == ReadPersistent) | |
157 | conf->modes[i] = AllPersist; | |
158 | else | |
159 | conf->modes[i] = ReadFixable; | |
160 | return; | |
161 | } | |
162 | } else if (conf->modes[i] == NoPersist) | |
163 | n = i; | |
164 | ||
165 | if (n >= MaxFault) | |
166 | return; | |
167 | conf->faults[n] = start; | |
168 | conf->modes[n] = mode; | |
169 | if (conf->nfaults == n) | |
170 | conf->nfaults = n+1; | |
171 | } | |
172 | ||
b4fdcb02 | 173 | static void make_request(struct mddev *mddev, struct bio *bio) |
1da177e4 | 174 | { |
8f1ae43d | 175 | struct faulty_conf *conf = mddev->private; |
1da177e4 LT |
176 | int failit = 0; |
177 | ||
802ba064 | 178 | if (bio_data_dir(bio) == WRITE) { |
1da177e4 LT |
179 | /* write request */ |
180 | if (atomic_read(&conf->counters[WriteAll])) { | |
181 | /* special case - don't decrement, don't generic_make_request, | |
182 | * just fail immediately | |
183 | */ | |
6712ecf8 | 184 | bio_endio(bio, -EIO); |
5a7bbad2 | 185 | return; |
1da177e4 LT |
186 | } |
187 | ||
f73a1c7d | 188 | if (check_sector(conf, bio->bi_sector, bio_end_sector(bio), WRITE)) |
1da177e4 LT |
189 | failit = 1; |
190 | if (check_mode(conf, WritePersistent)) { | |
191 | add_sector(conf, bio->bi_sector, WritePersistent); | |
192 | failit = 1; | |
193 | } | |
194 | if (check_mode(conf, WriteTransient)) | |
195 | failit = 1; | |
196 | } else { | |
197 | /* read request */ | |
f73a1c7d | 198 | if (check_sector(conf, bio->bi_sector, bio_end_sector(bio), READ)) |
1da177e4 LT |
199 | failit = 1; |
200 | if (check_mode(conf, ReadTransient)) | |
201 | failit = 1; | |
202 | if (check_mode(conf, ReadPersistent)) { | |
203 | add_sector(conf, bio->bi_sector, ReadPersistent); | |
204 | failit = 1; | |
205 | } | |
206 | if (check_mode(conf, ReadFixable)) { | |
207 | add_sector(conf, bio->bi_sector, ReadFixable); | |
208 | failit = 1; | |
209 | } | |
210 | } | |
211 | if (failit) { | |
a167f663 | 212 | struct bio *b = bio_clone_mddev(bio, GFP_NOIO, mddev); |
5a7bbad2 | 213 | |
1da177e4 LT |
214 | b->bi_bdev = conf->rdev->bdev; |
215 | b->bi_private = bio; | |
216 | b->bi_end_io = faulty_fail; | |
5a7bbad2 CH |
217 | bio = b; |
218 | } else | |
1da177e4 | 219 | bio->bi_bdev = conf->rdev->bdev; |
5a7bbad2 CH |
220 | |
221 | generic_make_request(bio); | |
1da177e4 LT |
222 | } |
223 | ||
fd01b88c | 224 | static void status(struct seq_file *seq, struct mddev *mddev) |
1da177e4 | 225 | { |
8f1ae43d | 226 | struct faulty_conf *conf = mddev->private; |
1da177e4 LT |
227 | int n; |
228 | ||
229 | if ((n=atomic_read(&conf->counters[WriteTransient])) != 0) | |
230 | seq_printf(seq, " WriteTransient=%d(%d)", | |
231 | n, conf->period[WriteTransient]); | |
232 | ||
233 | if ((n=atomic_read(&conf->counters[ReadTransient])) != 0) | |
234 | seq_printf(seq, " ReadTransient=%d(%d)", | |
235 | n, conf->period[ReadTransient]); | |
236 | ||
237 | if ((n=atomic_read(&conf->counters[WritePersistent])) != 0) | |
238 | seq_printf(seq, " WritePersistent=%d(%d)", | |
239 | n, conf->period[WritePersistent]); | |
240 | ||
241 | if ((n=atomic_read(&conf->counters[ReadPersistent])) != 0) | |
242 | seq_printf(seq, " ReadPersistent=%d(%d)", | |
243 | n, conf->period[ReadPersistent]); | |
244 | ||
245 | ||
246 | if ((n=atomic_read(&conf->counters[ReadFixable])) != 0) | |
247 | seq_printf(seq, " ReadFixable=%d(%d)", | |
248 | n, conf->period[ReadFixable]); | |
249 | ||
250 | if ((n=atomic_read(&conf->counters[WriteAll])) != 0) | |
251 | seq_printf(seq, " WriteAll"); | |
252 | ||
253 | seq_printf(seq, " nfaults=%d", conf->nfaults); | |
254 | } | |
255 | ||
256 | ||
fd01b88c | 257 | static int reshape(struct mddev *mddev) |
1da177e4 | 258 | { |
597a711b N |
259 | int mode = mddev->new_layout & ModeMask; |
260 | int count = mddev->new_layout >> ModeShift; | |
8f1ae43d | 261 | struct faulty_conf *conf = mddev->private; |
1da177e4 | 262 | |
597a711b N |
263 | if (mddev->new_layout < 0) |
264 | return 0; | |
1da177e4 LT |
265 | |
266 | /* new layout */ | |
267 | if (mode == ClearFaults) | |
268 | conf->nfaults = 0; | |
269 | else if (mode == ClearErrors) { | |
270 | int i; | |
271 | for (i=0 ; i < Modes ; i++) { | |
272 | conf->period[i] = 0; | |
273 | atomic_set(&conf->counters[i], 0); | |
274 | } | |
275 | } else if (mode < Modes) { | |
276 | conf->period[mode] = count; | |
277 | if (!count) count++; | |
278 | atomic_set(&conf->counters[mode], count); | |
279 | } else | |
280 | return -EINVAL; | |
597a711b | 281 | mddev->new_layout = -1; |
1da177e4 LT |
282 | mddev->layout = -1; /* makes sure further changes come through */ |
283 | return 0; | |
284 | } | |
285 | ||
fd01b88c | 286 | static sector_t faulty_size(struct mddev *mddev, sector_t sectors, int raid_disks) |
80c3a6ce DW |
287 | { |
288 | WARN_ONCE(raid_disks, | |
289 | "%s does not support generic reshape\n", __func__); | |
290 | ||
291 | if (sectors == 0) | |
292 | return mddev->dev_sectors; | |
293 | ||
294 | return sectors; | |
295 | } | |
296 | ||
fd01b88c | 297 | static int run(struct mddev *mddev) |
1da177e4 | 298 | { |
3cb03002 | 299 | struct md_rdev *rdev; |
1da177e4 | 300 | int i; |
8f1ae43d | 301 | struct faulty_conf *conf; |
1da177e4 | 302 | |
0894cc30 AN |
303 | if (md_check_no_bitmap(mddev)) |
304 | return -EINVAL; | |
305 | ||
306 | conf = kmalloc(sizeof(*conf), GFP_KERNEL); | |
08ff39f1 SW |
307 | if (!conf) |
308 | return -ENOMEM; | |
1da177e4 LT |
309 | |
310 | for (i=0; i<Modes; i++) { | |
311 | atomic_set(&conf->counters[i], 0); | |
312 | conf->period[i] = 0; | |
313 | } | |
314 | conf->nfaults = 0; | |
315 | ||
0be1fecd | 316 | rdev_for_each(rdev, mddev) { |
1da177e4 | 317 | conf->rdev = rdev; |
0be1fecd ES |
318 | disk_stack_limits(mddev->gendisk, rdev->bdev, |
319 | rdev->data_offset << 9); | |
320 | } | |
1da177e4 | 321 | |
1f403624 | 322 | md_set_array_sectors(mddev, faulty_size(mddev, 0, 0)); |
1da177e4 LT |
323 | mddev->private = conf; |
324 | ||
50ac168a | 325 | reshape(mddev); |
1da177e4 LT |
326 | |
327 | return 0; | |
328 | } | |
329 | ||
fd01b88c | 330 | static int stop(struct mddev *mddev) |
1da177e4 | 331 | { |
8f1ae43d | 332 | struct faulty_conf *conf = mddev->private; |
1da177e4 LT |
333 | |
334 | kfree(conf); | |
335 | mddev->private = NULL; | |
336 | return 0; | |
337 | } | |
338 | ||
84fc4b56 | 339 | static struct md_personality faulty_personality = |
1da177e4 LT |
340 | { |
341 | .name = "faulty", | |
2604b703 | 342 | .level = LEVEL_FAULTY, |
1da177e4 LT |
343 | .owner = THIS_MODULE, |
344 | .make_request = make_request, | |
345 | .run = run, | |
346 | .stop = stop, | |
347 | .status = status, | |
50ac168a | 348 | .check_reshape = reshape, |
80c3a6ce | 349 | .size = faulty_size, |
1da177e4 LT |
350 | }; |
351 | ||
352 | static int __init raid_init(void) | |
353 | { | |
2604b703 | 354 | return register_md_personality(&faulty_personality); |
1da177e4 LT |
355 | } |
356 | ||
357 | static void raid_exit(void) | |
358 | { | |
2604b703 | 359 | unregister_md_personality(&faulty_personality); |
1da177e4 LT |
360 | } |
361 | ||
362 | module_init(raid_init); | |
363 | module_exit(raid_exit); | |
364 | MODULE_LICENSE("GPL"); | |
0efb9e61 | 365 | MODULE_DESCRIPTION("Fault injection personality for MD"); |
1da177e4 | 366 | MODULE_ALIAS("md-personality-10"); /* faulty */ |
d9d166c2 | 367 | MODULE_ALIAS("md-faulty"); |
2604b703 | 368 | MODULE_ALIAS("md-level--5"); |