1#ifndef _RAID1_H 2#define _RAID1_H 3 4struct 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 * The 'raid_disks' here is twice the raid_disks in r1conf. 16 * This allows space for each 'real' device can have a replacement in the 17 * second half of the array. 18 */ 19 20struct pool_info { 21 struct mddev *mddev; 22 int raid_disks; 23}; 24 25struct r1conf { 26 struct mddev *mddev; 27 struct mirror_info *mirrors; /* twice 'raid_disks' to 28 * allow for replacements. 29 */ 30 int raid_disks; 31 32 /* When choose the best device for a read (read_balance()) 33 * we try to keep sequential reads one the same device 34 * using 'last_used' and 'next_seq_sect' 35 */ 36 int last_used; 37 sector_t next_seq_sect; 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/* when we get a read error on a read-only array, we redirect to another 139 * device without failing the first device, or trying to over-write to 140 * correct the read error. To keep track of bad blocks on a per-bio 141 * level, we store IO_BLOCKED in the appropriate 'bios' pointer 142 */ 143#define IO_BLOCKED ((struct bio *)1) 144/* When we successfully write to a known bad-block, we need to remove the 145 * bad-block marking which must be done from process context. So we record 146 * the success by setting bios[n] to IO_MADE_GOOD 147 */ 148#define IO_MADE_GOOD ((struct bio *)2) 149 150#define BIO_SPECIAL(bio) ((unsigned long)bio <= 2) 151 152/* bits for r1bio.state */ 153#define R1BIO_Uptodate 0 154#define R1BIO_IsSync 1 155#define R1BIO_Degraded 2 156#define R1BIO_BehindIO 3 157/* Set ReadError on bios that experience a readerror so that 158 * raid1d knows what to do with them. 159 */ 160#define R1BIO_ReadError 4 161/* For write-behind requests, we call bi_end_io when 162 * the last non-write-behind device completes, providing 163 * any write was successful. Otherwise we call when 164 * any write-behind write succeeds, otherwise we call 165 * with failure when last write completes (and all failed). 166 * Record that bi_end_io was called with this flag... 167 */ 168#define R1BIO_Returned 6 169/* If a write for this request means we can clear some 170 * known-bad-block records, we set this flag 171 */ 172#define R1BIO_MadeGood 7 173#define R1BIO_WriteError 8 174 175extern int md_raid1_congested(struct mddev *mddev, int bits); 176 177#endif 178