2 * Copyright (C) 2003 Sistina Software Limited.
4 * This file is released under the GPL.
7 #include <linux/device-mapper.h>
9 #include "dm-bio-list.h"
10 #include "dm-bio-record.h"
12 #include <linux/ctype.h>
13 #include <linux/init.h>
14 #include <linux/mempool.h>
15 #include <linux/module.h>
16 #include <linux/pagemap.h>
17 #include <linux/slab.h>
18 #include <linux/time.h>
19 #include <linux/vmalloc.h>
20 #include <linux/workqueue.h>
21 #include <linux/log2.h>
22 #include <linux/hardirq.h>
23 #include <linux/dm-io.h>
24 #include <linux/dm-dirty-log.h>
25 #include <linux/dm-kcopyd.h>
27 #define DM_MSG_PREFIX "raid1"
28 #define DM_IO_PAGES 64
30 #define DM_RAID1_HANDLE_ERRORS 0x01
31 #define errors_handled(p) ((p)->features & DM_RAID1_HANDLE_ERRORS)
33 static DECLARE_WAIT_QUEUE_HEAD(_kmirrord_recovery_stopped
);
35 /*-----------------------------------------------------------------
38 * The mirror splits itself up into discrete regions. Each
39 * region can be in one of three states: clean, dirty,
40 * nosync. There is no need to put clean regions in the hash.
42 * In addition to being present in the hash table a region _may_
43 * be present on one of three lists.
45 * clean_regions: Regions on this list have no io pending to
46 * them, they are in sync, we are no longer interested in them,
47 * they are dull. rh_update_states() will remove them from the
50 * quiesced_regions: These regions have been spun down, ready
51 * for recovery. rh_recovery_start() will remove regions from
52 * this list and hand them to kmirrord, which will schedule the
53 * recovery io with kcopyd.
55 * recovered_regions: Regions that kcopyd has successfully
56 * recovered. rh_update_states() will now schedule any delayed
57 * io, up the recovery_count, and remove the region from the
61 * A rw spin lock 'hash_lock' protects just the hash table,
62 * this is never held in write mode from interrupt context,
63 * which I believe means that we only have to disable irqs when
66 * An ordinary spin lock 'region_lock' that protects the three
67 * lists in the region_hash, with the 'state', 'list' and
68 * 'bhs_delayed' fields of the regions. This is used from irq
69 * context, so all other uses will have to suspend local irqs.
70 *---------------------------------------------------------------*/
73 struct mirror_set
*ms
;
75 unsigned region_shift
;
77 /* holds persistent region state */
78 struct dm_dirty_log
*log
;
82 mempool_t
*region_pool
;
84 unsigned int nr_buckets
;
85 struct list_head
*buckets
;
87 spinlock_t region_lock
;
88 atomic_t recovery_in_flight
;
89 struct semaphore recovery_count
;
90 struct list_head clean_regions
;
91 struct list_head quiesced_regions
;
92 struct list_head recovered_regions
;
93 struct list_head failed_recovered_regions
;
104 struct region_hash
*rh
; /* FIXME: can we get rid of this ? */
108 struct list_head hash_list
;
109 struct list_head list
;
112 struct bio_list delayed_bios
;
116 /*-----------------------------------------------------------------
117 * Mirror set structures.
118 *---------------------------------------------------------------*/
119 enum dm_raid1_error
{
120 DM_RAID1_WRITE_ERROR
,
126 struct mirror_set
*ms
;
127 atomic_t error_count
;
128 unsigned long error_type
;
134 struct dm_target
*ti
;
135 struct list_head list
;
136 struct region_hash rh
;
137 struct dm_kcopyd_client
*kcopyd_client
;
140 spinlock_t lock
; /* protects the lists */
141 struct bio_list reads
;
142 struct bio_list writes
;
143 struct bio_list failures
;
145 struct dm_io_client
*io_client
;
146 mempool_t
*read_record_pool
;
154 atomic_t default_mirror
; /* Default mirror */
156 struct workqueue_struct
*kmirrord_wq
;
157 struct work_struct kmirrord_work
;
158 struct timer_list timer
;
159 unsigned long timer_pending
;
161 struct work_struct trigger_event
;
163 unsigned int nr_mirrors
;
164 struct mirror mirror
[0];
170 static inline region_t
bio_to_region(struct region_hash
*rh
, struct bio
*bio
)
172 return (bio
->bi_sector
- rh
->ms
->ti
->begin
) >> rh
->region_shift
;
175 static inline sector_t
region_to_sector(struct region_hash
*rh
, region_t region
)
177 return region
<< rh
->region_shift
;
180 static void wake(struct mirror_set
*ms
)
182 queue_work(ms
->kmirrord_wq
, &ms
->kmirrord_work
);
185 static void delayed_wake_fn(unsigned long data
)
187 struct mirror_set
*ms
= (struct mirror_set
*) data
;
189 clear_bit(0, &ms
->timer_pending
);
193 static void delayed_wake(struct mirror_set
*ms
)
195 if (test_and_set_bit(0, &ms
->timer_pending
))
198 ms
->timer
.expires
= jiffies
+ HZ
/ 5;
199 ms
->timer
.data
= (unsigned long) ms
;
200 ms
->timer
.function
= delayed_wake_fn
;
201 add_timer(&ms
->timer
);
204 /* FIXME move this */
205 static void queue_bio(struct mirror_set
*ms
, struct bio
*bio
, int rw
);
207 #define MIN_REGIONS 64
208 #define MAX_RECOVERY 1
209 static int rh_init(struct region_hash
*rh
, struct mirror_set
*ms
,
210 struct dm_dirty_log
*log
, uint32_t region_size
,
213 unsigned int nr_buckets
, max_buckets
;
217 * Calculate a suitable number of buckets for our hash
220 max_buckets
= nr_regions
>> 6;
221 for (nr_buckets
= 128u; nr_buckets
< max_buckets
; nr_buckets
<<= 1)
227 rh
->region_size
= region_size
;
228 rh
->region_shift
= ffs(region_size
) - 1;
229 rwlock_init(&rh
->hash_lock
);
230 rh
->mask
= nr_buckets
- 1;
231 rh
->nr_buckets
= nr_buckets
;
233 rh
->buckets
= vmalloc(nr_buckets
* sizeof(*rh
->buckets
));
235 DMERR("unable to allocate region hash memory");
239 for (i
= 0; i
< nr_buckets
; i
++)
240 INIT_LIST_HEAD(rh
->buckets
+ i
);
242 spin_lock_init(&rh
->region_lock
);
243 sema_init(&rh
->recovery_count
, 0);
244 atomic_set(&rh
->recovery_in_flight
, 0);
245 INIT_LIST_HEAD(&rh
->clean_regions
);
246 INIT_LIST_HEAD(&rh
->quiesced_regions
);
247 INIT_LIST_HEAD(&rh
->recovered_regions
);
248 INIT_LIST_HEAD(&rh
->failed_recovered_regions
);
250 rh
->region_pool
= mempool_create_kmalloc_pool(MIN_REGIONS
,
251 sizeof(struct region
));
252 if (!rh
->region_pool
) {
261 static void rh_exit(struct region_hash
*rh
)
264 struct region
*reg
, *nreg
;
266 BUG_ON(!list_empty(&rh
->quiesced_regions
));
267 for (h
= 0; h
< rh
->nr_buckets
; h
++) {
268 list_for_each_entry_safe(reg
, nreg
, rh
->buckets
+ h
, hash_list
) {
269 BUG_ON(atomic_read(®
->pending
));
270 mempool_free(reg
, rh
->region_pool
);
275 dm_dirty_log_destroy(rh
->log
);
277 mempool_destroy(rh
->region_pool
);
281 #define RH_HASH_MULT 2654435387U
283 static inline unsigned int rh_hash(struct region_hash
*rh
, region_t region
)
285 return (unsigned int) ((region
* RH_HASH_MULT
) >> 12) & rh
->mask
;
288 static struct region
*__rh_lookup(struct region_hash
*rh
, region_t region
)
292 list_for_each_entry (reg
, rh
->buckets
+ rh_hash(rh
, region
), hash_list
)
293 if (reg
->key
== region
)
299 static void __rh_insert(struct region_hash
*rh
, struct region
*reg
)
301 unsigned int h
= rh_hash(rh
, reg
->key
);
302 list_add(®
->hash_list
, rh
->buckets
+ h
);
305 static struct region
*__rh_alloc(struct region_hash
*rh
, region_t region
)
307 struct region
*reg
, *nreg
;
309 read_unlock(&rh
->hash_lock
);
310 nreg
= mempool_alloc(rh
->region_pool
, GFP_ATOMIC
);
312 nreg
= kmalloc(sizeof(struct region
), GFP_NOIO
);
313 nreg
->state
= rh
->log
->type
->in_sync(rh
->log
, region
, 1) ?
314 RH_CLEAN
: RH_NOSYNC
;
318 INIT_LIST_HEAD(&nreg
->list
);
320 atomic_set(&nreg
->pending
, 0);
321 bio_list_init(&nreg
->delayed_bios
);
322 write_lock_irq(&rh
->hash_lock
);
324 reg
= __rh_lookup(rh
, region
);
326 /* we lost the race */
327 mempool_free(nreg
, rh
->region_pool
);
330 __rh_insert(rh
, nreg
);
331 if (nreg
->state
== RH_CLEAN
) {
332 spin_lock(&rh
->region_lock
);
333 list_add(&nreg
->list
, &rh
->clean_regions
);
334 spin_unlock(&rh
->region_lock
);
338 write_unlock_irq(&rh
->hash_lock
);
339 read_lock(&rh
->hash_lock
);
344 static inline struct region
*__rh_find(struct region_hash
*rh
, region_t region
)
348 reg
= __rh_lookup(rh
, region
);
350 reg
= __rh_alloc(rh
, region
);
355 static int rh_state(struct region_hash
*rh
, region_t region
, int may_block
)
360 read_lock(&rh
->hash_lock
);
361 reg
= __rh_lookup(rh
, region
);
362 read_unlock(&rh
->hash_lock
);
368 * The region wasn't in the hash, so we fall back to the
371 r
= rh
->log
->type
->in_sync(rh
->log
, region
, may_block
);
374 * Any error from the dirty log (eg. -EWOULDBLOCK) gets
375 * taken as a RH_NOSYNC
377 return r
== 1 ? RH_CLEAN
: RH_NOSYNC
;
380 static inline int rh_in_sync(struct region_hash
*rh
,
381 region_t region
, int may_block
)
383 int state
= rh_state(rh
, region
, may_block
);
384 return state
== RH_CLEAN
|| state
== RH_DIRTY
;
387 static void dispatch_bios(struct mirror_set
*ms
, struct bio_list
*bio_list
)
391 while ((bio
= bio_list_pop(bio_list
))) {
392 queue_bio(ms
, bio
, WRITE
);
396 static void complete_resync_work(struct region
*reg
, int success
)
398 struct region_hash
*rh
= reg
->rh
;
400 rh
->log
->type
->set_region_sync(rh
->log
, reg
->key
, success
);
403 * Dispatch the bios before we call 'wake_up_all'.
404 * This is important because if we are suspending,
405 * we want to know that recovery is complete and
406 * the work queue is flushed. If we wake_up_all
407 * before we dispatch_bios (queue bios and call wake()),
408 * then we risk suspending before the work queue
409 * has been properly flushed.
411 dispatch_bios(rh
->ms
, ®
->delayed_bios
);
412 if (atomic_dec_and_test(&rh
->recovery_in_flight
))
413 wake_up_all(&_kmirrord_recovery_stopped
);
414 up(&rh
->recovery_count
);
417 static void rh_update_states(struct region_hash
*rh
)
419 struct region
*reg
, *next
;
422 LIST_HEAD(recovered
);
423 LIST_HEAD(failed_recovered
);
426 * Quickly grab the lists.
428 write_lock_irq(&rh
->hash_lock
);
429 spin_lock(&rh
->region_lock
);
430 if (!list_empty(&rh
->clean_regions
)) {
431 list_splice_init(&rh
->clean_regions
, &clean
);
433 list_for_each_entry(reg
, &clean
, list
)
434 list_del(®
->hash_list
);
437 if (!list_empty(&rh
->recovered_regions
)) {
438 list_splice_init(&rh
->recovered_regions
, &recovered
);
440 list_for_each_entry (reg
, &recovered
, list
)
441 list_del(®
->hash_list
);
444 if (!list_empty(&rh
->failed_recovered_regions
)) {
445 list_splice_init(&rh
->failed_recovered_regions
,
448 list_for_each_entry(reg
, &failed_recovered
, list
)
449 list_del(®
->hash_list
);
452 spin_unlock(&rh
->region_lock
);
453 write_unlock_irq(&rh
->hash_lock
);
456 * All the regions on the recovered and clean lists have
457 * now been pulled out of the system, so no need to do
460 list_for_each_entry_safe (reg
, next
, &recovered
, list
) {
461 rh
->log
->type
->clear_region(rh
->log
, reg
->key
);
462 complete_resync_work(reg
, 1);
463 mempool_free(reg
, rh
->region_pool
);
466 list_for_each_entry_safe(reg
, next
, &failed_recovered
, list
) {
467 complete_resync_work(reg
, errors_handled(rh
->ms
) ? 0 : 1);
468 mempool_free(reg
, rh
->region_pool
);
471 list_for_each_entry_safe(reg
, next
, &clean
, list
) {
472 rh
->log
->type
->clear_region(rh
->log
, reg
->key
);
473 mempool_free(reg
, rh
->region_pool
);
476 rh
->log
->type
->flush(rh
->log
);
479 static void rh_inc(struct region_hash
*rh
, region_t region
)
483 read_lock(&rh
->hash_lock
);
484 reg
= __rh_find(rh
, region
);
486 spin_lock_irq(&rh
->region_lock
);
487 atomic_inc(®
->pending
);
489 if (reg
->state
== RH_CLEAN
) {
490 reg
->state
= RH_DIRTY
;
491 list_del_init(®
->list
); /* take off the clean list */
492 spin_unlock_irq(&rh
->region_lock
);
494 rh
->log
->type
->mark_region(rh
->log
, reg
->key
);
496 spin_unlock_irq(&rh
->region_lock
);
499 read_unlock(&rh
->hash_lock
);
502 static void rh_inc_pending(struct region_hash
*rh
, struct bio_list
*bios
)
506 for (bio
= bios
->head
; bio
; bio
= bio
->bi_next
)
507 rh_inc(rh
, bio_to_region(rh
, bio
));
510 static void rh_dec(struct region_hash
*rh
, region_t region
)
516 read_lock(&rh
->hash_lock
);
517 reg
= __rh_lookup(rh
, region
);
518 read_unlock(&rh
->hash_lock
);
520 spin_lock_irqsave(&rh
->region_lock
, flags
);
521 if (atomic_dec_and_test(®
->pending
)) {
523 * There is no pending I/O for this region.
524 * We can move the region to corresponding list for next action.
525 * At this point, the region is not yet connected to any list.
527 * If the state is RH_NOSYNC, the region should be kept off
529 * The hash entry for RH_NOSYNC will remain in memory
530 * until the region is recovered or the map is reloaded.
533 /* do nothing for RH_NOSYNC */
534 if (reg
->state
== RH_RECOVERING
) {
535 list_add_tail(®
->list
, &rh
->quiesced_regions
);
536 } else if (reg
->state
== RH_DIRTY
) {
537 reg
->state
= RH_CLEAN
;
538 list_add(®
->list
, &rh
->clean_regions
);
542 spin_unlock_irqrestore(&rh
->region_lock
, flags
);
549 * Starts quiescing a region in preparation for recovery.
551 static int __rh_recovery_prepare(struct region_hash
*rh
)
558 * Ask the dirty log what's next.
560 r
= rh
->log
->type
->get_resync_work(rh
->log
, ®ion
);
565 * Get this region, and start it quiescing by setting the
568 read_lock(&rh
->hash_lock
);
569 reg
= __rh_find(rh
, region
);
570 read_unlock(&rh
->hash_lock
);
572 spin_lock_irq(&rh
->region_lock
);
573 reg
->state
= RH_RECOVERING
;
575 /* Already quiesced ? */
576 if (atomic_read(®
->pending
))
577 list_del_init(®
->list
);
579 list_move(®
->list
, &rh
->quiesced_regions
);
581 spin_unlock_irq(&rh
->region_lock
);
586 static void rh_recovery_prepare(struct region_hash
*rh
)
588 /* Extra reference to avoid race with rh_stop_recovery */
589 atomic_inc(&rh
->recovery_in_flight
);
591 while (!down_trylock(&rh
->recovery_count
)) {
592 atomic_inc(&rh
->recovery_in_flight
);
593 if (__rh_recovery_prepare(rh
) <= 0) {
594 atomic_dec(&rh
->recovery_in_flight
);
595 up(&rh
->recovery_count
);
600 /* Drop the extra reference */
601 if (atomic_dec_and_test(&rh
->recovery_in_flight
))
602 wake_up_all(&_kmirrord_recovery_stopped
);
606 * Returns any quiesced regions.
608 static struct region
*rh_recovery_start(struct region_hash
*rh
)
610 struct region
*reg
= NULL
;
612 spin_lock_irq(&rh
->region_lock
);
613 if (!list_empty(&rh
->quiesced_regions
)) {
614 reg
= list_entry(rh
->quiesced_regions
.next
,
615 struct region
, list
);
616 list_del_init(®
->list
); /* remove from the quiesced list */
618 spin_unlock_irq(&rh
->region_lock
);
623 static void rh_recovery_end(struct region
*reg
, int success
)
625 struct region_hash
*rh
= reg
->rh
;
627 spin_lock_irq(&rh
->region_lock
);
629 list_add(®
->list
, ®
->rh
->recovered_regions
);
631 reg
->state
= RH_NOSYNC
;
632 list_add(®
->list
, ®
->rh
->failed_recovered_regions
);
634 spin_unlock_irq(&rh
->region_lock
);
639 static int rh_flush(struct region_hash
*rh
)
641 return rh
->log
->type
->flush(rh
->log
);
644 static void rh_delay(struct region_hash
*rh
, struct bio
*bio
)
648 read_lock(&rh
->hash_lock
);
649 reg
= __rh_find(rh
, bio_to_region(rh
, bio
));
650 bio_list_add(®
->delayed_bios
, bio
);
651 read_unlock(&rh
->hash_lock
);
654 static void rh_stop_recovery(struct region_hash
*rh
)
658 /* wait for any recovering regions */
659 for (i
= 0; i
< MAX_RECOVERY
; i
++)
660 down(&rh
->recovery_count
);
663 static void rh_start_recovery(struct region_hash
*rh
)
667 for (i
= 0; i
< MAX_RECOVERY
; i
++)
668 up(&rh
->recovery_count
);
673 #define MIN_READ_RECORDS 20
674 struct dm_raid1_read_record
{
676 struct dm_bio_details details
;
680 * Every mirror should look like this one.
682 #define DEFAULT_MIRROR 0
685 * This is yucky. We squirrel the mirror struct away inside
686 * bi_next for read/write buffers. This is safe since the bh
687 * doesn't get submitted to the lower levels of block layer.
689 static struct mirror
*bio_get_m(struct bio
*bio
)
691 return (struct mirror
*) bio
->bi_next
;
694 static void bio_set_m(struct bio
*bio
, struct mirror
*m
)
696 bio
->bi_next
= (struct bio
*) m
;
699 static struct mirror
*get_default_mirror(struct mirror_set
*ms
)
701 return &ms
->mirror
[atomic_read(&ms
->default_mirror
)];
704 static void set_default_mirror(struct mirror
*m
)
706 struct mirror_set
*ms
= m
->ms
;
707 struct mirror
*m0
= &(ms
->mirror
[0]);
709 atomic_set(&ms
->default_mirror
, m
- m0
);
713 * @m: mirror device to fail
714 * @error_type: one of the enum's, DM_RAID1_*_ERROR
716 * If errors are being handled, record the type of
717 * error encountered for this device. If this type
718 * of error has already been recorded, we can return;
719 * otherwise, we must signal userspace by triggering
720 * an event. Additionally, if the device is the
721 * primary device, we must choose a new primary, but
722 * only if the mirror is in-sync.
724 * This function must not block.
726 static void fail_mirror(struct mirror
*m
, enum dm_raid1_error error_type
)
728 struct mirror_set
*ms
= m
->ms
;
731 if (!errors_handled(ms
))
735 * error_count is used for nothing more than a
736 * simple way to tell if a device has encountered
739 atomic_inc(&m
->error_count
);
741 if (test_and_set_bit(error_type
, &m
->error_type
))
744 if (m
!= get_default_mirror(ms
))
749 * Better to issue requests to same failing device
750 * than to risk returning corrupt data.
752 DMERR("Primary mirror (%s) failed while out-of-sync: "
753 "Reads may fail.", m
->dev
->name
);
757 for (new = ms
->mirror
; new < ms
->mirror
+ ms
->nr_mirrors
; new++)
758 if (!atomic_read(&new->error_count
)) {
759 set_default_mirror(new);
763 if (unlikely(new == ms
->mirror
+ ms
->nr_mirrors
))
764 DMWARN("All sides of mirror have failed.");
767 schedule_work(&ms
->trigger_event
);
770 /*-----------------------------------------------------------------
773 * When a mirror is first activated we may find that some regions
774 * are in the no-sync state. We have to recover these by
775 * recopying from the default mirror to all the others.
776 *---------------------------------------------------------------*/
777 static void recovery_complete(int read_err
, unsigned long write_err
,
780 struct region
*reg
= (struct region
*)context
;
781 struct mirror_set
*ms
= reg
->rh
->ms
;
785 /* Read error means the failure of default mirror. */
786 DMERR_LIMIT("Unable to read primary mirror during recovery");
787 fail_mirror(get_default_mirror(ms
), DM_RAID1_SYNC_ERROR
);
791 DMERR_LIMIT("Write error during recovery (error = 0x%lx)",
794 * Bits correspond to devices (excluding default mirror).
795 * The default mirror cannot change during recovery.
797 for (m
= 0; m
< ms
->nr_mirrors
; m
++) {
798 if (&ms
->mirror
[m
] == get_default_mirror(ms
))
800 if (test_bit(bit
, &write_err
))
801 fail_mirror(ms
->mirror
+ m
,
802 DM_RAID1_SYNC_ERROR
);
807 rh_recovery_end(reg
, !(read_err
|| write_err
));
810 static int recover(struct mirror_set
*ms
, struct region
*reg
)
814 struct dm_io_region from
, to
[DM_KCOPYD_MAX_REGIONS
], *dest
;
816 unsigned long flags
= 0;
818 /* fill in the source */
819 m
= get_default_mirror(ms
);
820 from
.bdev
= m
->dev
->bdev
;
821 from
.sector
= m
->offset
+ region_to_sector(reg
->rh
, reg
->key
);
822 if (reg
->key
== (ms
->nr_regions
- 1)) {
824 * The final region may be smaller than
827 from
.count
= ms
->ti
->len
& (reg
->rh
->region_size
- 1);
829 from
.count
= reg
->rh
->region_size
;
831 from
.count
= reg
->rh
->region_size
;
833 /* fill in the destinations */
834 for (i
= 0, dest
= to
; i
< ms
->nr_mirrors
; i
++) {
835 if (&ms
->mirror
[i
] == get_default_mirror(ms
))
839 dest
->bdev
= m
->dev
->bdev
;
840 dest
->sector
= m
->offset
+ region_to_sector(reg
->rh
, reg
->key
);
841 dest
->count
= from
.count
;
846 if (!errors_handled(ms
))
847 set_bit(DM_KCOPYD_IGNORE_ERROR
, &flags
);
849 r
= dm_kcopyd_copy(ms
->kcopyd_client
, &from
, ms
->nr_mirrors
- 1, to
,
850 flags
, recovery_complete
, reg
);
855 static void do_recovery(struct mirror_set
*ms
)
859 struct dm_dirty_log
*log
= ms
->rh
.log
;
862 * Start quiescing some regions.
864 rh_recovery_prepare(&ms
->rh
);
867 * Copy any already quiesced regions.
869 while ((reg
= rh_recovery_start(&ms
->rh
))) {
870 r
= recover(ms
, reg
);
872 rh_recovery_end(reg
, 0);
876 * Update the in sync flag.
879 (log
->type
->get_sync_count(log
) == ms
->nr_regions
)) {
880 /* the sync is complete */
881 dm_table_event(ms
->ti
->table
);
886 /*-----------------------------------------------------------------
888 *---------------------------------------------------------------*/
889 static struct mirror
*choose_mirror(struct mirror_set
*ms
, sector_t sector
)
891 struct mirror
*m
= get_default_mirror(ms
);
894 if (likely(!atomic_read(&m
->error_count
)))
897 if (m
-- == ms
->mirror
)
899 } while (m
!= get_default_mirror(ms
));
904 static int default_ok(struct mirror
*m
)
906 struct mirror
*default_mirror
= get_default_mirror(m
->ms
);
908 return !atomic_read(&default_mirror
->error_count
);
911 static int mirror_available(struct mirror_set
*ms
, struct bio
*bio
)
913 region_t region
= bio_to_region(&ms
->rh
, bio
);
915 if (ms
->rh
.log
->type
->in_sync(ms
->rh
.log
, region
, 0))
916 return choose_mirror(ms
, bio
->bi_sector
) ? 1 : 0;
922 * remap a buffer to a particular mirror.
924 static sector_t
map_sector(struct mirror
*m
, struct bio
*bio
)
926 return m
->offset
+ (bio
->bi_sector
- m
->ms
->ti
->begin
);
929 static void map_bio(struct mirror
*m
, struct bio
*bio
)
931 bio
->bi_bdev
= m
->dev
->bdev
;
932 bio
->bi_sector
= map_sector(m
, bio
);
935 static void map_region(struct dm_io_region
*io
, struct mirror
*m
,
938 io
->bdev
= m
->dev
->bdev
;
939 io
->sector
= map_sector(m
, bio
);
940 io
->count
= bio
->bi_size
>> 9;
943 /*-----------------------------------------------------------------
945 *---------------------------------------------------------------*/
946 static void read_callback(unsigned long error
, void *context
)
948 struct bio
*bio
= context
;
952 bio_set_m(bio
, NULL
);
954 if (likely(!error
)) {
959 fail_mirror(m
, DM_RAID1_READ_ERROR
);
961 if (likely(default_ok(m
)) || mirror_available(m
->ms
, bio
)) {
962 DMWARN_LIMIT("Read failure on mirror device %s. "
963 "Trying alternative device.",
965 queue_bio(m
->ms
, bio
, bio_rw(bio
));
969 DMERR_LIMIT("Read failure on mirror device %s. Failing I/O.",
971 bio_endio(bio
, -EIO
);
974 /* Asynchronous read. */
975 static void read_async_bio(struct mirror
*m
, struct bio
*bio
)
977 struct dm_io_region io
;
978 struct dm_io_request io_req
= {
980 .mem
.type
= DM_IO_BVEC
,
981 .mem
.ptr
.bvec
= bio
->bi_io_vec
+ bio
->bi_idx
,
982 .notify
.fn
= read_callback
,
983 .notify
.context
= bio
,
984 .client
= m
->ms
->io_client
,
987 map_region(&io
, m
, bio
);
989 (void) dm_io(&io_req
, 1, &io
, NULL
);
992 static void do_reads(struct mirror_set
*ms
, struct bio_list
*reads
)
998 while ((bio
= bio_list_pop(reads
))) {
999 region
= bio_to_region(&ms
->rh
, bio
);
1000 m
= get_default_mirror(ms
);
1003 * We can only read balance if the region is in sync.
1005 if (likely(rh_in_sync(&ms
->rh
, region
, 1)))
1006 m
= choose_mirror(ms
, bio
->bi_sector
);
1007 else if (m
&& atomic_read(&m
->error_count
))
1011 read_async_bio(m
, bio
);
1013 bio_endio(bio
, -EIO
);
1017 /*-----------------------------------------------------------------
1020 * We do different things with the write io depending on the
1021 * state of the region that it's in:
1023 * SYNC: increment pending, use kcopyd to write to *all* mirrors
1024 * RECOVERING: delay the io until recovery completes
1025 * NOSYNC: increment pending, just write to the default mirror
1026 *---------------------------------------------------------------*/
1028 /* __bio_mark_nosync
1034 * The bio was written on some mirror(s) but failed on other mirror(s).
1035 * We can successfully endio the bio but should avoid the region being
1036 * marked clean by setting the state RH_NOSYNC.
1038 * This function is _not_ safe in interrupt context!
1040 static void __bio_mark_nosync(struct mirror_set
*ms
,
1041 struct bio
*bio
, unsigned done
, int error
)
1043 unsigned long flags
;
1044 struct region_hash
*rh
= &ms
->rh
;
1045 struct dm_dirty_log
*log
= ms
->rh
.log
;
1047 region_t region
= bio_to_region(rh
, bio
);
1050 /* We must inform the log that the sync count has changed. */
1051 log
->type
->set_region_sync(log
, region
, 0);
1054 read_lock(&rh
->hash_lock
);
1055 reg
= __rh_find(rh
, region
);
1056 read_unlock(&rh
->hash_lock
);
1058 /* region hash entry should exist because write was in-flight */
1060 BUG_ON(!list_empty(®
->list
));
1062 spin_lock_irqsave(&rh
->region_lock
, flags
);
1066 * 2) RH_NOSYNC: was dirty, other preceeding writes failed
1067 * 3) RH_RECOVERING: flushing pending writes
1068 * Either case, the region should have not been connected to list.
1070 recovering
= (reg
->state
== RH_RECOVERING
);
1071 reg
->state
= RH_NOSYNC
;
1072 BUG_ON(!list_empty(®
->list
));
1073 spin_unlock_irqrestore(&rh
->region_lock
, flags
);
1075 bio_endio(bio
, error
);
1077 complete_resync_work(reg
, 0);
1080 static void write_callback(unsigned long error
, void *context
)
1082 unsigned i
, ret
= 0;
1083 struct bio
*bio
= (struct bio
*) context
;
1084 struct mirror_set
*ms
;
1086 int should_wake
= 0;
1087 unsigned long flags
;
1089 ms
= bio_get_m(bio
)->ms
;
1090 bio_set_m(bio
, NULL
);
1093 * NOTE: We don't decrement the pending count here,
1094 * instead it is done by the targets endio function.
1095 * This way we handle both writes to SYNC and NOSYNC
1096 * regions with the same code.
1101 for (i
= 0; i
< ms
->nr_mirrors
; i
++)
1102 if (test_bit(i
, &error
))
1103 fail_mirror(ms
->mirror
+ i
, DM_RAID1_WRITE_ERROR
);
1107 if (unlikely(!uptodate
)) {
1108 DMERR("All replicated volumes dead, failing I/O");
1109 /* None of the writes succeeded, fail the I/O. */
1111 } else if (errors_handled(ms
)) {
1113 * Need to raise event. Since raising
1114 * events can block, we need to do it in
1117 spin_lock_irqsave(&ms
->lock
, flags
);
1118 if (!ms
->failures
.head
)
1120 bio_list_add(&ms
->failures
, bio
);
1121 spin_unlock_irqrestore(&ms
->lock
, flags
);
1127 bio_endio(bio
, ret
);
1130 static void do_write(struct mirror_set
*ms
, struct bio
*bio
)
1133 struct dm_io_region io
[ms
->nr_mirrors
], *dest
= io
;
1135 struct dm_io_request io_req
= {
1137 .mem
.type
= DM_IO_BVEC
,
1138 .mem
.ptr
.bvec
= bio
->bi_io_vec
+ bio
->bi_idx
,
1139 .notify
.fn
= write_callback
,
1140 .notify
.context
= bio
,
1141 .client
= ms
->io_client
,
1144 for (i
= 0, m
= ms
->mirror
; i
< ms
->nr_mirrors
; i
++, m
++)
1145 map_region(dest
++, m
, bio
);
1148 * Use default mirror because we only need it to retrieve the reference
1149 * to the mirror set in write_callback().
1151 bio_set_m(bio
, get_default_mirror(ms
));
1153 (void) dm_io(&io_req
, ms
->nr_mirrors
, io
, NULL
);
1156 static void do_writes(struct mirror_set
*ms
, struct bio_list
*writes
)
1160 struct bio_list sync
, nosync
, recover
, *this_list
= NULL
;
1166 * Classify each write.
1168 bio_list_init(&sync
);
1169 bio_list_init(&nosync
);
1170 bio_list_init(&recover
);
1172 while ((bio
= bio_list_pop(writes
))) {
1173 state
= rh_state(&ms
->rh
, bio_to_region(&ms
->rh
, bio
), 1);
1181 this_list
= &nosync
;
1185 this_list
= &recover
;
1189 bio_list_add(this_list
, bio
);
1193 * Increment the pending counts for any regions that will
1194 * be written to (writes to recover regions are going to
1197 rh_inc_pending(&ms
->rh
, &sync
);
1198 rh_inc_pending(&ms
->rh
, &nosync
);
1199 ms
->log_failure
= rh_flush(&ms
->rh
) ? 1 : 0;
1204 if (unlikely(ms
->log_failure
)) {
1205 spin_lock_irq(&ms
->lock
);
1206 bio_list_merge(&ms
->failures
, &sync
);
1207 spin_unlock_irq(&ms
->lock
);
1210 while ((bio
= bio_list_pop(&sync
)))
1213 while ((bio
= bio_list_pop(&recover
)))
1214 rh_delay(&ms
->rh
, bio
);
1216 while ((bio
= bio_list_pop(&nosync
))) {
1217 map_bio(get_default_mirror(ms
), bio
);
1218 generic_make_request(bio
);
1222 static void do_failures(struct mirror_set
*ms
, struct bio_list
*failures
)
1226 if (!failures
->head
)
1229 if (!ms
->log_failure
) {
1230 while ((bio
= bio_list_pop(failures
)))
1231 __bio_mark_nosync(ms
, bio
, bio
->bi_size
, 0);
1236 * If the log has failed, unattempted writes are being
1237 * put on the failures list. We can't issue those writes
1238 * until a log has been marked, so we must store them.
1240 * If a 'noflush' suspend is in progress, we can requeue
1241 * the I/O's to the core. This give userspace a chance
1242 * to reconfigure the mirror, at which point the core
1243 * will reissue the writes. If the 'noflush' flag is
1244 * not set, we have no choice but to return errors.
1246 * Some writes on the failures list may have been
1247 * submitted before the log failure and represent a
1248 * failure to write to one of the devices. It is ok
1249 * for us to treat them the same and requeue them
1252 if (dm_noflush_suspending(ms
->ti
)) {
1253 while ((bio
= bio_list_pop(failures
)))
1254 bio_endio(bio
, DM_ENDIO_REQUEUE
);
1258 if (atomic_read(&ms
->suspend
)) {
1259 while ((bio
= bio_list_pop(failures
)))
1260 bio_endio(bio
, -EIO
);
1264 spin_lock_irq(&ms
->lock
);
1265 bio_list_merge(&ms
->failures
, failures
);
1266 spin_unlock_irq(&ms
->lock
);
1271 static void trigger_event(struct work_struct
*work
)
1273 struct mirror_set
*ms
=
1274 container_of(work
, struct mirror_set
, trigger_event
);
1276 dm_table_event(ms
->ti
->table
);
1279 /*-----------------------------------------------------------------
1281 *---------------------------------------------------------------*/
1282 static void do_mirror(struct work_struct
*work
)
1284 struct mirror_set
*ms
=container_of(work
, struct mirror_set
,
1286 struct bio_list reads
, writes
, failures
;
1287 unsigned long flags
;
1289 spin_lock_irqsave(&ms
->lock
, flags
);
1291 writes
= ms
->writes
;
1292 failures
= ms
->failures
;
1293 bio_list_init(&ms
->reads
);
1294 bio_list_init(&ms
->writes
);
1295 bio_list_init(&ms
->failures
);
1296 spin_unlock_irqrestore(&ms
->lock
, flags
);
1298 rh_update_states(&ms
->rh
);
1300 do_reads(ms
, &reads
);
1301 do_writes(ms
, &writes
);
1302 do_failures(ms
, &failures
);
1304 dm_table_unplug_all(ms
->ti
->table
);
1308 /*-----------------------------------------------------------------
1310 *---------------------------------------------------------------*/
1311 static struct mirror_set
*alloc_context(unsigned int nr_mirrors
,
1312 uint32_t region_size
,
1313 struct dm_target
*ti
,
1314 struct dm_dirty_log
*dl
)
1317 struct mirror_set
*ms
= NULL
;
1319 len
= sizeof(*ms
) + (sizeof(ms
->mirror
[0]) * nr_mirrors
);
1321 ms
= kzalloc(len
, GFP_KERNEL
);
1323 ti
->error
= "Cannot allocate mirror context";
1327 spin_lock_init(&ms
->lock
);
1330 ms
->nr_mirrors
= nr_mirrors
;
1331 ms
->nr_regions
= dm_sector_div_up(ti
->len
, region_size
);
1333 ms
->log_failure
= 0;
1334 atomic_set(&ms
->suspend
, 0);
1335 atomic_set(&ms
->default_mirror
, DEFAULT_MIRROR
);
1337 len
= sizeof(struct dm_raid1_read_record
);
1338 ms
->read_record_pool
= mempool_create_kmalloc_pool(MIN_READ_RECORDS
,
1340 if (!ms
->read_record_pool
) {
1341 ti
->error
= "Error creating mirror read_record_pool";
1346 ms
->io_client
= dm_io_client_create(DM_IO_PAGES
);
1347 if (IS_ERR(ms
->io_client
)) {
1348 ti
->error
= "Error creating dm_io client";
1349 mempool_destroy(ms
->read_record_pool
);
1354 if (rh_init(&ms
->rh
, ms
, dl
, region_size
, ms
->nr_regions
)) {
1355 ti
->error
= "Error creating dirty region hash";
1356 dm_io_client_destroy(ms
->io_client
);
1357 mempool_destroy(ms
->read_record_pool
);
1365 static void free_context(struct mirror_set
*ms
, struct dm_target
*ti
,
1369 dm_put_device(ti
, ms
->mirror
[m
].dev
);
1371 dm_io_client_destroy(ms
->io_client
);
1373 mempool_destroy(ms
->read_record_pool
);
1377 static inline int _check_region_size(struct dm_target
*ti
, uint32_t size
)
1379 return !(size
% (PAGE_SIZE
>> 9) || !is_power_of_2(size
) ||
1383 static int get_mirror(struct mirror_set
*ms
, struct dm_target
*ti
,
1384 unsigned int mirror
, char **argv
)
1386 unsigned long long offset
;
1388 if (sscanf(argv
[1], "%llu", &offset
) != 1) {
1389 ti
->error
= "Invalid offset";
1393 if (dm_get_device(ti
, argv
[0], offset
, ti
->len
,
1394 dm_table_get_mode(ti
->table
),
1395 &ms
->mirror
[mirror
].dev
)) {
1396 ti
->error
= "Device lookup failure";
1400 ms
->mirror
[mirror
].ms
= ms
;
1401 atomic_set(&(ms
->mirror
[mirror
].error_count
), 0);
1402 ms
->mirror
[mirror
].error_type
= 0;
1403 ms
->mirror
[mirror
].offset
= offset
;
1409 * Create dirty log: log_type #log_params <log_params>
1411 static struct dm_dirty_log
*create_dirty_log(struct dm_target
*ti
,
1412 unsigned int argc
, char **argv
,
1413 unsigned int *args_used
)
1415 unsigned int param_count
;
1416 struct dm_dirty_log
*dl
;
1419 ti
->error
= "Insufficient mirror log arguments";
1423 if (sscanf(argv
[1], "%u", ¶m_count
) != 1) {
1424 ti
->error
= "Invalid mirror log argument count";
1428 *args_used
= 2 + param_count
;
1430 if (argc
< *args_used
) {
1431 ti
->error
= "Insufficient mirror log arguments";
1435 dl
= dm_dirty_log_create(argv
[0], ti
, param_count
, argv
+ 2);
1437 ti
->error
= "Error creating mirror dirty log";
1441 if (!_check_region_size(ti
, dl
->type
->get_region_size(dl
))) {
1442 ti
->error
= "Invalid region size";
1443 dm_dirty_log_destroy(dl
);
1450 static int parse_features(struct mirror_set
*ms
, unsigned argc
, char **argv
,
1451 unsigned *args_used
)
1453 unsigned num_features
;
1454 struct dm_target
*ti
= ms
->ti
;
1461 if (sscanf(argv
[0], "%u", &num_features
) != 1) {
1462 ti
->error
= "Invalid number of features";
1470 if (num_features
> argc
) {
1471 ti
->error
= "Not enough arguments to support feature count";
1475 if (!strcmp("handle_errors", argv
[0]))
1476 ms
->features
|= DM_RAID1_HANDLE_ERRORS
;
1478 ti
->error
= "Unrecognised feature requested";
1488 * Construct a mirror mapping:
1490 * log_type #log_params <log_params>
1491 * #mirrors [mirror_path offset]{2,}
1492 * [#features <features>]
1494 * log_type is "core" or "disk"
1495 * #log_params is between 1 and 3
1497 * If present, features must be "handle_errors".
1499 static int mirror_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
1502 unsigned int nr_mirrors
, m
, args_used
;
1503 struct mirror_set
*ms
;
1504 struct dm_dirty_log
*dl
;
1506 dl
= create_dirty_log(ti
, argc
, argv
, &args_used
);
1513 if (!argc
|| sscanf(argv
[0], "%u", &nr_mirrors
) != 1 ||
1514 nr_mirrors
< 2 || nr_mirrors
> DM_KCOPYD_MAX_REGIONS
+ 1) {
1515 ti
->error
= "Invalid number of mirrors";
1516 dm_dirty_log_destroy(dl
);
1522 if (argc
< nr_mirrors
* 2) {
1523 ti
->error
= "Too few mirror arguments";
1524 dm_dirty_log_destroy(dl
);
1528 ms
= alloc_context(nr_mirrors
, dl
->type
->get_region_size(dl
), ti
, dl
);
1530 dm_dirty_log_destroy(dl
);
1534 /* Get the mirror parameter sets */
1535 for (m
= 0; m
< nr_mirrors
; m
++) {
1536 r
= get_mirror(ms
, ti
, m
, argv
);
1538 free_context(ms
, ti
, m
);
1546 ti
->split_io
= ms
->rh
.region_size
;
1548 ms
->kmirrord_wq
= create_singlethread_workqueue("kmirrord");
1549 if (!ms
->kmirrord_wq
) {
1550 DMERR("couldn't start kmirrord");
1552 goto err_free_context
;
1554 INIT_WORK(&ms
->kmirrord_work
, do_mirror
);
1555 init_timer(&ms
->timer
);
1556 ms
->timer_pending
= 0;
1557 INIT_WORK(&ms
->trigger_event
, trigger_event
);
1559 r
= parse_features(ms
, argc
, argv
, &args_used
);
1561 goto err_destroy_wq
;
1567 * Any read-balancing addition depends on the
1568 * DM_RAID1_HANDLE_ERRORS flag being present.
1569 * This is because the decision to balance depends
1570 * on the sync state of a region. If the above
1571 * flag is not present, we ignore errors; and
1572 * the sync state may be inaccurate.
1576 ti
->error
= "Too many mirror arguments";
1578 goto err_destroy_wq
;
1581 r
= dm_kcopyd_client_create(DM_IO_PAGES
, &ms
->kcopyd_client
);
1583 goto err_destroy_wq
;
1589 destroy_workqueue(ms
->kmirrord_wq
);
1591 free_context(ms
, ti
, ms
->nr_mirrors
);
1595 static void mirror_dtr(struct dm_target
*ti
)
1597 struct mirror_set
*ms
= (struct mirror_set
*) ti
->private;
1599 del_timer_sync(&ms
->timer
);
1600 flush_workqueue(ms
->kmirrord_wq
);
1601 dm_kcopyd_client_destroy(ms
->kcopyd_client
);
1602 destroy_workqueue(ms
->kmirrord_wq
);
1603 free_context(ms
, ti
, ms
->nr_mirrors
);
1606 static void queue_bio(struct mirror_set
*ms
, struct bio
*bio
, int rw
)
1608 unsigned long flags
;
1609 int should_wake
= 0;
1610 struct bio_list
*bl
;
1612 bl
= (rw
== WRITE
) ? &ms
->writes
: &ms
->reads
;
1613 spin_lock_irqsave(&ms
->lock
, flags
);
1614 should_wake
= !(bl
->head
);
1615 bio_list_add(bl
, bio
);
1616 spin_unlock_irqrestore(&ms
->lock
, flags
);
1623 * Mirror mapping function
1625 static int mirror_map(struct dm_target
*ti
, struct bio
*bio
,
1626 union map_info
*map_context
)
1628 int r
, rw
= bio_rw(bio
);
1630 struct mirror_set
*ms
= ti
->private;
1631 struct dm_raid1_read_record
*read_record
= NULL
;
1634 /* Save region for mirror_end_io() handler */
1635 map_context
->ll
= bio_to_region(&ms
->rh
, bio
);
1636 queue_bio(ms
, bio
, rw
);
1637 return DM_MAPIO_SUBMITTED
;
1640 r
= ms
->rh
.log
->type
->in_sync(ms
->rh
.log
,
1641 bio_to_region(&ms
->rh
, bio
), 0);
1642 if (r
< 0 && r
!= -EWOULDBLOCK
)
1646 * If region is not in-sync queue the bio.
1648 if (!r
|| (r
== -EWOULDBLOCK
)) {
1650 return -EWOULDBLOCK
;
1652 queue_bio(ms
, bio
, rw
);
1653 return DM_MAPIO_SUBMITTED
;
1657 * The region is in-sync and we can perform reads directly.
1658 * Store enough information so we can retry if it fails.
1660 m
= choose_mirror(ms
, bio
->bi_sector
);
1664 read_record
= mempool_alloc(ms
->read_record_pool
, GFP_NOIO
);
1665 if (likely(read_record
)) {
1666 dm_bio_record(&read_record
->details
, bio
);
1667 map_context
->ptr
= read_record
;
1673 return DM_MAPIO_REMAPPED
;
1676 static int mirror_end_io(struct dm_target
*ti
, struct bio
*bio
,
1677 int error
, union map_info
*map_context
)
1679 int rw
= bio_rw(bio
);
1680 struct mirror_set
*ms
= (struct mirror_set
*) ti
->private;
1681 struct mirror
*m
= NULL
;
1682 struct dm_bio_details
*bd
= NULL
;
1683 struct dm_raid1_read_record
*read_record
= map_context
->ptr
;
1686 * We need to dec pending if this was a write.
1689 rh_dec(&ms
->rh
, map_context
->ll
);
1693 if (error
== -EOPNOTSUPP
)
1696 if ((error
== -EWOULDBLOCK
) && bio_rw_ahead(bio
))
1699 if (unlikely(error
)) {
1702 * There wasn't enough memory to record necessary
1703 * information for a retry or there was no other
1706 DMERR_LIMIT("Mirror read failed.");
1712 DMERR("Mirror read failed from %s. Trying alternative device.",
1715 fail_mirror(m
, DM_RAID1_READ_ERROR
);
1718 * A failed read is requeued for another attempt using an intact
1721 if (default_ok(m
) || mirror_available(ms
, bio
)) {
1722 bd
= &read_record
->details
;
1724 dm_bio_restore(bd
, bio
);
1725 mempool_free(read_record
, ms
->read_record_pool
);
1726 map_context
->ptr
= NULL
;
1727 queue_bio(ms
, bio
, rw
);
1730 DMERR("All replicated volumes dead, failing I/O");
1735 mempool_free(read_record
, ms
->read_record_pool
);
1736 map_context
->ptr
= NULL
;
1742 static void mirror_presuspend(struct dm_target
*ti
)
1744 struct mirror_set
*ms
= (struct mirror_set
*) ti
->private;
1745 struct dm_dirty_log
*log
= ms
->rh
.log
;
1747 atomic_set(&ms
->suspend
, 1);
1750 * We must finish up all the work that we've
1751 * generated (i.e. recovery work).
1753 rh_stop_recovery(&ms
->rh
);
1755 wait_event(_kmirrord_recovery_stopped
,
1756 !atomic_read(&ms
->rh
.recovery_in_flight
));
1758 if (log
->type
->presuspend
&& log
->type
->presuspend(log
))
1759 /* FIXME: need better error handling */
1760 DMWARN("log presuspend failed");
1763 * Now that recovery is complete/stopped and the
1764 * delayed bios are queued, we need to wait for
1765 * the worker thread to complete. This way,
1766 * we know that all of our I/O has been pushed.
1768 flush_workqueue(ms
->kmirrord_wq
);
1771 static void mirror_postsuspend(struct dm_target
*ti
)
1773 struct mirror_set
*ms
= ti
->private;
1774 struct dm_dirty_log
*log
= ms
->rh
.log
;
1776 if (log
->type
->postsuspend
&& log
->type
->postsuspend(log
))
1777 /* FIXME: need better error handling */
1778 DMWARN("log postsuspend failed");
1781 static void mirror_resume(struct dm_target
*ti
)
1783 struct mirror_set
*ms
= ti
->private;
1784 struct dm_dirty_log
*log
= ms
->rh
.log
;
1786 atomic_set(&ms
->suspend
, 0);
1787 if (log
->type
->resume
&& log
->type
->resume(log
))
1788 /* FIXME: need better error handling */
1789 DMWARN("log resume failed");
1790 rh_start_recovery(&ms
->rh
);
1794 * device_status_char
1795 * @m: mirror device/leg we want the status of
1797 * We return one character representing the most severe error
1798 * we have encountered.
1799 * A => Alive - No failures
1800 * D => Dead - A write failure occurred leaving mirror out-of-sync
1801 * S => Sync - A sychronization failure occurred, mirror out-of-sync
1802 * R => Read - A read failure occurred, mirror data unaffected
1806 static char device_status_char(struct mirror
*m
)
1808 if (!atomic_read(&(m
->error_count
)))
1811 return (test_bit(DM_RAID1_WRITE_ERROR
, &(m
->error_type
))) ? 'D' :
1812 (test_bit(DM_RAID1_SYNC_ERROR
, &(m
->error_type
))) ? 'S' :
1813 (test_bit(DM_RAID1_READ_ERROR
, &(m
->error_type
))) ? 'R' : 'U';
1817 static int mirror_status(struct dm_target
*ti
, status_type_t type
,
1818 char *result
, unsigned int maxlen
)
1820 unsigned int m
, sz
= 0;
1821 struct mirror_set
*ms
= (struct mirror_set
*) ti
->private;
1822 struct dm_dirty_log
*log
= ms
->rh
.log
;
1823 char buffer
[ms
->nr_mirrors
+ 1];
1826 case STATUSTYPE_INFO
:
1827 DMEMIT("%d ", ms
->nr_mirrors
);
1828 for (m
= 0; m
< ms
->nr_mirrors
; m
++) {
1829 DMEMIT("%s ", ms
->mirror
[m
].dev
->name
);
1830 buffer
[m
] = device_status_char(&(ms
->mirror
[m
]));
1834 DMEMIT("%llu/%llu 1 %s ",
1835 (unsigned long long)log
->type
->get_sync_count(ms
->rh
.log
),
1836 (unsigned long long)ms
->nr_regions
, buffer
);
1838 sz
+= log
->type
->status(ms
->rh
.log
, type
, result
+sz
, maxlen
-sz
);
1842 case STATUSTYPE_TABLE
:
1843 sz
= log
->type
->status(ms
->rh
.log
, type
, result
, maxlen
);
1845 DMEMIT("%d", ms
->nr_mirrors
);
1846 for (m
= 0; m
< ms
->nr_mirrors
; m
++)
1847 DMEMIT(" %s %llu", ms
->mirror
[m
].dev
->name
,
1848 (unsigned long long)ms
->mirror
[m
].offset
);
1850 if (ms
->features
& DM_RAID1_HANDLE_ERRORS
)
1851 DMEMIT(" 1 handle_errors");
1857 static struct target_type mirror_target
= {
1859 .version
= {1, 0, 20},
1860 .module
= THIS_MODULE
,
1864 .end_io
= mirror_end_io
,
1865 .presuspend
= mirror_presuspend
,
1866 .postsuspend
= mirror_postsuspend
,
1867 .resume
= mirror_resume
,
1868 .status
= mirror_status
,
1871 static int __init
dm_mirror_init(void)
1875 r
= dm_register_target(&mirror_target
);
1877 DMERR("Failed to register mirror target");
1882 static void __exit
dm_mirror_exit(void)
1886 r
= dm_unregister_target(&mirror_target
);
1888 DMERR("unregister failed %d", r
);
1892 module_init(dm_mirror_init
);
1893 module_exit(dm_mirror_exit
);
1895 MODULE_DESCRIPTION(DM_NAME
" mirror target");
1896 MODULE_AUTHOR("Joe Thornber");
1897 MODULE_LICENSE("GPL");