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