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.
33 * A mode can be one-shot or recurrent with the recurrance being
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 "".
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
65 #include <linux/raid/md.h>
66
67
68 static void faulty_fail(struct bio *bio, int error)
69 {
70 struct bio *b = bio->bi_private;
71
72 b->bi_size = bio->bi_size;
73 b->bi_sector = bio->bi_sector;
74
75 bio_put(bio);
76
77 bio_io_error(b);
78 }
79
80 typedef struct faulty_conf {
81 int period[Modes];
82 atomic_t counters[Modes];
83 sector_t faults[MaxFault];
84 int modes[MaxFault];
85 int nfaults;
86 mdk_rdev_t *rdev;
87 } conf_t;
88
89 static int check_mode(conf_t *conf, int mode)
90 {
91 if (conf->period[mode] == 0 &&
92 atomic_read(&conf->counters[mode]) <= 0)
93 return 0; /* no failure, no decrement */
94
95
96 if (atomic_dec_and_test(&conf->counters[mode])) {
97 if (conf->period[mode])
98 atomic_set(&conf->counters[mode], conf->period[mode]);
99 return 1;
100 }
101 return 0;
102 }
103
104 static int check_sector(conf_t *conf, sector_t start, sector_t end, int dir)
105 {
106 /* If we find a ReadFixable sector, we fix it ... */
107 int i;
108 for (i=0; i<conf->nfaults; i++)
109 if (conf->faults[i] >= start &&
110 conf->faults[i] < end) {
111 /* found it ... */
112 switch (conf->modes[i] * 2 + dir) {
113 case WritePersistent*2+WRITE: return 1;
114 case ReadPersistent*2+READ: return 1;
115 case ReadFixable*2+READ: return 1;
116 case ReadFixable*2+WRITE:
117 conf->modes[i] = NoPersist;
118 return 0;
119 case AllPersist*2+READ:
120 case AllPersist*2+WRITE: return 1;
121 default:
122 return 0;
123 }
124 }
125 return 0;
126 }
127
128 static void add_sector(conf_t *conf, sector_t start, int mode)
129 {
130 int i;
131 int n = conf->nfaults;
132 for (i=0; i<conf->nfaults; i++)
133 if (conf->faults[i] == start) {
134 switch(mode) {
135 case NoPersist: conf->modes[i] = mode; return;
136 case WritePersistent:
137 if (conf->modes[i] == ReadPersistent ||
138 conf->modes[i] == ReadFixable)
139 conf->modes[i] = AllPersist;
140 else
141 conf->modes[i] = WritePersistent;
142 return;
143 case ReadPersistent:
144 if (conf->modes[i] == WritePersistent)
145 conf->modes[i] = AllPersist;
146 else
147 conf->modes[i] = ReadPersistent;
148 return;
149 case ReadFixable:
150 if (conf->modes[i] == WritePersistent ||
151 conf->modes[i] == ReadPersistent)
152 conf->modes[i] = AllPersist;
153 else
154 conf->modes[i] = ReadFixable;
155 return;
156 }
157 } else if (conf->modes[i] == NoPersist)
158 n = i;
159
160 if (n >= MaxFault)
161 return;
162 conf->faults[n] = start;
163 conf->modes[n] = mode;
164 if (conf->nfaults == n)
165 conf->nfaults = n+1;
166 }
167
168 static int make_request(struct request_queue *q, struct bio *bio)
169 {
170 mddev_t *mddev = q->queuedata;
171 conf_t *conf = (conf_t*)mddev->private;
172 int failit = 0;
173
174 if (bio_data_dir(bio) == WRITE) {
175 /* write request */
176 if (atomic_read(&conf->counters[WriteAll])) {
177 /* special case - don't decrement, don't generic_make_request,
178 * just fail immediately
179 */
180 bio_endio(bio, -EIO);
181 return 0;
182 }
183
184 if (check_sector(conf, bio->bi_sector, bio->bi_sector+(bio->bi_size>>9),
185 WRITE))
186 failit = 1;
187 if (check_mode(conf, WritePersistent)) {
188 add_sector(conf, bio->bi_sector, WritePersistent);
189 failit = 1;
190 }
191 if (check_mode(conf, WriteTransient))
192 failit = 1;
193 } else {
194 /* read request */
195 if (check_sector(conf, bio->bi_sector, bio->bi_sector + (bio->bi_size>>9),
196 READ))
197 failit = 1;
198 if (check_mode(conf, ReadTransient))
199 failit = 1;
200 if (check_mode(conf, ReadPersistent)) {
201 add_sector(conf, bio->bi_sector, ReadPersistent);
202 failit = 1;
203 }
204 if (check_mode(conf, ReadFixable)) {
205 add_sector(conf, bio->bi_sector, ReadFixable);
206 failit = 1;
207 }
208 }
209 if (failit) {
210 struct bio *b = bio_clone(bio, GFP_NOIO);
211 b->bi_bdev = conf->rdev->bdev;
212 b->bi_private = bio;
213 b->bi_end_io = faulty_fail;
214 generic_make_request(b);
215 return 0;
216 } else {
217 bio->bi_bdev = conf->rdev->bdev;
218 return 1;
219 }
220 }
221
222 static void status(struct seq_file *seq, mddev_t *mddev)
223 {
224 conf_t *conf = (conf_t*)mddev->private;
225 int n;
226
227 if ((n=atomic_read(&conf->counters[WriteTransient])) != 0)
228 seq_printf(seq, " WriteTransient=%d(%d)",
229 n, conf->period[WriteTransient]);
230
231 if ((n=atomic_read(&conf->counters[ReadTransient])) != 0)
232 seq_printf(seq, " ReadTransient=%d(%d)",
233 n, conf->period[ReadTransient]);
234
235 if ((n=atomic_read(&conf->counters[WritePersistent])) != 0)
236 seq_printf(seq, " WritePersistent=%d(%d)",
237 n, conf->period[WritePersistent]);
238
239 if ((n=atomic_read(&conf->counters[ReadPersistent])) != 0)
240 seq_printf(seq, " ReadPersistent=%d(%d)",
241 n, conf->period[ReadPersistent]);
242
243
244 if ((n=atomic_read(&conf->counters[ReadFixable])) != 0)
245 seq_printf(seq, " ReadFixable=%d(%d)",
246 n, conf->period[ReadFixable]);
247
248 if ((n=atomic_read(&conf->counters[WriteAll])) != 0)
249 seq_printf(seq, " WriteAll");
250
251 seq_printf(seq, " nfaults=%d", conf->nfaults);
252 }
253
254
255 static int reconfig(mddev_t *mddev, int layout, int chunk_size)
256 {
257 int mode = layout & ModeMask;
258 int count = layout >> ModeShift;
259 conf_t *conf = mddev->private;
260
261 if (chunk_size != -1)
262 return -EINVAL;
263
264 /* new layout */
265 if (mode == ClearFaults)
266 conf->nfaults = 0;
267 else if (mode == ClearErrors) {
268 int i;
269 for (i=0 ; i < Modes ; i++) {
270 conf->period[i] = 0;
271 atomic_set(&conf->counters[i], 0);
272 }
273 } else if (mode < Modes) {
274 conf->period[mode] = count;
275 if (!count) count++;
276 atomic_set(&conf->counters[mode], count);
277 } else
278 return -EINVAL;
279 mddev->layout = -1; /* makes sure further changes come through */
280 return 0;
281 }
282
283 static int run(mddev_t *mddev)
284 {
285 mdk_rdev_t *rdev;
286 struct list_head *tmp;
287 int i;
288
289 conf_t *conf = kmalloc(sizeof(*conf), GFP_KERNEL);
290
291 for (i=0; i<Modes; i++) {
292 atomic_set(&conf->counters[i], 0);
293 conf->period[i] = 0;
294 }
295 conf->nfaults = 0;
296
297 rdev_for_each(rdev, tmp, mddev)
298 conf->rdev = rdev;
299
300 mddev->array_size = mddev->size;
301 mddev->private = conf;
302
303 reconfig(mddev, mddev->layout, -1);
304
305 return 0;
306 }
307
308 static int stop(mddev_t *mddev)
309 {
310 conf_t *conf = (conf_t *)mddev->private;
311
312 kfree(conf);
313 mddev->private = NULL;
314 return 0;
315 }
316
317 static struct mdk_personality faulty_personality =
318 {
319 .name = "faulty",
320 .level = LEVEL_FAULTY,
321 .owner = THIS_MODULE,
322 .make_request = make_request,
323 .run = run,
324 .stop = stop,
325 .status = status,
326 .reconfig = reconfig,
327 };
328
329 static int __init raid_init(void)
330 {
331 return register_md_personality(&faulty_personality);
332 }
333
334 static void raid_exit(void)
335 {
336 unregister_md_personality(&faulty_personality);
337 }
338
339 module_init(raid_init);
340 module_exit(raid_exit);
341 MODULE_LICENSE("GPL");
342 MODULE_ALIAS("md-personality-10"); /* faulty */
343 MODULE_ALIAS("md-faulty");
344 MODULE_ALIAS("md-level--5");
345
|
This page was automatically generated by the
LXR engine.
|