[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.25 / patches.fixes / 0014-md-raid5-finish-support-for-DDF-raid6.patch

From 67cc2b8165857ba019920d1f00d64bcc4140075d Mon Sep 17 00:00:00 2001
From: NeilBrown <neilb@suse.de>
Date: Tue, 31 Mar 2009 14:39:38 +1100
Subject: [PATCH] md/raid5: finish support for DDF/raid6

DDF requires RAID6 calculations over different devices in a different
order.
For md/raid6, we calculate over just the data devices, starting
immediately after the 'Q' block.
For ddf/raid6 we calculate over all devices, using zeros in place of
the P and Q blocks.

This requires unfortunately complex loops...

Signed-off-by: NeilBrown <neilb@suse.de>
---
 drivers/md/raid5.c         |   58 +++++++++++++++++++++++++++++++--------------
 include/linux/raid/raid5.h |    1 
 2 files changed, 41 insertions(+), 18 deletions(-)

--- linux-2.6.27-SLE11_BRANCH.orig/drivers/md/raid5.c
+++ linux-2.6.27-SLE11_BRANCH/drivers/md/raid5.c
@@ -138,6 +138,10 @@ static inline void raid5_set_bi_hw_segme
 /* Find first data disk in a raid6 stripe */
 static inline int raid6_d0(struct stripe_head *sh)
 {
+	if (sh->ddf_layout)
+		/* ddf always start from first device */
+		return 0;
+	/* md starts just after Q block */
 	if (sh->qd_idx == sh->disks - 1)
 		return 0;
 	else
@@ -154,13 +158,15 @@ static inline int raid6_next_disk(int di
  * 0 .. raid_disks-3, the parity disk is raid_disks-2 and the Q disk
  * is raid_disks-1.  This help does that mapping.
  */
-static int raid6_idx_to_slot(int idx, struct stripe_head *sh, int *count)
+static int raid6_idx_to_slot(int idx, struct stripe_head *sh,
+			     int *count, int syndrome_disks)
 {
 	int slot;
+
 	if (idx == sh->pd_idx)
-		return sh->disks - 2;
+		return syndrome_disks;
 	if (idx == sh->qd_idx)
-		return sh->disks - 1;
+		return syndrome_disks + 1;
 	slot = (*count)++;
 	return slot;
 }
@@ -1269,6 +1275,7 @@ static sector_t raid5_compute_sector(rai
 	unsigned long chunk_number;
 	unsigned int chunk_offset;
 	int pd_idx, qd_idx;
+	int ddf_layout = 0;
 	sector_t new_sector;
 	int sectors_per_chunk = conf->chunk_size >> 9;
 	int raid_disks = previous ? conf->previous_raid_disks
@@ -1388,6 +1395,7 @@ static sector_t raid5_compute_sector(rai
 				qd_idx = 0;
 			} else if (*dd_idx >= pd_idx)
 				(*dd_idx) += 2; /* D D P Q D */
+			ddf_layout = 1;
 			break;
 
 		case ALGORITHM_ROTATING_N_RESTART:
@@ -1402,6 +1410,7 @@ static sector_t raid5_compute_sector(rai
 				qd_idx = 0;
 			} else if (*dd_idx >= pd_idx)
 				(*dd_idx) += 2; /* D D P Q D */
+			ddf_layout = 1;
 			break;
 
 		case ALGORITHM_ROTATING_N_CONTINUE:
@@ -1409,6 +1418,7 @@ static sector_t raid5_compute_sector(rai
 			pd_idx = raid_disks - 1 - (stripe % raid_disks);
 			qd_idx = (pd_idx + raid_disks - 1) % raid_disks;
 			*dd_idx = (pd_idx + 1 + *dd_idx) % raid_disks;
+			ddf_layout = 1;
 			break;
 
 		case ALGORITHM_LEFT_ASYMMETRIC_6:
@@ -1456,6 +1466,7 @@ static sector_t raid5_compute_sector(rai
 	if (sh) {
 		sh->pd_idx = pd_idx;
 		sh->qd_idx = qd_idx;
+		sh->ddf_layout = ddf_layout;
 	}
 	/*
 	 * Finally, compute the new sector number
@@ -1644,9 +1655,10 @@ static void compute_parity6(struct strip
 {
 	raid6_conf_t *conf = sh->raid_conf;
 	int i, pd_idx, qd_idx, d0_idx, disks = sh->disks, count;
+	int syndrome_disks = sh->ddf_layout ? disks : (disks - 2);
 	struct bio *chosen;
 	/**** FIX THIS: This could be very bad if disks is close to 256 ****/
-	void *ptrs[disks];
+	void *ptrs[syndrome_disks+2];
 
 	pd_idx = sh->pd_idx;
 	qd_idx = sh->qd_idx;
@@ -1689,23 +1701,28 @@ static void compute_parity6(struct strip
 		}
 
 	/* Note that unlike RAID-5, the ordering of the disks matters greatly.*/
-	/* FIX: Is this ordering of drives even remotely optimal? */
+
+	for (i = 0; i < disks; i++)
+		ptrs[i] = (void *)raid6_empty_zero_page;
+
 	count = 0;
 	i = d0_idx;
 	do {
-		int slot = raid6_idx_to_slot(i, sh, &count);
+		int slot = raid6_idx_to_slot(i, sh, &count, syndrome_disks);
+
 		ptrs[slot] = page_address(sh->dev[i].page);
-		if (slot < sh->disks - 2 &&
+		if (slot < syndrome_disks &&
 		    !test_bit(R5_UPTODATE, &sh->dev[i].flags)) {
 			printk(KERN_ERR "block %d/%d not uptodate "
 			       "on parity calc\n", i, count);
 			BUG();
 		}
+
 		i = raid6_next_disk(i, disks);
 	} while (i != d0_idx);
-	BUG_ON(count+2 != disks);
+	BUG_ON(count != syndrome_disks);
 
-	raid6_call.gen_syndrome(disks, STRIPE_SIZE, ptrs);
+	raid6_call.gen_syndrome(syndrome_disks+2, STRIPE_SIZE, ptrs);
 
 	switch(method) {
 	case RECONSTRUCT_WRITE:
@@ -1763,24 +1780,28 @@ static void compute_block_1(struct strip
 static void compute_block_2(struct stripe_head *sh, int dd_idx1, int dd_idx2)
 {
 	int i, count, disks = sh->disks;
+	int syndrome_disks = sh->ddf_layout ? disks : disks-2;
 	int d0_idx = raid6_d0(sh);
 	int faila = -1, failb = -1;
 	/**** FIX THIS: This could be very bad if disks is close to 256 ****/
-	void *ptrs[disks];
+	void *ptrs[syndrome_disks+2];
 
+	for (i = 0; i < disks ; i++)
+		ptrs[i] = (void *)raid6_empty_zero_page;
 	count = 0;
 	i = d0_idx;
 	do {
-		int slot;
-		slot = raid6_idx_to_slot(i, sh, &count);
+		int slot = raid6_idx_to_slot(i, sh, &count, syndrome_disks);
+
 		ptrs[slot] = page_address(sh->dev[i].page);
+
 		if (i == dd_idx1)
 			faila = slot;
 		if (i == dd_idx2)
 			failb = slot;
 		i = raid6_next_disk(i, disks);
 	} while (i != d0_idx);
-	BUG_ON(count+2 != disks);
+	BUG_ON(count != syndrome_disks);
 
 	BUG_ON(faila == failb);
 	if ( failb < faila ) { int tmp = faila; faila = failb; failb = tmp; }
@@ -1789,9 +1810,9 @@ static void compute_block_2(struct strip
 		 (unsigned long long)sh->sector, dd_idx1, dd_idx2,
 		 faila, failb);
 
-	if ( failb == disks-1 ) {
+	if (failb == syndrome_disks+1) {
 		/* Q disk is one of the missing disks */
-		if ( faila == disks-2 ) {
+		if (faila == syndrome_disks) {
 			/* Missing P+Q, just recompute */
 			compute_parity6(sh, UPDATE_PARITY);
 			return;
@@ -1806,12 +1827,13 @@ static void compute_block_2(struct strip
 	}
 
 	/* We're missing D+P or D+D; */
-	if (failb == disks-2) {
+	if (failb == syndrome_disks) {
 		/* We're missing D+P. */
-		raid6_datap_recov(disks, STRIPE_SIZE, faila, ptrs);
+		raid6_datap_recov(syndrome_disks+2, STRIPE_SIZE, faila, ptrs);
 	} else {
 		/* We're missing D+D. */
-		raid6_2data_recov(disks, STRIPE_SIZE, faila, failb, ptrs);
+		raid6_2data_recov(syndrome_disks+2, STRIPE_SIZE, faila, failb,
+				  ptrs);
 	}
 
 	/* Both the above update both missing blocks */
--- linux-2.6.27-SLE11_BRANCH.orig/include/linux/raid/raid5.h
+++ linux-2.6.27-SLE11_BRANCH/include/linux/raid/raid5.h
@@ -202,6 +202,7 @@ struct stripe_head {
 	sector_t		sector;		/* sector of this row */
 	short			pd_idx;		/* parity disk index */
 	short			qd_idx;		/* 'Q' disk index for raid6 */
+	short			ddf_layout;/* use DDF ordering to calculate Q */
 	unsigned long		state;		/* state flags */
 	atomic_t		count;	      /* nr of active thread/requests */
 	spinlock_t		lock;
Commit	Line	Data
00e5a55c BS	1	From 67cc2b8165857ba019920d1f00d64bcc4140075d Mon Sep 17 00:00:00 2001
	2	From: NeilBrown <neilb@suse.de>
	3	Date: Tue, 31 Mar 2009 14:39:38 +1100
	4	Subject: [PATCH] md/raid5: finish support for DDF/raid6
	5
	6	DDF requires RAID6 calculations over different devices in a different
	7	order.
	8	For md/raid6, we calculate over just the data devices, starting
	9	immediately after the 'Q' block.
	10	For ddf/raid6 we calculate over all devices, using zeros in place of
	11	the P and Q blocks.
	12
	13	This requires unfortunately complex loops...
	14
	15	Signed-off-by: NeilBrown <neilb@suse.de>
	16	---
	17	drivers/md/raid5.c \| 58 +++++++++++++++++++++++++++++++--------------
	18	include/linux/raid/raid5.h \| 1
	19	2 files changed, 41 insertions(+), 18 deletions(-)
	20
	21	--- linux-2.6.27-SLE11_BRANCH.orig/drivers/md/raid5.c
	22	+++ linux-2.6.27-SLE11_BRANCH/drivers/md/raid5.c
	23	@@ -138,6 +138,10 @@ static inline void raid5_set_bi_hw_segme
	24	/* Find first data disk in a raid6 stripe */
	25	static inline int raid6_d0(struct stripe_head *sh)
	26	{
	27	+ if (sh->ddf_layout)
	28	+ /* ddf always start from first device */
	29	+ return 0;
	30	+ /* md starts just after Q block */
	31	if (sh->qd_idx == sh->disks - 1)
	32	return 0;
	33	else
	34	@@ -154,13 +158,15 @@ static inline int raid6_next_disk(int di
	35	* 0 .. raid_disks-3, the parity disk is raid_disks-2 and the Q disk
	36	* is raid_disks-1. This help does that mapping.
	37	*/
	38	-static int raid6_idx_to_slot(int idx, struct stripe_head sh, int count)
	39	+static int raid6_idx_to_slot(int idx, struct stripe_head *sh,
	40	+ int *count, int syndrome_disks)
	41	{
	42	int slot;
	43	+
	44	if (idx == sh->pd_idx)
	45	- return sh->disks - 2;
	46	+ return syndrome_disks;
	47	if (idx == sh->qd_idx)
	48	- return sh->disks - 1;
	49	+ return syndrome_disks + 1;
	50	slot = (*count)++;
	51	return slot;
	52	}
	53	@@ -1269,6 +1275,7 @@ static sector_t raid5_compute_sector(rai
	54	unsigned long chunk_number;
	55	unsigned int chunk_offset;
	56	int pd_idx, qd_idx;
	57	+ int ddf_layout = 0;
	58	sector_t new_sector;
	59	int sectors_per_chunk = conf->chunk_size >> 9;
	60	int raid_disks = previous ? conf->previous_raid_disks
	61	@@ -1388,6 +1395,7 @@ static sector_t raid5_compute_sector(rai
	62	qd_idx = 0;
	63	} else if (*dd_idx >= pd_idx)
	64	(dd_idx) += 2; / D D P Q D */
65	+ ddf_layout = 1;
66	break;
67
68	case ALGORITHM_ROTATING_N_RESTART:
69	@@ -1402,6 +1410,7 @@ static sector_t raid5_compute_sector(rai
70	qd_idx = 0;
71	} else if (*dd_idx >= pd_idx)
72	(dd_idx) += 2; / D D P Q D */
73	+ ddf_layout = 1;
74	break;
75
76	case ALGORITHM_ROTATING_N_CONTINUE:
77	@@ -1409,6 +1418,7 @@ static sector_t raid5_compute_sector(rai
78	pd_idx = raid_disks - 1 - (stripe % raid_disks);
79	qd_idx = (pd_idx + raid_disks - 1) % raid_disks;
80	dd_idx = (pd_idx + 1 + dd_idx) % raid_disks;
81	+ ddf_layout = 1;
82	break;
83
84	case ALGORITHM_LEFT_ASYMMETRIC_6:
85	@@ -1456,6 +1466,7 @@ static sector_t raid5_compute_sector(rai
86	if (sh) {
87	sh->pd_idx = pd_idx;
88	sh->qd_idx = qd_idx;
89	+ sh->ddf_layout = ddf_layout;
90	}
91	/*
92	* Finally, compute the new sector number
93	@@ -1644,9 +1655,10 @@ static void compute_parity6(struct strip
94	{
95	raid6_conf_t *conf = sh->raid_conf;
96	int i, pd_idx, qd_idx, d0_idx, disks = sh->disks, count;
97	+ int syndrome_disks = sh->ddf_layout ? disks : (disks - 2);
98	struct bio *chosen;
99	/** FIX THIS: This could be very bad if disks is close to 256 **/
100	- void *ptrs[disks];
101	+ void *ptrs[syndrome_disks+2];
102
103	pd_idx = sh->pd_idx;
104	qd_idx = sh->qd_idx;
105	@@ -1689,23 +1701,28 @@ static void compute_parity6(struct strip
106	}
107
108	/* Note that unlike RAID-5, the ordering of the disks matters greatly.*/
109	- /* FIX: Is this ordering of drives even remotely optimal? */
110	+
111	+ for (i = 0; i < disks; i++)
112	+ ptrs[i] = (void *)raid6_empty_zero_page;
113	+
114	count = 0;
115	i = d0_idx;
116	do {
117	- int slot = raid6_idx_to_slot(i, sh, &count);
118	+ int slot = raid6_idx_to_slot(i, sh, &count, syndrome_disks);
119	+
120	ptrs[slot] = page_address(sh->dev[i].page);
121	- if (slot < sh->disks - 2 &&
122	+ if (slot < syndrome_disks &&
123	!test_bit(R5_UPTODATE, &sh->dev[i].flags)) {
124	printk(KERN_ERR "block %d/%d not uptodate "
125	"on parity calc\n", i, count);
126	BUG();
127	}
128	+
129	i = raid6_next_disk(i, disks);
130	} while (i != d0_idx);
131	- BUG_ON(count+2 != disks);
132	+ BUG_ON(count != syndrome_disks);
133
134	- raid6_call.gen_syndrome(disks, STRIPE_SIZE, ptrs);
135	+ raid6_call.gen_syndrome(syndrome_disks+2, STRIPE_SIZE, ptrs);
136
137	switch(method) {
138	case RECONSTRUCT_WRITE:
139	@@ -1763,24 +1780,28 @@ static void compute_block_1(struct strip
140	static void compute_block_2(struct stripe_head *sh, int dd_idx1, int dd_idx2)
141	{
142	int i, count, disks = sh->disks;
143	+ int syndrome_disks = sh->ddf_layout ? disks : disks-2;
144	int d0_idx = raid6_d0(sh);
145	int faila = -1, failb = -1;
146	/** FIX THIS: This could be very bad if disks is close to 256 **/
147	- void *ptrs[disks];
148	+ void *ptrs[syndrome_disks+2];
149
150	+ for (i = 0; i < disks ; i++)
151	+ ptrs[i] = (void *)raid6_empty_zero_page;
152	count = 0;
153	i = d0_idx;
154	do {
155	- int slot;
156	- slot = raid6_idx_to_slot(i, sh, &count);
157	+ int slot = raid6_idx_to_slot(i, sh, &count, syndrome_disks);
158	+
159	ptrs[slot] = page_address(sh->dev[i].page);
160	+
161	if (i == dd_idx1)
162	faila = slot;
163	if (i == dd_idx2)
164	failb = slot;
165	i = raid6_next_disk(i, disks);
166	} while (i != d0_idx);
167	- BUG_ON(count+2 != disks);
168	+ BUG_ON(count != syndrome_disks);
169
170	BUG_ON(faila == failb);
171	if ( failb < faila ) { int tmp = faila; faila = failb; failb = tmp; }
172	@@ -1789,9 +1810,9 @@ static void compute_block_2(struct strip
173	(unsigned long long)sh->sector, dd_idx1, dd_idx2,
174	faila, failb);
175
176	- if ( failb == disks-1 ) {
177	+ if (failb == syndrome_disks+1) {
178	/* Q disk is one of the missing disks */
179	- if ( faila == disks-2 ) {
180	+ if (faila == syndrome_disks) {
181	/* Missing P+Q, just recompute */
182	compute_parity6(sh, UPDATE_PARITY);
183	return;
184	@@ -1806,12 +1827,13 @@ static void compute_block_2(struct strip
185	}
186
187	/* We're missing D+P or D+D; */
188	- if (failb == disks-2) {
189	+ if (failb == syndrome_disks) {
190	/* We're missing D+P. */
191	- raid6_datap_recov(disks, STRIPE_SIZE, faila, ptrs);
192	+ raid6_datap_recov(syndrome_disks+2, STRIPE_SIZE, faila, ptrs);
193	} else {
194	/* We're missing D+D. */
195	- raid6_2data_recov(disks, STRIPE_SIZE, faila, failb, ptrs);
196	+ raid6_2data_recov(syndrome_disks+2, STRIPE_SIZE, faila, failb,
197	+ ptrs);
198	}
199
200	/* Both the above update both missing blocks */
201	--- linux-2.6.27-SLE11_BRANCH.orig/include/linux/raid/raid5.h
202	+++ linux-2.6.27-SLE11_BRANCH/include/linux/raid/raid5.h
203	@@ -202,6 +202,7 @@ struct stripe_head {
204	sector_t sector; /* sector of this row */
205	short pd_idx; /* parity disk index */
206	short qd_idx; /* 'Q' disk index for raid6 */
207	+ short ddf_layout;/* use DDF ordering to calculate Q */
208	unsigned long state; /* state flags */
209	atomic_t count; /* nr of active thread/requests */
210	spinlock_t lock;