1 #ifndef _RAID1_H 2 #define _RAID1_H 3 4 struct 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 26 struct pool_info { 27 struct mddev *mddev; 28 int raid_disks; 29 }; 30 31 struct 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 /* When raid1 starts resync, we divide array into four partitions 45 * |---------|--------------|---------------------|-------------| 46 * next_resync start_next_window end_window 47 * start_next_window = next_resync + NEXT_NORMALIO_DISTANCE 48 * end_window = start_next_window + NEXT_NORMALIO_DISTANCE 49 * current_window_requests means the count of normalIO between 50 * start_next_window and end_window. 51 * next_window_requests means the count of normalIO after end_window. 52 * */ 53 sector_t start_next_window; 54 int current_window_requests; 55 int next_window_requests; 56 57 spinlock_t device_lock; 58 59 /* list of 'struct r1bio' that need to be processed by raid1d, 60 * whether to retry a read, writeout a resync or recovery 61 * block, or anything else. 62 */ 63 struct list_head retry_list; 64 /* A separate list of r1bio which just need raid_end_bio_io called. 65 * This mustn't happen for writes which had any errors if the superblock 66 * needs to be written. 67 */ 68 struct list_head bio_end_io_list; 69 70 /* queue pending writes to be submitted on unplug */ 71 struct bio_list pending_bio_list; 72 int pending_count; 73 74 /* for use when syncing mirrors: 75 * We don't allow both normal IO and resync/recovery IO at 76 * the same time - resync/recovery can only happen when there 77 * is no other IO. So when either is active, the other has to wait. 78 * See more details description in raid1.c near raise_barrier(). 79 */ 80 wait_queue_head_t wait_barrier; 81 spinlock_t resync_lock; 82 int nr_pending; 83 int nr_waiting; 84 int nr_queued; 85 int barrier; 86 int array_frozen; 87 88 /* Set to 1 if a full sync is needed, (fresh device added). 89 * Cleared when a sync completes. 90 */ 91 int fullsync; 92 93 /* When the same as mddev->recovery_disabled we don't allow 94 * recovery to be attempted as we expect a read error. 95 */ 96 int recovery_disabled; 97 98 /* poolinfo contains information about the content of the 99 * mempools - it changes when the array grows or shrinks 100 */ 101 struct pool_info *poolinfo; 102 mempool_t *r1bio_pool; 103 mempool_t *r1buf_pool; 104 105 /* temporary buffer to synchronous IO when attempting to repair 106 * a read error. 107 */ 108 struct page *tmppage; 109 110 /* When taking over an array from a different personality, we store 111 * the new thread here until we fully activate the array. 112 */ 113 struct md_thread *thread; 114 115 /* Keep track of cluster resync window to send to other 116 * nodes. 117 */ 118 sector_t cluster_sync_low; 119 sector_t cluster_sync_high; 120 121 }; 122 123 /* 124 * this is our 'private' RAID1 bio. 125 * 126 * it contains information about what kind of IO operations were started 127 * for this RAID1 operation, and about their status: 128 */ 129 130 struct r1bio { 131 atomic_t remaining; /* 'have we finished' count, 132 * used from IRQ handlers 133 */ 134 atomic_t behind_remaining; /* number of write-behind ios remaining 135 * in this BehindIO request 136 */ 137 sector_t sector; 138 sector_t start_next_window; 139 int sectors; 140 unsigned long state; 141 struct mddev *mddev; 142 /* 143 * original bio going to /dev/mdx 144 */ 145 struct bio *master_bio; 146 /* 147 * if the IO is in READ direction, then this is where we read 148 */ 149 int read_disk; 150 151 struct list_head retry_list; 152 /* Next two are only valid when R1BIO_BehindIO is set */ 153 struct bio_vec *behind_bvecs; 154 int behind_page_count; 155 /* 156 * if the IO is in WRITE direction, then multiple bios are used. 157 * We choose the number when they are allocated. 158 */ 159 struct bio *bios[0]; 160 /* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/ 161 }; 162 163 /* bits for r1bio.state */ 164 #define R1BIO_Uptodate 0 165 #define R1BIO_IsSync 1 166 #define R1BIO_Degraded 2 167 #define R1BIO_BehindIO 3 168 /* Set ReadError on bios that experience a readerror so that 169 * raid1d knows what to do with them. 170 */ 171 #define R1BIO_ReadError 4 172 /* For write-behind requests, we call bi_end_io when 173 * the last non-write-behind device completes, providing 174 * any write was successful. Otherwise we call when 175 * any write-behind write succeeds, otherwise we call 176 * with failure when last write completes (and all failed). 177 * Record that bi_end_io was called with this flag... 178 */ 179 #define R1BIO_Returned 6 180 /* If a write for this request means we can clear some 181 * known-bad-block records, we set this flag 182 */ 183 #define R1BIO_MadeGood 7 184 #define R1BIO_WriteError 8 185 #endif 186