drivers/md/raid1.h

   1 #ifndef _RAID1_H
   2 #define _RAID1_H
   3
   4 struct mirror_info {
   5         struct md_rdev  *rdev;
   6         sector_t        head_position;
   7 };
   8
   9 /*
  10  * memory pools need a pointer to the mddev, so they can force an unplug
  11  * when memory is tight, and a count of the number of drives that the
  12  * pool was allocated for, so they know how much to allocate and free.
  13  * mddev->raid_disks cannot be used, as it can change while a pool is active
  14  * These two datums are stored in a kmalloced struct.
  15  */
  16
  17 struct pool_info {
  18         struct mddev *mddev;
  19         int     raid_disks;
  20 };
  21
  22 struct r1conf {
  23         struct mddev            *mddev;
  24         struct mirror_info              *mirrors;
  25         int                     raid_disks;
  26
  27         /* When choose the best device for a read (read_balance())
  28          * we try to keep sequential reads one the same device
  29          * using 'last_used' and 'next_seq_sect'
  30          */
  31         int                     last_used;
  32         sector_t                next_seq_sect;
  33         /* During resync, read_balancing is only allowed on the part
  34          * of the array that has been resynced.  'next_resync' tells us
  35          * where that is.
  36          */
  37         sector_t                next_resync;
  38
  39         spinlock_t              device_lock;
  40
  41         /* list of 'struct r1bio' that need to be processed by raid1d,
  42          * whether to retry a read, writeout a resync or recovery
  43          * block, or anything else.
  44          */
  45         struct list_head        retry_list;
  46
  47         /* queue pending writes to be submitted on unplug */
  48         struct bio_list         pending_bio_list;
  49         int                     pending_count;
  50
  51         /* for use when syncing mirrors:
  52          * We don't allow both normal IO and resync/recovery IO at
  53          * the same time - resync/recovery can only happen when there
  54          * is no other IO.  So when either is active, the other has to wait.
  55          * See more details description in raid1.c near raise_barrier().
  56          */
  57         wait_queue_head_t       wait_barrier;
  58         spinlock_t              resync_lock;
  59         int                     nr_pending;
  60         int                     nr_waiting;
  61         int                     nr_queued;
  62         int                     barrier;
  63
  64         /* Set to 1 if a full sync is needed, (fresh device added).
  65          * Cleared when a sync completes.
  66          */
  67         int                     fullsync;
  68
  69         /* When the same as mddev->recovery_disabled we don't allow
  70          * recovery to be attempted as we expect a read error.
  71          */
  72         int                     recovery_disabled;
  73
  74
  75         /* poolinfo contains information about the content of the
  76          * mempools - it changes when the array grows or shrinks
  77          */
  78         struct pool_info        *poolinfo;
  79         mempool_t               *r1bio_pool;
  80         mempool_t               *r1buf_pool;
  81
  82         /* temporary buffer to synchronous IO when attempting to repair
  83          * a read error.
  84          */
  85         struct page             *tmppage;
  86
  87
  88         /* When taking over an array from a different personality, we store
  89          * the new thread here until we fully activate the array.
  90          */
  91         struct md_thread        *thread;
  92 };
  93
  94 /*
  95  * this is our 'private' RAID1 bio.
  96  *
  97  * it contains information about what kind of IO operations were started
  98  * for this RAID1 operation, and about their status:
  99  */
 100
 101 struct r1bio {
 102         atomic_t                remaining; /* 'have we finished' count,
 103                                             * used from IRQ handlers
 104                                             */
 105         atomic_t                behind_remaining; /* number of write-behind ios remaining
 106                                                  * in this BehindIO request
 107                                                  */
 108         sector_t                sector;
 109         int                     sectors;
 110         unsigned long           state;
 111         struct mddev            *mddev;
 112         /*
 113          * original bio going to /dev/mdx
 114          */
 115         struct bio              *master_bio;
 116         /*
 117          * if the IO is in READ direction, then this is where we read
 118          */
 119         int                     read_disk;
 120
 121         struct list_head        retry_list;
 122         /* Next two are only valid when R1BIO_BehindIO is set */
 123         struct bio_vec          *behind_bvecs;
 124         int                     behind_page_count;
 125         /*
 126          * if the IO is in WRITE direction, then multiple bios are used.
 127          * We choose the number when they are allocated.
 128          */
 129         struct bio              *bios[0];
 130         /* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/
 131 };
 132
 133 /* when we get a read error on a read-only array, we redirect to another
 134  * device without failing the first device, or trying to over-write to
 135  * correct the read error.  To keep track of bad blocks on a per-bio
 136  * level, we store IO_BLOCKED in the appropriate 'bios' pointer
 137  */
 138 #define IO_BLOCKED ((struct bio *)1)
 139 /* When we successfully write to a known bad-block, we need to remove the
 140  * bad-block marking which must be done from process context.  So we record
 141  * the success by setting bios[n] to IO_MADE_GOOD
 142  */
 143 #define IO_MADE_GOOD ((struct bio *)2)
 144
 145 #define BIO_SPECIAL(bio) ((unsigned long)bio <= 2)
 146
 147 /* bits for r1bio.state */
 148 #define R1BIO_Uptodate  0
 149 #define R1BIO_IsSync    1
 150 #define R1BIO_Degraded  2
 151 #define R1BIO_BehindIO  3
 152 /* Set ReadError on bios that experience a readerror so that
 153  * raid1d knows what to do with them.
 154  */
 155 #define R1BIO_ReadError 4
 156 /* For write-behind requests, we call bi_end_io when
 157  * the last non-write-behind device completes, providing
 158  * any write was successful.  Otherwise we call when
 159  * any write-behind write succeeds, otherwise we call
 160  * with failure when last write completes (and all failed).
 161  * Record that bi_end_io was called with this flag...
 162  */
 163 #define R1BIO_Returned 6
 164 /* If a write for this request means we can clear some
 165  * known-bad-block records, we set this flag
 166  */
 167 #define R1BIO_MadeGood 7
 168 #define R1BIO_WriteError 8
 169
 170 extern int md_raid1_congested(struct mddev *mddev, int bits);
 171
 172 #endif