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