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