blob: dd22a37d0d8332e12785b9c270445aba09cce576 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _RAID1_H
2#define _RAID1_H
3
colyli@suse.defd768632017-02-18 03:05:56 +08004/*
5 * each barrier unit size is 64MB fow now
6 * note: it must be larger than RESYNC_DEPTH
7 */
8#define BARRIER_UNIT_SECTOR_BITS 17
9#define BARRIER_UNIT_SECTOR_SIZE (1<<17)
10/*
11 * In struct r1conf, the following members are related to I/O barrier
12 * buckets,
colyli@suse.de824e47d2017-02-18 03:05:57 +080013 * atomic_t *nr_pending;
14 * atomic_t *nr_waiting;
15 * atomic_t *nr_queued;
16 * atomic_t *barrier;
17 * Each of them points to array of atomic_t variables, each array is
18 * designed to have BARRIER_BUCKETS_NR elements and occupy a single
19 * memory page. The data width of atomic_t variables is 4 bytes, equal
20 * to 1<<(ilog2(sizeof(atomic_t))), BARRIER_BUCKETS_NR_BITS is defined
21 * as (PAGE_SHIFT - ilog2(sizeof(int))) to make sure an array of
22 * atomic_t variables with BARRIER_BUCKETS_NR elements just exactly
23 * occupies a single memory page.
colyli@suse.defd768632017-02-18 03:05:56 +080024 */
colyli@suse.de824e47d2017-02-18 03:05:57 +080025#define BARRIER_BUCKETS_NR_BITS (PAGE_SHIFT - ilog2(sizeof(atomic_t)))
colyli@suse.defd768632017-02-18 03:05:56 +080026#define BARRIER_BUCKETS_NR (1<<BARRIER_BUCKETS_NR_BITS)
27
Jonathan Brassow0eaf8222012-07-31 10:03:52 +100028struct raid1_info {
NeilBrown3cb03002011-10-11 16:45:26 +110029 struct md_rdev *rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 sector_t head_position;
Shaohua Libe4d3282012-07-31 10:03:53 +100031
32 /* When choose the best device for a read (read_balance())
33 * we try to keep sequential reads one the same device
34 */
35 sector_t next_seq_sect;
Shaohua Li12cee5a2012-07-31 10:03:53 +100036 sector_t seq_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037};
38
39/*
40 * memory pools need a pointer to the mddev, so they can force an unplug
41 * when memory is tight, and a count of the number of drives that the
42 * pool was allocated for, so they know how much to allocate and free.
43 * mddev->raid_disks cannot be used, as it can change while a pool is active
44 * These two datums are stored in a kmalloced struct.
NeilBrown8f19ccb2011-12-23 10:17:56 +110045 * The 'raid_disks' here is twice the raid_disks in r1conf.
46 * This allows space for each 'real' device can have a replacement in the
47 * second half of the array.
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 */
49
50struct pool_info {
NeilBrownfd01b882011-10-11 16:47:53 +110051 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 int raid_disks;
53};
54
NeilBrowne8096362011-10-11 16:49:05 +110055struct r1conf {
NeilBrownfd01b882011-10-11 16:47:53 +110056 struct mddev *mddev;
Jonathan Brassow0eaf8222012-07-31 10:03:52 +100057 struct raid1_info *mirrors; /* twice 'raid_disks' to
NeilBrown8f19ccb2011-12-23 10:17:56 +110058 * allow for replacements.
59 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 int raid_disks;
NeilBrownce550c22011-10-07 14:22:33 +110061
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 spinlock_t device_lock;
63
NeilBrown9f2c9d12011-10-11 16:48:43 +110064 /* list of 'struct r1bio' that need to be processed by raid1d,
65 * whether to retry a read, writeout a resync or recovery
66 * block, or anything else.
NeilBrownce550c22011-10-07 14:22:33 +110067 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 struct list_head retry_list;
NeilBrown55ce74d2015-08-14 11:11:10 +100069 /* A separate list of r1bio which just need raid_end_bio_io called.
70 * This mustn't happen for writes which had any errors if the superblock
71 * needs to be written.
72 */
73 struct list_head bio_end_io_list;
NeilBrownce550c22011-10-07 14:22:33 +110074
75 /* queue pending writes to be submitted on unplug */
NeilBrown191ea9b2005-06-21 17:17:23 -070076 struct bio_list pending_bio_list;
NeilBrown34db0cd2011-10-11 16:50:01 +110077 int pending_count;
NeilBrown191ea9b2005-06-21 17:17:23 -070078
NeilBrownce550c22011-10-07 14:22:33 +110079 /* for use when syncing mirrors:
80 * We don't allow both normal IO and resync/recovery IO at
81 * the same time - resync/recovery can only happen when there
82 * is no other IO. So when either is active, the other has to wait.
83 * See more details description in raid1.c near raise_barrier().
84 */
85 wait_queue_head_t wait_barrier;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 spinlock_t resync_lock;
colyli@suse.de824e47d2017-02-18 03:05:57 +080087 atomic_t *nr_pending;
88 atomic_t *nr_waiting;
89 atomic_t *nr_queued;
90 atomic_t *barrier;
majianpengb364e3d2013-11-14 15:16:18 +110091 int array_frozen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
NeilBrownce550c22011-10-07 14:22:33 +110093 /* Set to 1 if a full sync is needed, (fresh device added).
94 * Cleared when a sync completes.
95 */
96 int fullsync;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
NeilBrownce550c22011-10-07 14:22:33 +110098 /* When the same as mddev->recovery_disabled we don't allow
99 * recovery to be attempted as we expect a read error.
100 */
101 int recovery_disabled;
102
NeilBrownce550c22011-10-07 14:22:33 +1100103 /* poolinfo contains information about the content of the
104 * mempools - it changes when the array grows or shrinks
105 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 struct pool_info *poolinfo;
NeilBrown9f2c9d12011-10-11 16:48:43 +1100107 mempool_t *r1bio_pool;
108 mempool_t *r1buf_pool;
NeilBrown709ae482009-12-14 12:49:51 +1100109
NeilBrownce550c22011-10-07 14:22:33 +1100110 /* temporary buffer to synchronous IO when attempting to repair
111 * a read error.
112 */
113 struct page *tmppage;
114
NeilBrown709ae482009-12-14 12:49:51 +1100115 /* When taking over an array from a different personality, we store
116 * the new thread here until we fully activate the array.
117 */
NeilBrown2b8bf342011-10-11 16:48:23 +1100118 struct md_thread *thread;
Goldwyn Rodriguesc40f3412015-08-19 08:14:42 +1000119
120 /* Keep track of cluster resync window to send to other
121 * nodes.
122 */
123 sector_t cluster_sync_low;
124 sector_t cluster_sync_high;
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126};
127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 * this is our 'private' RAID1 bio.
130 *
131 * it contains information about what kind of IO operations were started
132 * for this RAID1 operation, and about their status:
133 */
134
NeilBrown9f2c9d12011-10-11 16:48:43 +1100135struct r1bio {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 atomic_t remaining; /* 'have we finished' count,
137 * used from IRQ handlers
138 */
NeilBrown4b6d2872005-09-09 16:23:47 -0700139 atomic_t behind_remaining; /* number of write-behind ios remaining
140 * in this BehindIO request
141 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 sector_t sector;
143 int sectors;
144 unsigned long state;
NeilBrownfd01b882011-10-11 16:47:53 +1100145 struct mddev *mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 /*
147 * original bio going to /dev/mdx
148 */
149 struct bio *master_bio;
150 /*
151 * if the IO is in READ direction, then this is where we read
152 */
153 int read_disk;
154
155 struct list_head retry_list;
NeilBrownaf6d7b72011-05-11 14:51:19 +1000156 /* Next two are only valid when R1BIO_BehindIO is set */
NeilBrown2ca68f52011-07-28 11:32:10 +1000157 struct bio_vec *behind_bvecs;
NeilBrownaf6d7b72011-05-11 14:51:19 +1000158 int behind_page_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 /*
160 * if the IO is in WRITE direction, then multiple bios are used.
161 * We choose the number when they are allocated.
162 */
163 struct bio *bios[0];
NeilBrown191ea9b2005-06-21 17:17:23 -0700164 /* DO NOT PUT ANY NEW FIELDS HERE - bios array is contiguously alloced*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165};
166
167/* bits for r1bio.state */
NeilBrownbe306c22016-11-09 10:21:33 +1100168enum r1bio_state {
169 R1BIO_Uptodate,
170 R1BIO_IsSync,
171 R1BIO_Degraded,
172 R1BIO_BehindIO,
NeilBrownd2eb35a2011-07-28 11:31:48 +1000173/* Set ReadError on bios that experience a readerror so that
174 * raid1d knows what to do with them.
175 */
NeilBrownbe306c22016-11-09 10:21:33 +1100176 R1BIO_ReadError,
NeilBrown4b6d2872005-09-09 16:23:47 -0700177/* For write-behind requests, we call bi_end_io when
178 * the last non-write-behind device completes, providing
179 * any write was successful. Otherwise we call when
180 * any write-behind write succeeds, otherwise we call
181 * with failure when last write completes (and all failed).
182 * Record that bi_end_io was called with this flag...
183 */
NeilBrownbe306c22016-11-09 10:21:33 +1100184 R1BIO_Returned,
NeilBrown4367af52011-07-28 11:31:49 +1000185/* If a write for this request means we can clear some
186 * known-bad-block records, we set this flag
187 */
NeilBrownbe306c22016-11-09 10:21:33 +1100188 R1BIO_MadeGood,
189 R1BIO_WriteError,
NeilBrown2e52d442016-11-18 16:16:12 +1100190 R1BIO_FailFast,
NeilBrownbe306c22016-11-09 10:21:33 +1100191};
colyli@suse.defd768632017-02-18 03:05:56 +0800192
193static inline int sector_to_idx(sector_t sector)
194{
195 return hash_long(sector >> BARRIER_UNIT_SECTOR_BITS,
196 BARRIER_BUCKETS_NR_BITS);
197}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198#endif