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 173