Branch data Line data Source code
1 : : /*
2 : : * Copyright (C) 2003 Sistina Software Limited.
3 : : * Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved.
4 : : *
5 : : * This file is released under the GPL.
6 : : */
7 : :
8 : : #include "dm-bio-record.h"
9 : :
10 : : #include <linux/init.h>
11 : : #include <linux/mempool.h>
12 : : #include <linux/module.h>
13 : : #include <linux/pagemap.h>
14 : : #include <linux/slab.h>
15 : : #include <linux/workqueue.h>
16 : : #include <linux/device-mapper.h>
17 : : #include <linux/dm-io.h>
18 : : #include <linux/dm-dirty-log.h>
19 : : #include <linux/dm-kcopyd.h>
20 : : #include <linux/dm-region-hash.h>
21 : :
22 : : #define DM_MSG_PREFIX "raid1"
23 : :
24 : : #define MAX_RECOVERY 1 /* Maximum number of regions recovered in parallel. */
25 : :
26 : : #define MAX_NR_MIRRORS (DM_KCOPYD_MAX_REGIONS + 1)
27 : :
28 : : #define DM_RAID1_HANDLE_ERRORS 0x01
29 : : #define DM_RAID1_KEEP_LOG 0x02
30 : : #define errors_handled(p) ((p)->features & DM_RAID1_HANDLE_ERRORS)
31 : : #define keep_log(p) ((p)->features & DM_RAID1_KEEP_LOG)
32 : :
33 : : static DECLARE_WAIT_QUEUE_HEAD(_kmirrord_recovery_stopped);
34 : :
35 : : /*-----------------------------------------------------------------
36 : : * Mirror set structures.
37 : : *---------------------------------------------------------------*/
38 : : enum dm_raid1_error {
39 : : DM_RAID1_WRITE_ERROR,
40 : : DM_RAID1_FLUSH_ERROR,
41 : : DM_RAID1_SYNC_ERROR,
42 : : DM_RAID1_READ_ERROR
43 : : };
44 : :
45 : : struct mirror {
46 : : struct mirror_set *ms;
47 : : atomic_t error_count;
48 : : unsigned long error_type;
49 : : struct dm_dev *dev;
50 : : sector_t offset;
51 : : };
52 : :
53 : : struct mirror_set {
54 : : struct dm_target *ti;
55 : : struct list_head list;
56 : :
57 : : uint64_t features;
58 : :
59 : : spinlock_t lock; /* protects the lists */
60 : : struct bio_list reads;
61 : : struct bio_list writes;
62 : : struct bio_list failures;
63 : : struct bio_list holds; /* bios are waiting until suspend */
64 : :
65 : : struct dm_region_hash *rh;
66 : : struct dm_kcopyd_client *kcopyd_client;
67 : : struct dm_io_client *io_client;
68 : :
69 : : /* recovery */
70 : : region_t nr_regions;
71 : : int in_sync;
72 : : int log_failure;
73 : : int leg_failure;
74 : : atomic_t suspend;
75 : :
76 : : atomic_t default_mirror; /* Default mirror */
77 : :
78 : : struct workqueue_struct *kmirrord_wq;
79 : : struct work_struct kmirrord_work;
80 : : struct timer_list timer;
81 : : unsigned long timer_pending;
82 : :
83 : : struct work_struct trigger_event;
84 : :
85 : : unsigned nr_mirrors;
86 : : struct mirror mirror[0];
87 : : };
88 : :
89 : : DECLARE_DM_KCOPYD_THROTTLE_WITH_MODULE_PARM(raid1_resync_throttle,
90 : : "A percentage of time allocated for raid resynchronization");
91 : :
92 : 0 : static void wakeup_mirrord(void *context)
93 : : {
94 : 0 : struct mirror_set *ms = context;
95 : :
96 : 0 : queue_work(ms->kmirrord_wq, &ms->kmirrord_work);
97 : 0 : }
98 : :
99 : 0 : static void delayed_wake_fn(struct timer_list *t)
100 : : {
101 : 0 : struct mirror_set *ms = from_timer(ms, t, timer);
102 : :
103 : 0 : clear_bit(0, &ms->timer_pending);
104 : 0 : wakeup_mirrord(ms);
105 : 0 : }
106 : :
107 : 0 : static void delayed_wake(struct mirror_set *ms)
108 : : {
109 [ # # ]: 0 : if (test_and_set_bit(0, &ms->timer_pending))
110 : : return;
111 : :
112 : 0 : ms->timer.expires = jiffies + HZ / 5;
113 : 0 : add_timer(&ms->timer);
114 : : }
115 : :
116 : 0 : static void wakeup_all_recovery_waiters(void *context)
117 : : {
118 : 0 : wake_up_all(&_kmirrord_recovery_stopped);
119 : 0 : }
120 : :
121 : 0 : static void queue_bio(struct mirror_set *ms, struct bio *bio, int rw)
122 : : {
123 : 0 : unsigned long flags;
124 : 0 : int should_wake = 0;
125 : 0 : struct bio_list *bl;
126 : :
127 [ # # ]: 0 : bl = (rw == WRITE) ? &ms->writes : &ms->reads;
128 : 0 : spin_lock_irqsave(&ms->lock, flags);
129 : 0 : should_wake = !(bl->head);
130 [ # # ]: 0 : bio_list_add(bl, bio);
131 : 0 : spin_unlock_irqrestore(&ms->lock, flags);
132 : :
133 [ # # ]: 0 : if (should_wake)
134 : 0 : wakeup_mirrord(ms);
135 : 0 : }
136 : :
137 : 0 : static void dispatch_bios(void *context, struct bio_list *bio_list)
138 : : {
139 : 0 : struct mirror_set *ms = context;
140 : 0 : struct bio *bio;
141 : :
142 [ # # # # ]: 0 : while ((bio = bio_list_pop(bio_list)))
143 : 0 : queue_bio(ms, bio, WRITE);
144 : 0 : }
145 : :
146 : : struct dm_raid1_bio_record {
147 : : struct mirror *m;
148 : : /* if details->bi_disk == NULL, details were not saved */
149 : : struct dm_bio_details details;
150 : : region_t write_region;
151 : : };
152 : :
153 : : /*
154 : : * Every mirror should look like this one.
155 : : */
156 : : #define DEFAULT_MIRROR 0
157 : :
158 : : /*
159 : : * This is yucky. We squirrel the mirror struct away inside
160 : : * bi_next for read/write buffers. This is safe since the bh
161 : : * doesn't get submitted to the lower levels of block layer.
162 : : */
163 : 0 : static struct mirror *bio_get_m(struct bio *bio)
164 : : {
165 : 0 : return (struct mirror *) bio->bi_next;
166 : : }
167 : :
168 : 0 : static void bio_set_m(struct bio *bio, struct mirror *m)
169 : : {
170 : 0 : bio->bi_next = (struct bio *) m;
171 : : }
172 : :
173 : 0 : static struct mirror *get_default_mirror(struct mirror_set *ms)
174 : : {
175 : 0 : return &ms->mirror[atomic_read(&ms->default_mirror)];
176 : : }
177 : :
178 : 0 : static void set_default_mirror(struct mirror *m)
179 : : {
180 : 0 : struct mirror_set *ms = m->ms;
181 : 0 : struct mirror *m0 = &(ms->mirror[0]);
182 : :
183 : 0 : atomic_set(&ms->default_mirror, m - m0);
184 : 0 : }
185 : :
186 : 0 : static struct mirror *get_valid_mirror(struct mirror_set *ms)
187 : : {
188 : 0 : struct mirror *m;
189 : :
190 [ # # ]: 0 : for (m = ms->mirror; m < ms->mirror + ms->nr_mirrors; m++)
191 [ # # ]: 0 : if (!atomic_read(&m->error_count))
192 : 0 : return m;
193 : :
194 : : return NULL;
195 : : }
196 : :
197 : : /* fail_mirror
198 : : * @m: mirror device to fail
199 : : * @error_type: one of the enum's, DM_RAID1_*_ERROR
200 : : *
201 : : * If errors are being handled, record the type of
202 : : * error encountered for this device. If this type
203 : : * of error has already been recorded, we can return;
204 : : * otherwise, we must signal userspace by triggering
205 : : * an event. Additionally, if the device is the
206 : : * primary device, we must choose a new primary, but
207 : : * only if the mirror is in-sync.
208 : : *
209 : : * This function must not block.
210 : : */
211 : 0 : static void fail_mirror(struct mirror *m, enum dm_raid1_error error_type)
212 : : {
213 : 0 : struct mirror_set *ms = m->ms;
214 : 0 : struct mirror *new;
215 : :
216 : 0 : ms->leg_failure = 1;
217 : :
218 : : /*
219 : : * error_count is used for nothing more than a
220 : : * simple way to tell if a device has encountered
221 : : * errors.
222 : : */
223 : 0 : atomic_inc(&m->error_count);
224 : :
225 [ # # ]: 0 : if (test_and_set_bit(error_type, &m->error_type))
226 : : return;
227 : :
228 [ # # ]: 0 : if (!errors_handled(ms))
229 : : return;
230 : :
231 [ # # ]: 0 : if (m != get_default_mirror(ms))
232 : 0 : goto out;
233 : :
234 [ # # # # ]: 0 : if (!ms->in_sync && !keep_log(ms)) {
235 : : /*
236 : : * Better to issue requests to same failing device
237 : : * than to risk returning corrupt data.
238 : : */
239 : 0 : DMERR("Primary mirror (%s) failed while out-of-sync: "
240 : : "Reads may fail.", m->dev->name);
241 : 0 : goto out;
242 : : }
243 : :
244 : 0 : new = get_valid_mirror(ms);
245 [ # # ]: 0 : if (new)
246 : 0 : set_default_mirror(new);
247 : : else
248 : 0 : DMWARN("All sides of mirror have failed.");
249 : :
250 : 0 : out:
251 : 0 : schedule_work(&ms->trigger_event);
252 : : }
253 : :
254 : 0 : static int mirror_flush(struct dm_target *ti)
255 : : {
256 : 0 : struct mirror_set *ms = ti->private;
257 : 0 : unsigned long error_bits;
258 : :
259 : 0 : unsigned int i;
260 : 0 : struct dm_io_region io[MAX_NR_MIRRORS];
261 : 0 : struct mirror *m;
262 : 0 : struct dm_io_request io_req = {
263 : : .bi_op = REQ_OP_WRITE,
264 : : .bi_op_flags = REQ_PREFLUSH | REQ_SYNC,
265 : : .mem.type = DM_IO_KMEM,
266 : : .mem.ptr.addr = NULL,
267 : 0 : .client = ms->io_client,
268 : : };
269 : :
270 [ # # ]: 0 : for (i = 0, m = ms->mirror; i < ms->nr_mirrors; i++, m++) {
271 : 0 : io[i].bdev = m->dev->bdev;
272 : 0 : io[i].sector = 0;
273 : 0 : io[i].count = 0;
274 : : }
275 : :
276 : 0 : error_bits = -1;
277 : 0 : dm_io(&io_req, ms->nr_mirrors, io, &error_bits);
278 [ # # ]: 0 : if (unlikely(error_bits != 0)) {
279 [ # # ]: 0 : for (i = 0; i < ms->nr_mirrors; i++)
280 [ # # ]: 0 : if (test_bit(i, &error_bits))
281 : 0 : fail_mirror(ms->mirror + i,
282 : : DM_RAID1_FLUSH_ERROR);
283 : : return -EIO;
284 : : }
285 : :
286 : : return 0;
287 : : }
288 : :
289 : : /*-----------------------------------------------------------------
290 : : * Recovery.
291 : : *
292 : : * When a mirror is first activated we may find that some regions
293 : : * are in the no-sync state. We have to recover these by
294 : : * recopying from the default mirror to all the others.
295 : : *---------------------------------------------------------------*/
296 : 0 : static void recovery_complete(int read_err, unsigned long write_err,
297 : : void *context)
298 : : {
299 : 0 : struct dm_region *reg = context;
300 : 0 : struct mirror_set *ms = dm_rh_region_context(reg);
301 : 0 : int m, bit = 0;
302 : :
303 [ # # ]: 0 : if (read_err) {
304 : : /* Read error means the failure of default mirror. */
305 [ # # ]: 0 : DMERR_LIMIT("Unable to read primary mirror during recovery");
306 : 0 : fail_mirror(get_default_mirror(ms), DM_RAID1_SYNC_ERROR);
307 : : }
308 : :
309 [ # # ]: 0 : if (write_err) {
310 [ # # ]: 0 : DMERR_LIMIT("Write error during recovery (error = 0x%lx)",
311 : : write_err);
312 : : /*
313 : : * Bits correspond to devices (excluding default mirror).
314 : : * The default mirror cannot change during recovery.
315 : : */
316 [ # # ]: 0 : for (m = 0; m < ms->nr_mirrors; m++) {
317 [ # # ]: 0 : if (&ms->mirror[m] == get_default_mirror(ms))
318 : 0 : continue;
319 [ # # ]: 0 : if (test_bit(bit, &write_err))
320 : 0 : fail_mirror(ms->mirror + m,
321 : : DM_RAID1_SYNC_ERROR);
322 : 0 : bit++;
323 : : }
324 : : }
325 : :
326 [ # # # # ]: 0 : dm_rh_recovery_end(reg, !(read_err || write_err));
327 : 0 : }
328 : :
329 : 0 : static void recover(struct mirror_set *ms, struct dm_region *reg)
330 : : {
331 : 0 : unsigned i;
332 : 0 : struct dm_io_region from, to[DM_KCOPYD_MAX_REGIONS], *dest;
333 : 0 : struct mirror *m;
334 : 0 : unsigned long flags = 0;
335 : 0 : region_t key = dm_rh_get_region_key(reg);
336 : 0 : sector_t region_size = dm_rh_get_region_size(ms->rh);
337 : :
338 : : /* fill in the source */
339 : 0 : m = get_default_mirror(ms);
340 : 0 : from.bdev = m->dev->bdev;
341 : 0 : from.sector = m->offset + dm_rh_region_to_sector(ms->rh, key);
342 [ # # ]: 0 : if (key == (ms->nr_regions - 1)) {
343 : : /*
344 : : * The final region may be smaller than
345 : : * region_size.
346 : : */
347 : 0 : from.count = ms->ti->len & (region_size - 1);
348 [ # # ]: 0 : if (!from.count)
349 : 0 : from.count = region_size;
350 : : } else
351 : 0 : from.count = region_size;
352 : :
353 : : /* fill in the destinations */
354 [ # # ]: 0 : for (i = 0, dest = to; i < ms->nr_mirrors; i++) {
355 [ # # ]: 0 : if (&ms->mirror[i] == get_default_mirror(ms))
356 : 0 : continue;
357 : :
358 : 0 : m = ms->mirror + i;
359 : 0 : dest->bdev = m->dev->bdev;
360 : 0 : dest->sector = m->offset + dm_rh_region_to_sector(ms->rh, key);
361 : 0 : dest->count = from.count;
362 : 0 : dest++;
363 : : }
364 : :
365 : : /* hand to kcopyd */
366 [ # # ]: 0 : if (!errors_handled(ms))
367 : 0 : set_bit(DM_KCOPYD_IGNORE_ERROR, &flags);
368 : :
369 : 0 : dm_kcopyd_copy(ms->kcopyd_client, &from, ms->nr_mirrors - 1, to,
370 : : flags, recovery_complete, reg);
371 : 0 : }
372 : :
373 : 0 : static void reset_ms_flags(struct mirror_set *ms)
374 : : {
375 : 0 : unsigned int m;
376 : :
377 : 0 : ms->leg_failure = 0;
378 [ # # ]: 0 : for (m = 0; m < ms->nr_mirrors; m++) {
379 : 0 : atomic_set(&(ms->mirror[m].error_count), 0);
380 : 0 : ms->mirror[m].error_type = 0;
381 : : }
382 : : }
383 : :
384 : 0 : static void do_recovery(struct mirror_set *ms)
385 : : {
386 : 0 : struct dm_region *reg;
387 : 0 : struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
388 : :
389 : : /*
390 : : * Start quiescing some regions.
391 : : */
392 : 0 : dm_rh_recovery_prepare(ms->rh);
393 : :
394 : : /*
395 : : * Copy any already quiesced regions.
396 : : */
397 [ # # ]: 0 : while ((reg = dm_rh_recovery_start(ms->rh)))
398 : 0 : recover(ms, reg);
399 : :
400 : : /*
401 : : * Update the in sync flag.
402 : : */
403 [ # # ]: 0 : if (!ms->in_sync &&
404 [ # # ]: 0 : (log->type->get_sync_count(log) == ms->nr_regions)) {
405 : : /* the sync is complete */
406 : 0 : dm_table_event(ms->ti->table);
407 : 0 : ms->in_sync = 1;
408 : 0 : reset_ms_flags(ms);
409 : : }
410 : 0 : }
411 : :
412 : : /*-----------------------------------------------------------------
413 : : * Reads
414 : : *---------------------------------------------------------------*/
415 : : static struct mirror *choose_mirror(struct mirror_set *ms, sector_t sector)
416 : : {
417 : : struct mirror *m = get_default_mirror(ms);
418 : :
419 : : do {
420 : : if (likely(!atomic_read(&m->error_count)))
421 : : return m;
422 : :
423 : : if (m-- == ms->mirror)
424 : : m += ms->nr_mirrors;
425 : : } while (m != get_default_mirror(ms));
426 : :
427 : : return NULL;
428 : : }
429 : :
430 : : static int default_ok(struct mirror *m)
431 : : {
432 : : struct mirror *default_mirror = get_default_mirror(m->ms);
433 : :
434 : : return !atomic_read(&default_mirror->error_count);
435 : : }
436 : :
437 : 0 : static int mirror_available(struct mirror_set *ms, struct bio *bio)
438 : : {
439 : 0 : struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
440 : 0 : region_t region = dm_rh_bio_to_region(ms->rh, bio);
441 : :
442 [ # # ]: 0 : if (log->type->in_sync(log, region, 0))
443 : 0 : return choose_mirror(ms, bio->bi_iter.bi_sector) ? 1 : 0;
444 : :
445 : : return 0;
446 : : }
447 : :
448 : : /*
449 : : * remap a buffer to a particular mirror.
450 : : */
451 : 0 : static sector_t map_sector(struct mirror *m, struct bio *bio)
452 : : {
453 : 0 : if (unlikely(!bio->bi_iter.bi_size))
454 : : return 0;
455 : 0 : return m->offset + dm_target_offset(m->ms->ti, bio->bi_iter.bi_sector);
456 : : }
457 : :
458 : 0 : static void map_bio(struct mirror *m, struct bio *bio)
459 : : {
460 [ # # # # ]: 0 : bio_set_dev(bio, m->dev->bdev);
461 [ # # ]: 0 : bio->bi_iter.bi_sector = map_sector(m, bio);
462 : 0 : }
463 : :
464 : 0 : static void map_region(struct dm_io_region *io, struct mirror *m,
465 : : struct bio *bio)
466 : : {
467 : 0 : io->bdev = m->dev->bdev;
468 : 0 : io->sector = map_sector(m, bio);
469 : 0 : io->count = bio_sectors(bio);
470 : : }
471 : :
472 : 0 : static void hold_bio(struct mirror_set *ms, struct bio *bio)
473 : : {
474 : : /*
475 : : * Lock is required to avoid race condition during suspend
476 : : * process.
477 : : */
478 : 0 : spin_lock_irq(&ms->lock);
479 : :
480 [ # # ]: 0 : if (atomic_read(&ms->suspend)) {
481 : 0 : spin_unlock_irq(&ms->lock);
482 : :
483 : : /*
484 : : * If device is suspended, complete the bio.
485 : : */
486 [ # # ]: 0 : if (dm_noflush_suspending(ms->ti))
487 : 0 : bio->bi_status = BLK_STS_DM_REQUEUE;
488 : : else
489 : 0 : bio->bi_status = BLK_STS_IOERR;
490 : :
491 : 0 : bio_endio(bio);
492 : 0 : return;
493 : : }
494 : :
495 : : /*
496 : : * Hold bio until the suspend is complete.
497 : : */
498 [ # # ]: 0 : bio_list_add(&ms->holds, bio);
499 : 0 : spin_unlock_irq(&ms->lock);
500 : : }
501 : :
502 : : /*-----------------------------------------------------------------
503 : : * Reads
504 : : *---------------------------------------------------------------*/
505 : 0 : static void read_callback(unsigned long error, void *context)
506 : : {
507 : 0 : struct bio *bio = context;
508 : 0 : struct mirror *m;
509 : :
510 : 0 : m = bio_get_m(bio);
511 : 0 : bio_set_m(bio, NULL);
512 : :
513 [ # # ]: 0 : if (likely(!error)) {
514 : 0 : bio_endio(bio);
515 : 0 : return;
516 : : }
517 : :
518 : 0 : fail_mirror(m, DM_RAID1_READ_ERROR);
519 : :
520 [ # # # # ]: 0 : if (likely(default_ok(m)) || mirror_available(m->ms, bio)) {
521 [ # # ]: 0 : DMWARN_LIMIT("Read failure on mirror device %s. "
522 : : "Trying alternative device.",
523 : : m->dev->name);
524 : 0 : queue_bio(m->ms, bio, bio_data_dir(bio));
525 : 0 : return;
526 : : }
527 : :
528 [ # # ]: 0 : DMERR_LIMIT("Read failure on mirror device %s. Failing I/O.",
529 : : m->dev->name);
530 : 0 : bio_io_error(bio);
531 : : }
532 : :
533 : : /* Asynchronous read. */
534 : 0 : static void read_async_bio(struct mirror *m, struct bio *bio)
535 : : {
536 : 0 : struct dm_io_region io;
537 : 0 : struct dm_io_request io_req = {
538 : : .bi_op = REQ_OP_READ,
539 : : .bi_op_flags = 0,
540 : : .mem.type = DM_IO_BIO,
541 : : .mem.ptr.bio = bio,
542 : : .notify.fn = read_callback,
543 : : .notify.context = bio,
544 : 0 : .client = m->ms->io_client,
545 : : };
546 : :
547 [ # # ]: 0 : map_region(&io, m, bio);
548 : 0 : bio_set_m(bio, m);
549 [ # # ]: 0 : BUG_ON(dm_io(&io_req, 1, &io, NULL));
550 : 0 : }
551 : :
552 : 0 : static inline int region_in_sync(struct mirror_set *ms, region_t region,
553 : : int may_block)
554 : : {
555 : 0 : int state = dm_rh_get_state(ms->rh, region, may_block);
556 : 0 : return state == DM_RH_CLEAN || state == DM_RH_DIRTY;
557 : : }
558 : :
559 : 0 : static void do_reads(struct mirror_set *ms, struct bio_list *reads)
560 : : {
561 : 0 : region_t region;
562 : 0 : struct bio *bio;
563 : 0 : struct mirror *m;
564 : :
565 [ # # # # ]: 0 : while ((bio = bio_list_pop(reads))) {
566 : 0 : region = dm_rh_bio_to_region(ms->rh, bio);
567 : 0 : m = get_default_mirror(ms);
568 : :
569 : : /*
570 : : * We can only read balance if the region is in sync.
571 : : */
572 [ # # ]: 0 : if (likely(region_in_sync(ms, region, 1)))
573 : 0 : m = choose_mirror(ms, bio->bi_iter.bi_sector);
574 [ # # # # ]: 0 : else if (m && atomic_read(&m->error_count))
575 : 0 : m = NULL;
576 : :
577 [ # # ]: 0 : if (likely(m))
578 : 0 : read_async_bio(m, bio);
579 : : else
580 : 0 : bio_io_error(bio);
581 : : }
582 : 0 : }
583 : :
584 : : /*-----------------------------------------------------------------
585 : : * Writes.
586 : : *
587 : : * We do different things with the write io depending on the
588 : : * state of the region that it's in:
589 : : *
590 : : * SYNC: increment pending, use kcopyd to write to *all* mirrors
591 : : * RECOVERING: delay the io until recovery completes
592 : : * NOSYNC: increment pending, just write to the default mirror
593 : : *---------------------------------------------------------------*/
594 : :
595 : :
596 : 0 : static void write_callback(unsigned long error, void *context)
597 : : {
598 : 0 : unsigned i;
599 : 0 : struct bio *bio = (struct bio *) context;
600 : 0 : struct mirror_set *ms;
601 : 0 : int should_wake = 0;
602 : 0 : unsigned long flags;
603 : :
604 : 0 : ms = bio_get_m(bio)->ms;
605 : 0 : bio_set_m(bio, NULL);
606 : :
607 : : /*
608 : : * NOTE: We don't decrement the pending count here,
609 : : * instead it is done by the targets endio function.
610 : : * This way we handle both writes to SYNC and NOSYNC
611 : : * regions with the same code.
612 : : */
613 [ # # ]: 0 : if (likely(!error)) {
614 : 0 : bio_endio(bio);
615 : 0 : return;
616 : : }
617 : :
618 : : /*
619 : : * If the bio is discard, return an error, but do not
620 : : * degrade the array.
621 : : */
622 [ # # ]: 0 : if (bio_op(bio) == REQ_OP_DISCARD) {
623 : 0 : bio->bi_status = BLK_STS_NOTSUPP;
624 : 0 : bio_endio(bio);
625 : 0 : return;
626 : : }
627 : :
628 [ # # ]: 0 : for (i = 0; i < ms->nr_mirrors; i++)
629 [ # # ]: 0 : if (test_bit(i, &error))
630 : 0 : fail_mirror(ms->mirror + i, DM_RAID1_WRITE_ERROR);
631 : :
632 : : /*
633 : : * Need to raise event. Since raising
634 : : * events can block, we need to do it in
635 : : * the main thread.
636 : : */
637 : 0 : spin_lock_irqsave(&ms->lock, flags);
638 [ # # ]: 0 : if (!ms->failures.head)
639 : 0 : should_wake = 1;
640 [ # # ]: 0 : bio_list_add(&ms->failures, bio);
641 : 0 : spin_unlock_irqrestore(&ms->lock, flags);
642 [ # # ]: 0 : if (should_wake)
643 : 0 : wakeup_mirrord(ms);
644 : : }
645 : :
646 : 0 : static void do_write(struct mirror_set *ms, struct bio *bio)
647 : : {
648 : 0 : unsigned int i;
649 : 0 : struct dm_io_region io[MAX_NR_MIRRORS], *dest = io;
650 : 0 : struct mirror *m;
651 : 0 : struct dm_io_request io_req = {
652 : : .bi_op = REQ_OP_WRITE,
653 : 0 : .bi_op_flags = bio->bi_opf & (REQ_FUA | REQ_PREFLUSH),
654 : : .mem.type = DM_IO_BIO,
655 : : .mem.ptr.bio = bio,
656 : : .notify.fn = write_callback,
657 : : .notify.context = bio,
658 : 0 : .client = ms->io_client,
659 : : };
660 : :
661 [ # # ]: 0 : if (bio_op(bio) == REQ_OP_DISCARD) {
662 : 0 : io_req.bi_op = REQ_OP_DISCARD;
663 : 0 : io_req.mem.type = DM_IO_KMEM;
664 : 0 : io_req.mem.ptr.addr = NULL;
665 : : }
666 : :
667 [ # # ]: 0 : for (i = 0, m = ms->mirror; i < ms->nr_mirrors; i++, m++)
668 [ # # ]: 0 : map_region(dest++, m, bio);
669 : :
670 : : /*
671 : : * Use default mirror because we only need it to retrieve the reference
672 : : * to the mirror set in write_callback().
673 : : */
674 : 0 : bio_set_m(bio, get_default_mirror(ms));
675 : :
676 [ # # ]: 0 : BUG_ON(dm_io(&io_req, ms->nr_mirrors, io, NULL));
677 : 0 : }
678 : :
679 : 0 : static void do_writes(struct mirror_set *ms, struct bio_list *writes)
680 : : {
681 : 0 : int state;
682 : 0 : struct bio *bio;
683 : 0 : struct bio_list sync, nosync, recover, *this_list = NULL;
684 : 0 : struct bio_list requeue;
685 : 0 : struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
686 : 0 : region_t region;
687 : :
688 [ # # ]: 0 : if (!writes->head)
689 : 0 : return;
690 : :
691 : : /*
692 : : * Classify each write.
693 : : */
694 : 0 : bio_list_init(&sync);
695 : 0 : bio_list_init(&nosync);
696 : 0 : bio_list_init(&recover);
697 : 0 : bio_list_init(&requeue);
698 : :
699 [ # # # # ]: 0 : while ((bio = bio_list_pop(writes))) {
700 [ # # ]: 0 : if ((bio->bi_opf & REQ_PREFLUSH) ||
701 [ # # ]: 0 : (bio_op(bio) == REQ_OP_DISCARD)) {
702 [ # # ]: 0 : bio_list_add(&sync, bio);
703 : 0 : continue;
704 : : }
705 : :
706 : 0 : region = dm_rh_bio_to_region(ms->rh, bio);
707 : :
708 [ # # # # ]: 0 : if (log->type->is_remote_recovering &&
709 : 0 : log->type->is_remote_recovering(log, region)) {
710 [ # # ]: 0 : bio_list_add(&requeue, bio);
711 : 0 : continue;
712 : : }
713 : :
714 : 0 : state = dm_rh_get_state(ms->rh, region, 1);
715 [ # # # # ]: 0 : switch (state) {
716 : 0 : case DM_RH_CLEAN:
717 : : case DM_RH_DIRTY:
718 : 0 : this_list = &sync;
719 : 0 : break;
720 : :
721 : 0 : case DM_RH_NOSYNC:
722 : 0 : this_list = &nosync;
723 : 0 : break;
724 : :
725 : 0 : case DM_RH_RECOVERING:
726 : 0 : this_list = &recover;
727 : 0 : break;
728 : : }
729 : :
730 [ # # ]: 0 : bio_list_add(this_list, bio);
731 : : }
732 : :
733 : : /*
734 : : * Add bios that are delayed due to remote recovery
735 : : * back on to the write queue
736 : : */
737 [ # # ]: 0 : if (unlikely(requeue.head)) {
738 : 0 : spin_lock_irq(&ms->lock);
739 [ # # ]: 0 : bio_list_merge(&ms->writes, &requeue);
740 : 0 : spin_unlock_irq(&ms->lock);
741 : 0 : delayed_wake(ms);
742 : : }
743 : :
744 : : /*
745 : : * Increment the pending counts for any regions that will
746 : : * be written to (writes to recover regions are going to
747 : : * be delayed).
748 : : */
749 : 0 : dm_rh_inc_pending(ms->rh, &sync);
750 : 0 : dm_rh_inc_pending(ms->rh, &nosync);
751 : :
752 : : /*
753 : : * If the flush fails on a previous call and succeeds here,
754 : : * we must not reset the log_failure variable. We need
755 : : * userspace interaction to do that.
756 : : */
757 [ # # ]: 0 : ms->log_failure = dm_rh_flush(ms->rh) ? 1 : ms->log_failure;
758 : :
759 : : /*
760 : : * Dispatch io.
761 : : */
762 [ # # # # ]: 0 : if (unlikely(ms->log_failure) && errors_handled(ms)) {
763 : 0 : spin_lock_irq(&ms->lock);
764 [ # # ]: 0 : bio_list_merge(&ms->failures, &sync);
765 : 0 : spin_unlock_irq(&ms->lock);
766 : 0 : wakeup_mirrord(ms);
767 : : } else
768 [ # # # # ]: 0 : while ((bio = bio_list_pop(&sync)))
769 : 0 : do_write(ms, bio);
770 : :
771 [ # # # # ]: 0 : while ((bio = bio_list_pop(&recover)))
772 : 0 : dm_rh_delay(ms->rh, bio);
773 : :
774 [ # # # # ]: 0 : while ((bio = bio_list_pop(&nosync))) {
775 [ # # # # ]: 0 : if (unlikely(ms->leg_failure) && errors_handled(ms) && !keep_log(ms)) {
776 : 0 : spin_lock_irq(&ms->lock);
777 [ # # ]: 0 : bio_list_add(&ms->failures, bio);
778 : 0 : spin_unlock_irq(&ms->lock);
779 : 0 : wakeup_mirrord(ms);
780 : : } else {
781 : 0 : map_bio(get_default_mirror(ms), bio);
782 : 0 : generic_make_request(bio);
783 : : }
784 : : }
785 : : }
786 : :
787 : 0 : static void do_failures(struct mirror_set *ms, struct bio_list *failures)
788 : : {
789 : 0 : struct bio *bio;
790 : :
791 [ # # ]: 0 : if (likely(!failures->head))
792 : : return;
793 : :
794 : : /*
795 : : * If the log has failed, unattempted writes are being
796 : : * put on the holds list. We can't issue those writes
797 : : * until a log has been marked, so we must store them.
798 : : *
799 : : * If a 'noflush' suspend is in progress, we can requeue
800 : : * the I/O's to the core. This give userspace a chance
801 : : * to reconfigure the mirror, at which point the core
802 : : * will reissue the writes. If the 'noflush' flag is
803 : : * not set, we have no choice but to return errors.
804 : : *
805 : : * Some writes on the failures list may have been
806 : : * submitted before the log failure and represent a
807 : : * failure to write to one of the devices. It is ok
808 : : * for us to treat them the same and requeue them
809 : : * as well.
810 : : */
811 [ # # # # ]: 0 : while ((bio = bio_list_pop(failures))) {
812 [ # # ]: 0 : if (!ms->log_failure) {
813 : 0 : ms->in_sync = 0;
814 : 0 : dm_rh_mark_nosync(ms->rh, bio);
815 : : }
816 : :
817 : : /*
818 : : * If all the legs are dead, fail the I/O.
819 : : * If the device has failed and keep_log is enabled,
820 : : * fail the I/O.
821 : : *
822 : : * If we have been told to handle errors, and keep_log
823 : : * isn't enabled, hold the bio and wait for userspace to
824 : : * deal with the problem.
825 : : *
826 : : * Otherwise pretend that the I/O succeeded. (This would
827 : : * be wrong if the failed leg returned after reboot and
828 : : * got replicated back to the good legs.)
829 : : */
830 [ # # # # : 0 : if (unlikely(!get_valid_mirror(ms) || (keep_log(ms) && ms->log_failure)))
# # ]
831 : 0 : bio_io_error(bio);
832 [ # # ]: 0 : else if (errors_handled(ms) && !keep_log(ms))
833 : 0 : hold_bio(ms, bio);
834 : : else
835 : 0 : bio_endio(bio);
836 : : }
837 : : }
838 : :
839 : 0 : static void trigger_event(struct work_struct *work)
840 : : {
841 : 0 : struct mirror_set *ms =
842 : 0 : container_of(work, struct mirror_set, trigger_event);
843 : :
844 : 0 : dm_table_event(ms->ti->table);
845 : 0 : }
846 : :
847 : : /*-----------------------------------------------------------------
848 : : * kmirrord
849 : : *---------------------------------------------------------------*/
850 : 0 : static void do_mirror(struct work_struct *work)
851 : : {
852 : 0 : struct mirror_set *ms = container_of(work, struct mirror_set,
853 : : kmirrord_work);
854 : 0 : struct bio_list reads, writes, failures;
855 : 0 : unsigned long flags;
856 : :
857 : 0 : spin_lock_irqsave(&ms->lock, flags);
858 : 0 : reads = ms->reads;
859 : 0 : writes = ms->writes;
860 : 0 : failures = ms->failures;
861 : 0 : bio_list_init(&ms->reads);
862 : 0 : bio_list_init(&ms->writes);
863 : 0 : bio_list_init(&ms->failures);
864 : 0 : spin_unlock_irqrestore(&ms->lock, flags);
865 : :
866 : 0 : dm_rh_update_states(ms->rh, errors_handled(ms));
867 : 0 : do_recovery(ms);
868 : 0 : do_reads(ms, &reads);
869 : 0 : do_writes(ms, &writes);
870 : 0 : do_failures(ms, &failures);
871 : 0 : }
872 : :
873 : : /*-----------------------------------------------------------------
874 : : * Target functions
875 : : *---------------------------------------------------------------*/
876 : 0 : static struct mirror_set *alloc_context(unsigned int nr_mirrors,
877 : : uint32_t region_size,
878 : : struct dm_target *ti,
879 : : struct dm_dirty_log *dl)
880 : : {
881 : 0 : struct mirror_set *ms =
882 [ # # ]: 0 : kzalloc(struct_size(ms, mirror, nr_mirrors), GFP_KERNEL);
883 : :
884 [ # # ]: 0 : if (!ms) {
885 : 0 : ti->error = "Cannot allocate mirror context";
886 : 0 : return NULL;
887 : : }
888 : :
889 : 0 : spin_lock_init(&ms->lock);
890 : 0 : bio_list_init(&ms->reads);
891 : 0 : bio_list_init(&ms->writes);
892 : 0 : bio_list_init(&ms->failures);
893 : 0 : bio_list_init(&ms->holds);
894 : :
895 : 0 : ms->ti = ti;
896 : 0 : ms->nr_mirrors = nr_mirrors;
897 : 0 : ms->nr_regions = dm_sector_div_up(ti->len, region_size);
898 : 0 : ms->in_sync = 0;
899 : 0 : ms->log_failure = 0;
900 : 0 : ms->leg_failure = 0;
901 : 0 : atomic_set(&ms->suspend, 0);
902 : 0 : atomic_set(&ms->default_mirror, DEFAULT_MIRROR);
903 : :
904 : 0 : ms->io_client = dm_io_client_create();
905 [ # # ]: 0 : if (IS_ERR(ms->io_client)) {
906 : 0 : ti->error = "Error creating dm_io client";
907 : 0 : kfree(ms);
908 : 0 : return NULL;
909 : : }
910 : :
911 : 0 : ms->rh = dm_region_hash_create(ms, dispatch_bios, wakeup_mirrord,
912 : : wakeup_all_recovery_waiters,
913 : 0 : ms->ti->begin, MAX_RECOVERY,
914 : : dl, region_size, ms->nr_regions);
915 [ # # ]: 0 : if (IS_ERR(ms->rh)) {
916 : 0 : ti->error = "Error creating dirty region hash";
917 : 0 : dm_io_client_destroy(ms->io_client);
918 : 0 : kfree(ms);
919 : 0 : return NULL;
920 : : }
921 : :
922 : : return ms;
923 : : }
924 : :
925 : 0 : static void free_context(struct mirror_set *ms, struct dm_target *ti,
926 : : unsigned int m)
927 : : {
928 [ # # ]: 0 : while (m--)
929 : 0 : dm_put_device(ti, ms->mirror[m].dev);
930 : :
931 : 0 : dm_io_client_destroy(ms->io_client);
932 : 0 : dm_region_hash_destroy(ms->rh);
933 : 0 : kfree(ms);
934 : 0 : }
935 : :
936 : 0 : static int get_mirror(struct mirror_set *ms, struct dm_target *ti,
937 : : unsigned int mirror, char **argv)
938 : : {
939 : 0 : unsigned long long offset;
940 : 0 : char dummy;
941 : 0 : int ret;
942 : :
943 [ # # ]: 0 : if (sscanf(argv[1], "%llu%c", &offset, &dummy) != 1 ||
944 : : offset != (sector_t)offset) {
945 : 0 : ti->error = "Invalid offset";
946 : 0 : return -EINVAL;
947 : : }
948 : :
949 : 0 : ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
950 : : &ms->mirror[mirror].dev);
951 [ # # ]: 0 : if (ret) {
952 : 0 : ti->error = "Device lookup failure";
953 : 0 : return ret;
954 : : }
955 : :
956 : 0 : ms->mirror[mirror].ms = ms;
957 : 0 : atomic_set(&(ms->mirror[mirror].error_count), 0);
958 : 0 : ms->mirror[mirror].error_type = 0;
959 : 0 : ms->mirror[mirror].offset = offset;
960 : :
961 : 0 : return 0;
962 : : }
963 : :
964 : : /*
965 : : * Create dirty log: log_type #log_params <log_params>
966 : : */
967 : 0 : static struct dm_dirty_log *create_dirty_log(struct dm_target *ti,
968 : : unsigned argc, char **argv,
969 : : unsigned *args_used)
970 : : {
971 : 0 : unsigned param_count;
972 : 0 : struct dm_dirty_log *dl;
973 : 0 : char dummy;
974 : :
975 [ # # ]: 0 : if (argc < 2) {
976 : 0 : ti->error = "Insufficient mirror log arguments";
977 : 0 : return NULL;
978 : : }
979 : :
980 [ # # ]: 0 : if (sscanf(argv[1], "%u%c", ¶m_count, &dummy) != 1) {
981 : 0 : ti->error = "Invalid mirror log argument count";
982 : 0 : return NULL;
983 : : }
984 : :
985 : 0 : *args_used = 2 + param_count;
986 : :
987 [ # # ]: 0 : if (argc < *args_used) {
988 : 0 : ti->error = "Insufficient mirror log arguments";
989 : 0 : return NULL;
990 : : }
991 : :
992 : 0 : dl = dm_dirty_log_create(argv[0], ti, mirror_flush, param_count,
993 : : argv + 2);
994 [ # # ]: 0 : if (!dl) {
995 : 0 : ti->error = "Error creating mirror dirty log";
996 : 0 : return NULL;
997 : : }
998 : :
999 : : return dl;
1000 : : }
1001 : :
1002 : 0 : static int parse_features(struct mirror_set *ms, unsigned argc, char **argv,
1003 : : unsigned *args_used)
1004 : : {
1005 : 0 : unsigned num_features;
1006 : 0 : struct dm_target *ti = ms->ti;
1007 : 0 : char dummy;
1008 : 0 : int i;
1009 : :
1010 : 0 : *args_used = 0;
1011 : :
1012 [ # # ]: 0 : if (!argc)
1013 : : return 0;
1014 : :
1015 [ # # ]: 0 : if (sscanf(argv[0], "%u%c", &num_features, &dummy) != 1) {
1016 : 0 : ti->error = "Invalid number of features";
1017 : 0 : return -EINVAL;
1018 : : }
1019 : :
1020 : 0 : argc--;
1021 : 0 : argv++;
1022 : 0 : (*args_used)++;
1023 : :
1024 [ # # ]: 0 : if (num_features > argc) {
1025 : 0 : ti->error = "Not enough arguments to support feature count";
1026 : 0 : return -EINVAL;
1027 : : }
1028 : :
1029 [ # # ]: 0 : for (i = 0; i < num_features; i++) {
1030 [ # # ]: 0 : if (!strcmp("handle_errors", argv[0]))
1031 : 0 : ms->features |= DM_RAID1_HANDLE_ERRORS;
1032 [ # # ]: 0 : else if (!strcmp("keep_log", argv[0]))
1033 : 0 : ms->features |= DM_RAID1_KEEP_LOG;
1034 : : else {
1035 : 0 : ti->error = "Unrecognised feature requested";
1036 : 0 : return -EINVAL;
1037 : : }
1038 : :
1039 : 0 : argc--;
1040 : 0 : argv++;
1041 : 0 : (*args_used)++;
1042 : : }
1043 [ # # ]: 0 : if (!errors_handled(ms) && keep_log(ms)) {
1044 : 0 : ti->error = "keep_log feature requires the handle_errors feature";
1045 : 0 : return -EINVAL;
1046 : : }
1047 : :
1048 : : return 0;
1049 : : }
1050 : :
1051 : : /*
1052 : : * Construct a mirror mapping:
1053 : : *
1054 : : * log_type #log_params <log_params>
1055 : : * #mirrors [mirror_path offset]{2,}
1056 : : * [#features <features>]
1057 : : *
1058 : : * log_type is "core" or "disk"
1059 : : * #log_params is between 1 and 3
1060 : : *
1061 : : * If present, supported features are "handle_errors" and "keep_log".
1062 : : */
1063 : 0 : static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
1064 : : {
1065 : 0 : int r;
1066 : 0 : unsigned int nr_mirrors, m, args_used;
1067 : 0 : struct mirror_set *ms;
1068 : 0 : struct dm_dirty_log *dl;
1069 : 0 : char dummy;
1070 : :
1071 : 0 : dl = create_dirty_log(ti, argc, argv, &args_used);
1072 [ # # ]: 0 : if (!dl)
1073 : : return -EINVAL;
1074 : :
1075 : 0 : argv += args_used;
1076 : 0 : argc -= args_used;
1077 : :
1078 [ # # # # ]: 0 : if (!argc || sscanf(argv[0], "%u%c", &nr_mirrors, &dummy) != 1 ||
1079 [ # # # # ]: 0 : nr_mirrors < 2 || nr_mirrors > MAX_NR_MIRRORS) {
1080 : 0 : ti->error = "Invalid number of mirrors";
1081 : 0 : dm_dirty_log_destroy(dl);
1082 : 0 : return -EINVAL;
1083 : : }
1084 : :
1085 : 0 : argv++, argc--;
1086 : :
1087 [ # # ]: 0 : if (argc < nr_mirrors * 2) {
1088 : 0 : ti->error = "Too few mirror arguments";
1089 : 0 : dm_dirty_log_destroy(dl);
1090 : 0 : return -EINVAL;
1091 : : }
1092 : :
1093 : 0 : ms = alloc_context(nr_mirrors, dl->type->get_region_size(dl), ti, dl);
1094 [ # # ]: 0 : if (!ms) {
1095 : 0 : dm_dirty_log_destroy(dl);
1096 : 0 : return -ENOMEM;
1097 : : }
1098 : :
1099 : : /* Get the mirror parameter sets */
1100 [ # # ]: 0 : for (m = 0; m < nr_mirrors; m++) {
1101 : 0 : r = get_mirror(ms, ti, m, argv);
1102 [ # # ]: 0 : if (r) {
1103 : 0 : free_context(ms, ti, m);
1104 : 0 : return r;
1105 : : }
1106 : 0 : argv += 2;
1107 : 0 : argc -= 2;
1108 : : }
1109 : :
1110 : 0 : ti->private = ms;
1111 : :
1112 : 0 : r = dm_set_target_max_io_len(ti, dm_rh_get_region_size(ms->rh));
1113 [ # # ]: 0 : if (r)
1114 : 0 : goto err_free_context;
1115 : :
1116 : 0 : ti->num_flush_bios = 1;
1117 : 0 : ti->num_discard_bios = 1;
1118 : 0 : ti->per_io_data_size = sizeof(struct dm_raid1_bio_record);
1119 : :
1120 : 0 : ms->kmirrord_wq = alloc_workqueue("kmirrord", WQ_MEM_RECLAIM, 0);
1121 [ # # ]: 0 : if (!ms->kmirrord_wq) {
1122 : 0 : DMERR("couldn't start kmirrord");
1123 : 0 : r = -ENOMEM;
1124 : 0 : goto err_free_context;
1125 : : }
1126 : 0 : INIT_WORK(&ms->kmirrord_work, do_mirror);
1127 : 0 : timer_setup(&ms->timer, delayed_wake_fn, 0);
1128 : 0 : ms->timer_pending = 0;
1129 : 0 : INIT_WORK(&ms->trigger_event, trigger_event);
1130 : :
1131 : 0 : r = parse_features(ms, argc, argv, &args_used);
1132 [ # # ]: 0 : if (r)
1133 : 0 : goto err_destroy_wq;
1134 : :
1135 : 0 : argv += args_used;
1136 : 0 : argc -= args_used;
1137 : :
1138 : : /*
1139 : : * Any read-balancing addition depends on the
1140 : : * DM_RAID1_HANDLE_ERRORS flag being present.
1141 : : * This is because the decision to balance depends
1142 : : * on the sync state of a region. If the above
1143 : : * flag is not present, we ignore errors; and
1144 : : * the sync state may be inaccurate.
1145 : : */
1146 : :
1147 [ # # ]: 0 : if (argc) {
1148 : 0 : ti->error = "Too many mirror arguments";
1149 : 0 : r = -EINVAL;
1150 : 0 : goto err_destroy_wq;
1151 : : }
1152 : :
1153 : 0 : ms->kcopyd_client = dm_kcopyd_client_create(&dm_kcopyd_throttle);
1154 [ # # ]: 0 : if (IS_ERR(ms->kcopyd_client)) {
1155 : 0 : r = PTR_ERR(ms->kcopyd_client);
1156 : 0 : goto err_destroy_wq;
1157 : : }
1158 : :
1159 : 0 : wakeup_mirrord(ms);
1160 : 0 : return 0;
1161 : :
1162 : 0 : err_destroy_wq:
1163 : 0 : destroy_workqueue(ms->kmirrord_wq);
1164 : 0 : err_free_context:
1165 : 0 : free_context(ms, ti, ms->nr_mirrors);
1166 : 0 : return r;
1167 : : }
1168 : :
1169 : 0 : static void mirror_dtr(struct dm_target *ti)
1170 : : {
1171 : 0 : struct mirror_set *ms = (struct mirror_set *) ti->private;
1172 : :
1173 : 0 : del_timer_sync(&ms->timer);
1174 : 0 : flush_workqueue(ms->kmirrord_wq);
1175 : 0 : flush_work(&ms->trigger_event);
1176 : 0 : dm_kcopyd_client_destroy(ms->kcopyd_client);
1177 : 0 : destroy_workqueue(ms->kmirrord_wq);
1178 : 0 : free_context(ms, ti, ms->nr_mirrors);
1179 : 0 : }
1180 : :
1181 : : /*
1182 : : * Mirror mapping function
1183 : : */
1184 : 0 : static int mirror_map(struct dm_target *ti, struct bio *bio)
1185 : : {
1186 : 0 : int r, rw = bio_data_dir(bio);
1187 : 0 : struct mirror *m;
1188 : 0 : struct mirror_set *ms = ti->private;
1189 : 0 : struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
1190 : 0 : struct dm_raid1_bio_record *bio_record =
1191 : 0 : dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1192 : :
1193 : 0 : bio_record->details.bi_disk = NULL;
1194 : :
1195 [ # # ]: 0 : if (rw == WRITE) {
1196 : : /* Save region for mirror_end_io() handler */
1197 : 0 : bio_record->write_region = dm_rh_bio_to_region(ms->rh, bio);
1198 : 0 : queue_bio(ms, bio, rw);
1199 : 0 : return DM_MAPIO_SUBMITTED;
1200 : : }
1201 : :
1202 : 0 : r = log->type->in_sync(log, dm_rh_bio_to_region(ms->rh, bio), 0);
1203 [ # # ]: 0 : if (r < 0 && r != -EWOULDBLOCK)
1204 : : return DM_MAPIO_KILL;
1205 : :
1206 : : /*
1207 : : * If region is not in-sync queue the bio.
1208 : : */
1209 [ # # ]: 0 : if (!r || (r == -EWOULDBLOCK)) {
1210 [ # # ]: 0 : if (bio->bi_opf & REQ_RAHEAD)
1211 : : return DM_MAPIO_KILL;
1212 : :
1213 : 0 : queue_bio(ms, bio, rw);
1214 : 0 : return DM_MAPIO_SUBMITTED;
1215 : : }
1216 : :
1217 : : /*
1218 : : * The region is in-sync and we can perform reads directly.
1219 : : * Store enough information so we can retry if it fails.
1220 : : */
1221 : 0 : m = choose_mirror(ms, bio->bi_iter.bi_sector);
1222 [ # # ]: 0 : if (unlikely(!m))
1223 : : return DM_MAPIO_KILL;
1224 : :
1225 : 0 : dm_bio_record(&bio_record->details, bio);
1226 : 0 : bio_record->m = m;
1227 : :
1228 : 0 : map_bio(m, bio);
1229 : :
1230 : 0 : return DM_MAPIO_REMAPPED;
1231 : : }
1232 : :
1233 : 0 : static int mirror_end_io(struct dm_target *ti, struct bio *bio,
1234 : : blk_status_t *error)
1235 : : {
1236 : 0 : int rw = bio_data_dir(bio);
1237 : 0 : struct mirror_set *ms = (struct mirror_set *) ti->private;
1238 : 0 : struct mirror *m = NULL;
1239 : 0 : struct dm_bio_details *bd = NULL;
1240 : 0 : struct dm_raid1_bio_record *bio_record =
1241 : 0 : dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1242 : :
1243 : : /*
1244 : : * We need to dec pending if this was a write.
1245 : : */
1246 [ # # ]: 0 : if (rw == WRITE) {
1247 [ # # ]: 0 : if (!(bio->bi_opf & REQ_PREFLUSH) &&
1248 [ # # ]: 0 : bio_op(bio) != REQ_OP_DISCARD)
1249 : 0 : dm_rh_dec(ms->rh, bio_record->write_region);
1250 : 0 : return DM_ENDIO_DONE;
1251 : : }
1252 : :
1253 [ # # ]: 0 : if (*error == BLK_STS_NOTSUPP)
1254 : 0 : goto out;
1255 : :
1256 [ # # ]: 0 : if (bio->bi_opf & REQ_RAHEAD)
1257 : 0 : goto out;
1258 : :
1259 [ # # ]: 0 : if (unlikely(*error)) {
1260 [ # # ]: 0 : if (!bio_record->details.bi_disk) {
1261 : : /*
1262 : : * There wasn't enough memory to record necessary
1263 : : * information for a retry or there was no other
1264 : : * mirror in-sync.
1265 : : */
1266 [ # # ]: 0 : DMERR_LIMIT("Mirror read failed.");
1267 : 0 : return DM_ENDIO_DONE;
1268 : : }
1269 : :
1270 : 0 : m = bio_record->m;
1271 : :
1272 : 0 : DMERR("Mirror read failed from %s. Trying alternative device.",
1273 : : m->dev->name);
1274 : :
1275 : 0 : fail_mirror(m, DM_RAID1_READ_ERROR);
1276 : :
1277 : : /*
1278 : : * A failed read is requeued for another attempt using an intact
1279 : : * mirror.
1280 : : */
1281 [ # # # # ]: 0 : if (default_ok(m) || mirror_available(ms, bio)) {
1282 : 0 : bd = &bio_record->details;
1283 : :
1284 : 0 : dm_bio_restore(bd, bio);
1285 : 0 : bio_record->details.bi_disk = NULL;
1286 : 0 : bio->bi_status = 0;
1287 : :
1288 : 0 : queue_bio(ms, bio, rw);
1289 : 0 : return DM_ENDIO_INCOMPLETE;
1290 : : }
1291 : 0 : DMERR("All replicated volumes dead, failing I/O");
1292 : : }
1293 : :
1294 : 0 : out:
1295 : 0 : bio_record->details.bi_disk = NULL;
1296 : :
1297 : 0 : return DM_ENDIO_DONE;
1298 : : }
1299 : :
1300 : 0 : static void mirror_presuspend(struct dm_target *ti)
1301 : : {
1302 : 0 : struct mirror_set *ms = (struct mirror_set *) ti->private;
1303 : 0 : struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
1304 : :
1305 : 0 : struct bio_list holds;
1306 : 0 : struct bio *bio;
1307 : :
1308 : 0 : atomic_set(&ms->suspend, 1);
1309 : :
1310 : : /*
1311 : : * Process bios in the hold list to start recovery waiting
1312 : : * for bios in the hold list. After the process, no bio has
1313 : : * a chance to be added in the hold list because ms->suspend
1314 : : * is set.
1315 : : */
1316 : 0 : spin_lock_irq(&ms->lock);
1317 : 0 : holds = ms->holds;
1318 : 0 : bio_list_init(&ms->holds);
1319 : 0 : spin_unlock_irq(&ms->lock);
1320 : :
1321 [ # # # # ]: 0 : while ((bio = bio_list_pop(&holds)))
1322 : 0 : hold_bio(ms, bio);
1323 : :
1324 : : /*
1325 : : * We must finish up all the work that we've
1326 : : * generated (i.e. recovery work).
1327 : : */
1328 : 0 : dm_rh_stop_recovery(ms->rh);
1329 : :
1330 [ # # # # ]: 0 : wait_event(_kmirrord_recovery_stopped,
1331 : : !dm_rh_recovery_in_flight(ms->rh));
1332 : :
1333 [ # # # # ]: 0 : if (log->type->presuspend && log->type->presuspend(log))
1334 : : /* FIXME: need better error handling */
1335 : 0 : DMWARN("log presuspend failed");
1336 : :
1337 : : /*
1338 : : * Now that recovery is complete/stopped and the
1339 : : * delayed bios are queued, we need to wait for
1340 : : * the worker thread to complete. This way,
1341 : : * we know that all of our I/O has been pushed.
1342 : : */
1343 : 0 : flush_workqueue(ms->kmirrord_wq);
1344 : 0 : }
1345 : :
1346 : 0 : static void mirror_postsuspend(struct dm_target *ti)
1347 : : {
1348 : 0 : struct mirror_set *ms = ti->private;
1349 : 0 : struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
1350 : :
1351 [ # # # # ]: 0 : if (log->type->postsuspend && log->type->postsuspend(log))
1352 : : /* FIXME: need better error handling */
1353 : 0 : DMWARN("log postsuspend failed");
1354 : 0 : }
1355 : :
1356 : 0 : static void mirror_resume(struct dm_target *ti)
1357 : : {
1358 : 0 : struct mirror_set *ms = ti->private;
1359 : 0 : struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
1360 : :
1361 : 0 : atomic_set(&ms->suspend, 0);
1362 [ # # # # ]: 0 : if (log->type->resume && log->type->resume(log))
1363 : : /* FIXME: need better error handling */
1364 : 0 : DMWARN("log resume failed");
1365 : 0 : dm_rh_start_recovery(ms->rh);
1366 : 0 : }
1367 : :
1368 : : /*
1369 : : * device_status_char
1370 : : * @m: mirror device/leg we want the status of
1371 : : *
1372 : : * We return one character representing the most severe error
1373 : : * we have encountered.
1374 : : * A => Alive - No failures
1375 : : * D => Dead - A write failure occurred leaving mirror out-of-sync
1376 : : * S => Sync - A sychronization failure occurred, mirror out-of-sync
1377 : : * R => Read - A read failure occurred, mirror data unaffected
1378 : : *
1379 : : * Returns: <char>
1380 : : */
1381 : 0 : static char device_status_char(struct mirror *m)
1382 : : {
1383 [ # # ]: 0 : if (!atomic_read(&(m->error_count)))
1384 : : return 'A';
1385 : :
1386 [ # # # # : 0 : return (test_bit(DM_RAID1_FLUSH_ERROR, &(m->error_type))) ? 'F' :
# # # # ]
1387 : : (test_bit(DM_RAID1_WRITE_ERROR, &(m->error_type))) ? 'D' :
1388 : : (test_bit(DM_RAID1_SYNC_ERROR, &(m->error_type))) ? 'S' :
1389 : : (test_bit(DM_RAID1_READ_ERROR, &(m->error_type))) ? 'R' : 'U';
1390 : : }
1391 : :
1392 : :
1393 : 0 : static void mirror_status(struct dm_target *ti, status_type_t type,
1394 : : unsigned status_flags, char *result, unsigned maxlen)
1395 : : {
1396 : 0 : unsigned int m, sz = 0;
1397 : 0 : int num_feature_args = 0;
1398 : 0 : struct mirror_set *ms = (struct mirror_set *) ti->private;
1399 : 0 : struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
1400 : 0 : char buffer[MAX_NR_MIRRORS + 1];
1401 : :
1402 [ # # # ]: 0 : switch (type) {
1403 : 0 : case STATUSTYPE_INFO:
1404 [ # # ]: 0 : DMEMIT("%d ", ms->nr_mirrors);
1405 [ # # ]: 0 : for (m = 0; m < ms->nr_mirrors; m++) {
1406 [ # # ]: 0 : DMEMIT("%s ", ms->mirror[m].dev->name);
1407 : 0 : buffer[m] = device_status_char(&(ms->mirror[m]));
1408 : : }
1409 : 0 : buffer[m] = '\0';
1410 : :
1411 [ # # ]: 0 : DMEMIT("%llu/%llu 1 %s ",
1412 : : (unsigned long long)log->type->get_sync_count(log),
1413 : : (unsigned long long)ms->nr_regions, buffer);
1414 : :
1415 : 0 : sz += log->type->status(log, type, result+sz, maxlen-sz);
1416 : :
1417 : 0 : break;
1418 : :
1419 : 0 : case STATUSTYPE_TABLE:
1420 : 0 : sz = log->type->status(log, type, result, maxlen);
1421 : :
1422 [ # # ]: 0 : DMEMIT("%d", ms->nr_mirrors);
1423 [ # # ]: 0 : for (m = 0; m < ms->nr_mirrors; m++)
1424 [ # # ]: 0 : DMEMIT(" %s %llu", ms->mirror[m].dev->name,
1425 : : (unsigned long long)ms->mirror[m].offset);
1426 : :
1427 : 0 : num_feature_args += !!errors_handled(ms);
1428 : 0 : num_feature_args += !!keep_log(ms);
1429 [ # # ]: 0 : if (num_feature_args) {
1430 [ # # ]: 0 : DMEMIT(" %d", num_feature_args);
1431 [ # # ]: 0 : if (errors_handled(ms))
1432 [ # # ]: 0 : DMEMIT(" handle_errors");
1433 [ # # ]: 0 : if (keep_log(ms))
1434 [ # # ]: 0 : DMEMIT(" keep_log");
1435 : : }
1436 : :
1437 : : break;
1438 : : }
1439 : 0 : }
1440 : :
1441 : 0 : static int mirror_iterate_devices(struct dm_target *ti,
1442 : : iterate_devices_callout_fn fn, void *data)
1443 : : {
1444 : 0 : struct mirror_set *ms = ti->private;
1445 : 0 : int ret = 0;
1446 : 0 : unsigned i;
1447 : :
1448 [ # # # # ]: 0 : for (i = 0; !ret && i < ms->nr_mirrors; i++)
1449 : 0 : ret = fn(ti, ms->mirror[i].dev,
1450 : : ms->mirror[i].offset, ti->len, data);
1451 : :
1452 : 0 : return ret;
1453 : : }
1454 : :
1455 : : static struct target_type mirror_target = {
1456 : : .name = "mirror",
1457 : : .version = {1, 14, 0},
1458 : : .module = THIS_MODULE,
1459 : : .ctr = mirror_ctr,
1460 : : .dtr = mirror_dtr,
1461 : : .map = mirror_map,
1462 : : .end_io = mirror_end_io,
1463 : : .presuspend = mirror_presuspend,
1464 : : .postsuspend = mirror_postsuspend,
1465 : : .resume = mirror_resume,
1466 : : .status = mirror_status,
1467 : : .iterate_devices = mirror_iterate_devices,
1468 : : };
1469 : :
1470 : 28 : static int __init dm_mirror_init(void)
1471 : : {
1472 : 28 : int r;
1473 : :
1474 : 28 : r = dm_register_target(&mirror_target);
1475 [ - + ]: 28 : if (r < 0) {
1476 : 0 : DMERR("Failed to register mirror target");
1477 : 0 : goto bad_target;
1478 : : }
1479 : :
1480 : : return 0;
1481 : :
1482 : : bad_target:
1483 : 0 : return r;
1484 : : }
1485 : :
1486 : 0 : static void __exit dm_mirror_exit(void)
1487 : : {
1488 : 0 : dm_unregister_target(&mirror_target);
1489 : 0 : }
1490 : :
1491 : : /* Module hooks */
1492 : : module_init(dm_mirror_init);
1493 : : module_exit(dm_mirror_exit);
1494 : :
1495 : : MODULE_DESCRIPTION(DM_NAME " mirror target");
1496 : : MODULE_AUTHOR("Joe Thornber");
1497 : : MODULE_LICENSE("GPL");
|
