]> git.ipfire.org Git - ipfire-2.x.git/blame - src/patches/suse-2.6.27.39/patches.fixes/0011-md-raid6-remove-expectation-that-Q-device-is-immedia.patch
projects / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix oinkmaster patch.
[ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.fixes / 0011-md-raid6-remove-expectation-that-Q-device-is-immedia.patch
CommitLineData
2cb7cef9
BS		 1From d0dabf7e577411c2bf6b616c751544dc241213d4 Mon Sep 17 00:00:00 2001
2From: NeilBrown <neilb@suse.de>
3Date: Tue, 31 Mar 2009 14:39:38 +1100
4Subject: [PATCH] md/raid6: remove expectation that Q device is immediately after P device.
5
6Code currently assumes that the devices in a raid6 stripe are
7 0 1 ... N-1 P Q
8in some rotated order. We will shortly add new layouts in which
9this strict pattern is broken.
10So remove this expectation. We still assume that the data disks
11are roughly in-order. However P and Q can be inserted anywhere within
12that order.
13
14Signed-off-by: NeilBrown <neilb@suse.de>
15---
16 drivers/md/raid5.c | 213 ++++++++++++++++++++++++++-------------------
17 include/linux/raid/raid5.h | 15 +--
18 2 files changed, 133 insertions(+), 95 deletions(-)
19
20--- linux-2.6.27-SLE11_BRANCH.orig/drivers/md/raid5.c
21+++ linux-2.6.27-SLE11_BRANCH/drivers/md/raid5.c
22@@ -135,12 +135,36 @@ static inline void raid5_set_bi_hw_segme
23 bio->bi_phys_segments = raid5_bi_phys_segments(bio) || (cnt << 16);
24 }
25
26+/* Find first data disk in a raid6 stripe */
27+static inline int raid6_d0(struct stripe_head *sh)
28+{
29+ if (sh->qd_idx == sh->disks - 1)
30+ return 0;
31+ else
32+ return sh->qd_idx + 1;
33+}
34 static inline int raid6_next_disk(int disk, int raid_disks)
35 {
36 disk++;
37 return (disk < raid_disks) ? disk : 0;
38 }
39
40+/* When walking through the disks in a raid5, starting at raid6_d0,
41+ * We need to map each disk to a 'slot', where the data disks are slot
42+ * 0 .. raid_disks-3, the parity disk is raid_disks-2 and the Q disk
43+ * is raid_disks-1. This help does that mapping.
44+ */
45+static int raid6_idx_to_slot(int idx, struct stripe_head *sh, int *count)
46+{
47+ int slot;
48+ if (idx == sh->pd_idx)
49+ return sh->disks - 2;
50+ if (idx == sh->qd_idx)
51+ return sh->disks - 1;
52+ slot = (*count)++;
53+ return slot;
54+}
55+
56 static void return_io(struct bio *return_bi)
57 {
58 struct bio *bi = return_bi;
59@@ -198,6 +222,7 @@ static void __release_stripe(raid5_conf_
60 }
61 }
62 }
63+
64 static void release_stripe(struct stripe_head *sh)
65 {
66 raid5_conf_t *conf = sh->raid_conf;
67@@ -276,12 +301,14 @@ static int grow_buffers(struct stripe_he
68 }
69
70 static void raid5_build_block (struct stripe_head *sh, int i);
71-static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int previous);
72+static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int previous,
73+ int *qd_idx);
74
75 static void init_stripe(struct stripe_head *sh, sector_t sector, int previous)
76 {
77 raid5_conf_t *conf = sh->raid_conf;
78 int i;
79+ int qd_idx;
80
81 BUG_ON(atomic_read(&sh->count) != 0);
82 BUG_ON(test_bit(STRIPE_HANDLE, &sh->state));
83@@ -295,7 +322,8 @@ static void init_stripe(struct stripe_he
84
85 sh->disks = previous ? conf->previous_raid_disks : conf->raid_disks;
86 sh->sector = sector;
87- sh->pd_idx = stripe_to_pdidx(sector, conf, previous);
88+ sh->pd_idx = stripe_to_pdidx(sector, conf, previous, &qd_idx);
89+ sh->qd_idx = qd_idx;
90 sh->state = 0;
91
92
93@@ -1237,7 +1265,7 @@ static void error(mddev_t *mddev, mdk_rd
94 */
95 static sector_t raid5_compute_sector(raid5_conf_t *conf, sector_t r_sector,
96 int previous,
97- int *dd_idx, int *pd_idx)
98+ int *dd_idx, int *pd_idx, int *qd_idx)
99 {
100 long stripe;
101 unsigned long chunk_number;
102@@ -1270,6 +1298,7 @@ static sector_t raid5_compute_sector(rai
103 /*
104 * Select the parity disk based on the user selected algorithm.
105 */
106+ *qd_idx = ~0;
107 switch(conf->level) {
108 case 4:
109 *pd_idx = data_disks;
110@@ -1305,24 +1334,30 @@ static sector_t raid5_compute_sector(rai
111 switch (conf->algorithm) {
112 case ALGORITHM_LEFT_ASYMMETRIC:
113 *pd_idx = raid_disks - 1 - (stripe % raid_disks);
114- if (*pd_idx == raid_disks-1)
115+ *qd_idx = *pd_idx + 1;
116+ if (*pd_idx == raid_disks-1) {
117 (*dd_idx)++; /* Q D D D P */
118- else if (*dd_idx >= *pd_idx)
119+ *qd_idx = 0;
120+ } else if (*dd_idx >= *pd_idx)
121 (*dd_idx) += 2; /* D D P Q D */
122 break;
123 case ALGORITHM_RIGHT_ASYMMETRIC:
124 *pd_idx = stripe % raid_disks;
125- if (*pd_idx == raid_disks-1)
126+ *qd_idx = *pd_idx + 1;
127+ if (*pd_idx == raid_disks-1) {
128 (*dd_idx)++; /* Q D D D P */
129- else if (*dd_idx >= *pd_idx)
130+ *qd_idx = 0;
131+ } else if (*dd_idx >= *pd_idx)
132 (*dd_idx) += 2; /* D D P Q D */
133 break;
134 case ALGORITHM_LEFT_SYMMETRIC:
135 *pd_idx = raid_disks - 1 - (stripe % raid_disks);
136+ *qd_idx = (*pd_idx + 1) % raid_disks;
137 *dd_idx = (*pd_idx + 2 + *dd_idx) % raid_disks;
138 break;
139 case ALGORITHM_RIGHT_SYMMETRIC:
140 *pd_idx = stripe % raid_disks;
141+ *qd_idx = (*pd_idx + 1) % raid_disks;
142 *dd_idx = (*pd_idx + 2 + *dd_idx) % raid_disks;
143 break;
144 default:
145@@ -1349,7 +1384,7 @@ static sector_t compute_blocknr(struct s
146 int sectors_per_chunk = conf->chunk_size >> 9;
147 sector_t stripe;
148 int chunk_offset;
149- int chunk_number, dummy1, dummy2, dd_idx = i;
150+ int chunk_number, dummy1, dummy2, dummy3, dd_idx = i;
151 sector_t r_sector;
152
153
154@@ -1380,7 +1415,7 @@ static sector_t compute_blocknr(struct s
155 }
156 break;
157 case 6:
158- if (i == raid6_next_disk(sh->pd_idx, raid_disks))
159+ if (i == sh->qd_idx)
160 return 0; /* It is the Q disk */
161 switch (conf->algorithm) {
162 case ALGORITHM_LEFT_ASYMMETRIC:
163@@ -1413,7 +1448,7 @@ static sector_t compute_blocknr(struct s
164
165 check = raid5_compute_sector (conf, r_sector,
166 (raid_disks != conf->raid_disks),
167- &dummy1, &dummy2);
168+ &dummy1, &dummy2, &dummy3);
169 if (check != sh->sector || dummy1 != dd_idx || dummy2 != sh->pd_idx) {
170 printk(KERN_ERR "compute_blocknr: map not correct\n");
171 return 0;
172@@ -1482,13 +1517,14 @@ static void copy_data(int frombio, struc
173 static void compute_parity6(struct stripe_head *sh, int method)
174 {
175 raid6_conf_t *conf = sh->raid_conf;
176- int i, pd_idx = sh->pd_idx, qd_idx, d0_idx, disks = sh->disks, count;
177+ int i, pd_idx, qd_idx, d0_idx, disks = sh->disks, count;
178 struct bio *chosen;
179 /**** FIX THIS: This could be very bad if disks is close to 256 ****/
180 void *ptrs[disks];
181
182- qd_idx = raid6_next_disk(pd_idx, disks);
183- d0_idx = raid6_next_disk(qd_idx, disks);
184+ pd_idx = sh->pd_idx;
185+ qd_idx = sh->qd_idx;
186+ d0_idx = raid6_d0(sh);
187
188 pr_debug("compute_parity, stripe %llu, method %d\n",
189 (unsigned long long)sh->sector, method);
190@@ -1526,22 +1562,22 @@ static void compute_parity6(struct strip
191 set_bit(R5_UPTODATE, &sh->dev[i].flags);
192 }
193
194-// switch(method) {
195-// case RECONSTRUCT_WRITE:
196-// case CHECK_PARITY:
197-// case UPDATE_PARITY:
198- /* Note that unlike RAID-5, the ordering of the disks matters greatly. */
199- /* FIX: Is this ordering of drives even remotely optimal? */
200- count = 0;
201- i = d0_idx;
202- do {
203- ptrs[count++] = page_address(sh->dev[i].page);
204- if (count <= disks-2 && !test_bit(R5_UPTODATE, &sh->dev[i].flags))
205- printk("block %d/%d not uptodate on parity calc\n", i,count);
206- i = raid6_next_disk(i, disks);
207- } while ( i != d0_idx );
208-// break;
209-// }
210+ /* Note that unlike RAID-5, the ordering of the disks matters greatly.*/
211+ /* FIX: Is this ordering of drives even remotely optimal? */
212+ count = 0;
213+ i = d0_idx;
214+ do {
215+ int slot = raid6_idx_to_slot(i, sh, &count);
216+ ptrs[slot] = page_address(sh->dev[i].page);
217+ if (slot < sh->disks - 2 &&
218+ !test_bit(R5_UPTODATE, &sh->dev[i].flags)) {
219+ printk(KERN_ERR "block %d/%d not uptodate "
220+ "on parity calc\n", i, count);
221+ BUG();
222+ }
223+ i = raid6_next_disk(i, disks);
224+ } while (i != d0_idx);
225+ BUG_ON(count+2 != disks);
226
227 raid6_call.gen_syndrome(disks, STRIPE_SIZE, ptrs);
228
229@@ -1565,8 +1601,7 @@ static void compute_block_1(struct strip
230 {
231 int i, count, disks = sh->disks;
232 void *ptr[MAX_XOR_BLOCKS], *dest, *p;
233- int pd_idx = sh->pd_idx;
234- int qd_idx = raid6_next_disk(pd_idx, disks);
235+ int qd_idx = sh->qd_idx;
236
237 pr_debug("compute_block_1, stripe %llu, idx %d\n",
238 (unsigned long long)sh->sector, dd_idx);
239@@ -1602,21 +1637,31 @@ static void compute_block_1(struct strip
240 static void compute_block_2(struct stripe_head *sh, int dd_idx1, int dd_idx2)
241 {
242 int i, count, disks = sh->disks;
243- int pd_idx = sh->pd_idx;
244- int qd_idx = raid6_next_disk(pd_idx, disks);
245- int d0_idx = raid6_next_disk(qd_idx, disks);
246- int faila, failb;
247-
248- /* faila and failb are disk numbers relative to d0_idx */
249- /* pd_idx become disks-2 and qd_idx become disks-1 */
250- faila = (dd_idx1 < d0_idx) ? dd_idx1+(disks-d0_idx) : dd_idx1-d0_idx;
251- failb = (dd_idx2 < d0_idx) ? dd_idx2+(disks-d0_idx) : dd_idx2-d0_idx;
252+ int d0_idx = raid6_d0(sh);
253+ int faila = -1, failb = -1;
254+ /**** FIX THIS: This could be very bad if disks is close to 256 ****/
255+ void *ptrs[disks];
256+
257+ count = 0;
258+ i = d0_idx;
259+ do {
260+ int slot;
261+ slot = raid6_idx_to_slot(i, sh, &count);
262+ ptrs[slot] = page_address(sh->dev[i].page);
263+ if (i == dd_idx1)
264+ faila = slot;
265+ if (i == dd_idx2)
266+ failb = slot;
267+ i = raid6_next_disk(i, disks);
268+ } while (i != d0_idx);
269+ BUG_ON(count+2 != disks);
270
271 BUG_ON(faila == failb);
272 if ( failb < faila ) { int tmp = faila; faila = failb; failb = tmp; }
273
274 pr_debug("compute_block_2, stripe %llu, idx %d,%d (%d,%d)\n",
275- (unsigned long long)sh->sector, dd_idx1, dd_idx2, faila, failb);
276+ (unsigned long long)sh->sector, dd_idx1, dd_idx2,
277+ faila, failb);
278
279 if ( failb == disks-1 ) {
280 /* Q disk is one of the missing disks */
281@@ -1626,39 +1671,26 @@ static void compute_block_2(struct strip
282 return;
283 } else {
284 /* We're missing D+Q; recompute D from P */
285- compute_block_1(sh, (dd_idx1 == qd_idx) ? dd_idx2 : dd_idx1, 0);
286+ compute_block_1(sh, ((dd_idx1 == sh->qd_idx) ?
287+ dd_idx2 : dd_idx1),
288+ 0);
289 compute_parity6(sh, UPDATE_PARITY); /* Is this necessary? */
290 return;
291 }
292 }
293
294- /* We're missing D+P or D+D; build pointer table */
295- {
296- /**** FIX THIS: This could be very bad if disks is close to 256 ****/
297- void *ptrs[disks];
298-
299- count = 0;
300- i = d0_idx;
301- do {
302- ptrs[count++] = page_address(sh->dev[i].page);
303- i = raid6_next_disk(i, disks);
304- if (i != dd_idx1 && i != dd_idx2 &&
305- !test_bit(R5_UPTODATE, &sh->dev[i].flags))
306- printk("compute_2 with missing block %d/%d\n", count, i);
307- } while ( i != d0_idx );
308-
309- if ( failb == disks-2 ) {
310- /* We're missing D+P. */
311- raid6_datap_recov(disks, STRIPE_SIZE, faila, ptrs);
312- } else {
313- /* We're missing D+D. */
314- raid6_2data_recov(disks, STRIPE_SIZE, faila, failb, ptrs);
315- }
316-
317- /* Both the above update both missing blocks */
318- set_bit(R5_UPTODATE, &sh->dev[dd_idx1].flags);
319- set_bit(R5_UPTODATE, &sh->dev[dd_idx2].flags);
320+ /* We're missing D+P or D+D; */
321+ if (failb == disks-2) {
322+ /* We're missing D+P. */
323+ raid6_datap_recov(disks, STRIPE_SIZE, faila, ptrs);
324+ } else {
325+ /* We're missing D+D. */
326+ raid6_2data_recov(disks, STRIPE_SIZE, faila, failb, ptrs);
327 }
328+
329+ /* Both the above update both missing blocks */
330+ set_bit(R5_UPTODATE, &sh->dev[dd_idx1].flags);
331+ set_bit(R5_UPTODATE, &sh->dev[dd_idx2].flags);
332 }
333
334 static void
335@@ -1813,7 +1845,8 @@ static int page_is_zero(struct page *p)
336 memcmp(a, a+4, STRIPE_SIZE-4)==0);
337 }
338
339-static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int previous)
340+static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int previous,
341+ int *qd_idxp)
342 {
343 int sectors_per_chunk = conf->chunk_size >> 9;
344 int pd_idx, dd_idx;
345@@ -1824,7 +1857,7 @@ static int stripe_to_pdidx(sector_t stri
346 stripe * (disks - conf->max_degraded)
347 *sectors_per_chunk + chunk_offset,
348 previous,
349- &dd_idx, &pd_idx);
350+ &dd_idx, &pd_idx, qd_idxp);
351 return pd_idx;
352 }
353
354@@ -2483,12 +2516,13 @@ static void handle_stripe_expansion(raid
355 clear_bit(STRIPE_EXPAND_SOURCE, &sh->state);
356 for (i = 0; i < sh->disks; i++)
357 if (i != sh->pd_idx && (!r6s || i != r6s->qd_idx)) {
358- int dd_idx, pd_idx, j;
359+ int dd_idx, pd_idx, qd_idx, j;
360 struct stripe_head *sh2;
361
362 sector_t bn = compute_blocknr(sh, i);
363- sector_t s = raid5_compute_sector(conf, bn, 0,
364- &dd_idx, &pd_idx);
365+ sector_t s =
366+ raid5_compute_sector(conf, bn, 0,
367+ &dd_idx, &pd_idx, &qd_idx);
368 sh2 = get_active_stripe(conf, s, 0, 1);
369 if (sh2 == NULL)
370 /* so far only the early blocks of this stripe
371@@ -2512,8 +2546,7 @@ static void handle_stripe_expansion(raid
372 set_bit(R5_UPTODATE, &sh2->dev[dd_idx].flags);
373 for (j = 0; j < conf->raid_disks; j++)
374 if (j != sh2->pd_idx &&
375- (!r6s || j != raid6_next_disk(sh2->pd_idx,
376- sh2->disks)) &&
377+ (!r6s || j != sh2->qd_idx) &&
378 !test_bit(R5_Expanded, &sh2->dev[j].flags))
379 break;
380 if (j == conf->raid_disks) {
381@@ -2773,9 +2806,11 @@ static bool handle_stripe5(struct stripe
382
383 if (s.expanded && test_bit(STRIPE_EXPANDING, &sh->state) &&
384 !sh->reconstruct_state) {
385+ int qd_idx;
386 /* Need to write out all blocks after computing parity */
387 sh->disks = conf->raid_disks;
388- sh->pd_idx = stripe_to_pdidx(sh->sector, conf, 0);
389+ sh->pd_idx = stripe_to_pdidx(sh->sector, conf, 0, &qd_idx);
390+ sh->qd_idx = qd_idx;
391 schedule_reconstruction5(sh, &s, 1, 1);
392 } else if (s.expanded && !sh->reconstruct_state && s.locked == 0) {
393 clear_bit(STRIPE_EXPAND_READY, &sh->state);
394@@ -2816,7 +2851,7 @@ static bool handle_stripe6(struct stripe
395 struct r5dev *dev, *pdev, *qdev;
396 mdk_rdev_t *blocked_rdev = NULL;
397
398- r6s.qd_idx = raid6_next_disk(pd_idx, disks);
399+ r6s.qd_idx = sh->qd_idx;
400 pr_debug("handling stripe %llu, state=%#lx cnt=%d, "
401 "pd_idx=%d, qd_idx=%d\n",
402 (unsigned long long)sh->sector, sh->state,
403@@ -2992,8 +3027,10 @@ static bool handle_stripe6(struct stripe
404
405 if (s.expanded && test_bit(STRIPE_EXPANDING, &sh->state)) {
406 /* Need to write out all blocks after computing P&Q */
407+ int qd_idx;
408 sh->disks = conf->raid_disks;
409- sh->pd_idx = stripe_to_pdidx(sh->sector, conf, 0);
410+ sh->pd_idx = stripe_to_pdidx(sh->sector, conf, 0, &qd_idx);
411+ sh->qd_idx = qd_idx;
412 compute_parity6(sh, RECONSTRUCT_WRITE);
413 for (i = conf->raid_disks ; i-- ; ) {
414 set_bit(R5_LOCKED, &sh->dev[i].flags);
415@@ -3265,7 +3302,7 @@ static int chunk_aligned_read(struct req
416 {
417 mddev_t *mddev = q->queuedata;
418 raid5_conf_t *conf = mddev_to_conf(mddev);
419- unsigned int dd_idx, pd_idx;
420+ unsigned int dd_idx, pd_idx, qd_idx;
421 struct bio* align_bi;
422 mdk_rdev_t *rdev;
423
424@@ -3290,7 +3327,7 @@ static int chunk_aligned_read(struct req
425 */
426 align_bi->bi_sector = raid5_compute_sector(conf, raid_bio->bi_sector,
427 0,
428- &dd_idx, &pd_idx);
429+ &dd_idx, &pd_idx, &qd_idx);
430
431 rcu_read_lock();
432 rdev = rcu_dereference(conf->disks[dd_idx].rdev);
433@@ -3382,7 +3419,7 @@ static int make_request(struct request_q
434 {
435 mddev_t *mddev = q->queuedata;
436 raid5_conf_t *conf = mddev_to_conf(mddev);
437- unsigned int dd_idx, pd_idx;
438+ int dd_idx, pd_idx, qd_idx;
439 sector_t new_sector;
440 sector_t logical_sector, last_sector;
441 struct stripe_head *sh;
442@@ -3446,7 +3483,7 @@ static int make_request(struct request_q
443
444 new_sector = raid5_compute_sector(conf, logical_sector,
445 previous,
446- &dd_idx, &pd_idx);
447+ &dd_idx, &pd_idx, &qd_idx);
448 pr_debug("raid5: make_request, sector %llu logical %llu\n",
449 (unsigned long long)new_sector,
450 (unsigned long long)logical_sector);
451@@ -3535,7 +3572,7 @@ static sector_t reshape_request(mddev_t
452 */
453 raid5_conf_t *conf = (raid5_conf_t *) mddev->private;
454 struct stripe_head *sh;
455- int pd_idx;
456+ int pd_idx, qd_idx;
457 sector_t first_sector, last_sector;
458 int raid_disks = conf->previous_raid_disks;
459 int data_disks = raid_disks - conf->max_degraded;
460@@ -3598,7 +3635,7 @@ static sector_t reshape_request(mddev_t
461 if (j == sh->pd_idx)
462 continue;
463 if (conf->level == 6 &&
464- j == raid6_next_disk(sh->pd_idx, sh->disks))
465+ j == sh->qd_idx)
466 continue;
467 s = compute_blocknr(sh, j);
468 if (s < mddev->array_sectors) {
469@@ -3625,11 +3662,11 @@ static sector_t reshape_request(mddev_t
470 */
471 first_sector =
472 raid5_compute_sector(conf, sector_nr*(new_data_disks),
473- 1, &dd_idx, &pd_idx);
474+ 1, &dd_idx, &pd_idx, &qd_idx);
475 last_sector =
476 raid5_compute_sector(conf, ((sector_nr+conf->chunk_size/512)
477 *(new_data_disks) - 1),
478- 1, &dd_idx, &pd_idx);
479+ 1, &dd_idx, &pd_idx, &qd_idx);
480 if (last_sector >= (mddev->size<<1))
481 last_sector = (mddev->size<<1)-1;
482 while (first_sector <= last_sector) {
483@@ -3764,7 +3801,7 @@ static int retry_aligned_read(raid5_con
484 * it will be only one 'dd_idx' and only need one call to raid5_compute_sector.
485 */
486 struct stripe_head *sh;
487- int dd_idx, pd_idx;
488+ int dd_idx, pd_idx, qd_idx;
489 sector_t sector, logical_sector, last_sector;
490 int scnt = 0;
491 int remaining;
492@@ -3772,7 +3809,7 @@ static int retry_aligned_read(raid5_con
493
494 logical_sector = raid_bio->bi_sector & ~((sector_t)STRIPE_SECTORS-1);
495 sector = raid5_compute_sector(conf, logical_sector,
496- 0, &dd_idx, &pd_idx);
497+ 0, &dd_idx, &pd_idx, &qd_idx);
498 last_sector = raid_bio->bi_sector + (raid_bio->bi_size>>9);
499
500 for (; logical_sector < last_sector;
501--- linux-2.6.27-SLE11_BRANCH.orig/include/linux/raid/raid5.h
502+++ linux-2.6.27-SLE11_BRANCH/include/linux/raid/raid5.h
503@@ -197,15 +197,16 @@ enum reconstruct_states {
504
505 struct stripe_head {
506 struct hlist_node hash;
507- struct list_head lru; /* inactive_list or handle_list */
508- struct raid5_private_data *raid_conf;
509- sector_t sector; /* sector of this row */
510- int pd_idx; /* parity disk index */
511- unsigned long state; /* state flags */
512- atomic_t count; /* nr of active thread/requests */
513+ struct list_head lru; /* inactive_list or handle_list */
514+ struct raid5_private_data *raid_conf;
515+ sector_t sector; /* sector of this row */
516+ short pd_idx; /* parity disk index */
517+ short qd_idx; /* 'Q' disk index for raid6 */
518+ unsigned long state; /* state flags */
519+ atomic_t count; /* nr of active thread/requests */
520 spinlock_t lock;
521 int bm_seq; /* sequence number for bitmap flushes */
522- int disks; /* disks in stripe */
523+ int disks; /* disks in stripe */
524 enum check_states check_state;
525 enum reconstruct_states reconstruct_state;
526 /* stripe_operations
IPFire 2.x development tree