Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/apm...
[platform/adaptation/renesas_rcar/renesas_kernel.git] / drivers / md / raid1.h
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