Merge branch 'for-linus' of git://neil.brown.name/md

* 'for-linus' of git://neil.brown.name/md: md: deal with merge_bvec_fn in component devices better.
author: Linus Torvalds <torvalds@linux-foundation.org> 2010-03-18 19:55:24 -0400
committer: Linus Torvalds <torvalds@linux-foundation.org> 2010-03-18 19:55:24 -0400
commit: 31cc1dd344d941358345bd02f24c629dada9b08c (patch)
tree: 9a8cd10e2e633cb83e1c7984adc85f58006dc2ec
parent: 961cde93dee2658000ead32abffb8ddf0727abe0 (diff)
parent: 627a2d3c29427637f4c5d31ccc7fcbd8d312cd71 (diff)
5 files changed, 60 insertions, 41 deletions
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index af2d39d603c7..bb2a23159b21 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -172,12 +172,14 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                disk_stack_limits(mddev->gendisk, rdev->bdev,
                                  rdev->data_offset << 9);
                /* as we don't honour merge_bvec_fn, we must never risk
-                 * violating it, so limit ->max_sector to one PAGE, as
+                 * violating it, so limit max_segments to 1 lying within
-                 * a one page request is never in violation.
+                 * a single page.
                 */
-                if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
+                if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
-                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                        blk_queue_max_segments(mddev->queue, 1);
-                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_segment_boundary(mddev->queue,
+                                                   PAGE_CACHE_SIZE - 1);
+                }
                conf->array_sectors += rdev->sectors;
                cnt++;
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 4b323f45ad74..5558ebc705c8 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -301,14 +301,16 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                                          rdev->data_offset << 9);
                /* as we don't honour merge_bvec_fn, we must never risk
-                 * violating it, so limit ->max_sector to one PAGE, as
+                 * violating it, so limit ->max_segments to one, lying
-                 * a one page request is never in violation.
+                 * within a single page.
                 * (Note: it is very unlikely that a device with
                 * merge_bvec_fn will be involved in multipath.)
                 */
-                        if (q->merge_bvec_fn &&
+                        if (q->merge_bvec_fn) {
-                            queue_max_sectors(q) > (PAGE_SIZE>>9))
+                                blk_queue_max_segments(mddev->queue, 1);
-                                blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
+                                blk_queue_segment_boundary(mddev->queue,
+                                                           PAGE_CACHE_SIZE - 1);
+                        }
                        conf->working_disks++;
                        mddev->degraded--;
@@ -476,9 +478,11 @@ static int multipath_run (mddev_t *mddev)
                /* as we don't honour merge_bvec_fn, we must never risk
                 * violating it, not that we ever expect a device with
                 * a merge_bvec_fn to be involved in multipath */
-                if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
+                if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
-                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                        blk_queue_max_segments(mddev->queue, 1);
-                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_segment_boundary(mddev->queue,
+                                                   PAGE_CACHE_SIZE - 1);
+                }
                if (!test_bit(Faulty, &rdev->flags))
                        conf->working_disks++;
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index a1f7147b757f..377cf2a3c333 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -176,14 +176,15 @@ static int create_strip_zones(mddev_t *mddev)
                disk_stack_limits(mddev->gendisk, rdev1->bdev,
                                  rdev1->data_offset << 9);
                /* as we don't honour merge_bvec_fn, we must never risk
-                 * violating it, so limit ->max_sector to one PAGE, as
+                 * violating it, so limit ->max_segments to 1, lying within
-                 * a one page request is never in violation.
+                 * a single page.
                 */
-                if (rdev1->bdev->bd_disk->queue->merge_bvec_fn &&
+                if (rdev1->bdev->bd_disk->queue->merge_bvec_fn) {
-                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                        blk_queue_max_segments(mddev->queue, 1);
-                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_segment_boundary(mddev->queue,
+                                                   PAGE_CACHE_SIZE - 1);
+                }
                if (!smallest || (rdev1->sectors < smallest->sectors))
                        smallest = rdev1;
                cnt++;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 5a06122abd3b..f741f77eeb2b 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1152,13 +1152,17 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                        disk_stack_limits(mddev->gendisk, rdev->bdev,
                                          rdev->data_offset << 9);
-                        /* as we don't honour merge_bvec_fn, we must never risk
+                        /* as we don't honour merge_bvec_fn, we must
-                         * violating it, so limit ->max_sector to one PAGE, as
+                         * never risk violating it, so limit
-                         * a one page request is never in violation.
+                         * ->max_segments to one lying with a single
+                         * page, as a one page request is never in
+                         * violation.
                         */
-                        if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
+                        if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
-                            queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                                blk_queue_max_segments(mddev->queue, 1);
-                                blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
+                                blk_queue_segment_boundary(mddev->queue,
+                                                           PAGE_CACHE_SIZE - 1);
+                        }
                        p->head_position = 0;
                        rdev->raid_disk = mirror;
@@ -2098,12 +2102,14 @@ static int run(mddev_t *mddev)
                disk_stack_limits(mddev->gendisk, rdev->bdev,
                                  rdev->data_offset << 9);
                /* as we don't honour merge_bvec_fn, we must never risk
-                 * violating it, so limit ->max_sector to one PAGE, as
+                 * violating it, so limit ->max_segments to 1 lying within
-                 * a one page request is never in violation.
+                 * a single page, as a one page request is never in violation.
                 */
-                if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
+                if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
-                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                        blk_queue_max_segments(mddev->queue, 1);
-                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_segment_boundary(mddev->queue,
+                                                   PAGE_CACHE_SIZE - 1);
+                }
        }
        mddev->degraded = 0;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 7584f9ab9bcf..b4ba41ecbd20 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1155,13 +1155,17 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                        disk_stack_limits(mddev->gendisk, rdev->bdev,
                                          rdev->data_offset << 9);
-                        /* as we don't honour merge_bvec_fn, we must never risk
+                        /* as we don't honour merge_bvec_fn, we must
-                         * violating it, so limit ->max_sector to one PAGE, as
+                         * never risk violating it, so limit
-                         * a one page request is never in violation.
+                         * ->max_segments to one lying with a single
+                         * page, as a one page request is never in
+                         * violation.
                         */
-                        if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
+                        if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
-                            queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                                blk_queue_max_segments(mddev->queue, 1);
-                                blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
+                                blk_queue_segment_boundary(mddev->queue,
+                                                           PAGE_CACHE_SIZE - 1);
+                        }
                        p->head_position = 0;
                        rdev->raid_disk = mirror;
@@ -2255,12 +2259,14 @@ static int run(mddev_t *mddev)
                disk_stack_limits(mddev->gendisk, rdev->bdev,
                                  rdev->data_offset << 9);
                /* as we don't honour merge_bvec_fn, we must never risk
-                 * violating it, so limit ->max_sector to one PAGE, as
+                 * violating it, so limit max_segments to 1 lying
-                 * a one page request is never in violation.
+                 * within a single page.
                 */
-                if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
+                if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
-                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                        blk_queue_max_segments(mddev->queue, 1);
-                        blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);
+                        blk_queue_segment_boundary(mddev->queue,
+                                                   PAGE_CACHE_SIZE - 1);
+                }
                disk->head_position = 0;
        }
author	Linus Torvalds <torvalds@linux-foundation.org>	2010-03-18 19:55:24 -0400
committer	Linus Torvalds <torvalds@linux-foundation.org>	2010-03-18 19:55:24 -0400
commit	31cc1dd344d941358345bd02f24c629dada9b08c (patch)
tree	9a8cd10e2e633cb83e1c7984adc85f58006dc2ec
parent	961cde93dee2658000ead32abffb8ddf0727abe0 (diff)
parent	627a2d3c29427637f4c5d31ccc7fcbd8d312cd71 (diff)

diff --git a/drivers/md/linear.c b/drivers/md/linear.c index af2d39d603c7..bb2a23159b21 100644 --- a/drivers/md/linear.c +++ b/drivers/md/linear.c
@@ -172,12 +172,14 @@ static linear_conf_t linear_conf(mddev_t mddev, int raid_disks)
172	disk_stack_limits(mddev->gendisk, rdev->bdev,	172	disk_stack_limits(mddev->gendisk, rdev->bdev,
173	rdev->data_offset << 9);	173	rdev->data_offset << 9);
174	/* as we don't honour merge_bvec_fn, we must never risk	174	/* as we don't honour merge_bvec_fn, we must never risk
175	* violating it, so limit ->max_sector to one PAGE, as	175	* violating it, so limit max_segments to 1 lying within
176	* a one page request is never in violation.	176	* a single page.
177	*/	177	*/
178	if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&	178	if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
179	queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))	179	blk_queue_max_segments(mddev->queue, 1);
180	blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);	180	blk_queue_segment_boundary(mddev->queue,
		181	PAGE_CACHE_SIZE - 1);
		182	}
181		183
182	conf->array_sectors += rdev->sectors;	184	conf->array_sectors += rdev->sectors;
183	cnt++;	185	cnt++;


diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c index 4b323f45ad74..5558ebc705c8 100644 --- a/drivers/md/multipath.c +++ b/drivers/md/multipath.c
@@ -301,14 +301,16 @@ static int multipath_add_disk(mddev_t mddev, mdk_rdev_t rdev)
301	rdev->data_offset << 9);	301	rdev->data_offset << 9);
302		302
303	/* as we don't honour merge_bvec_fn, we must never risk	303	/* as we don't honour merge_bvec_fn, we must never risk
304	* violating it, so limit ->max_sector to one PAGE, as	304	* violating it, so limit ->max_segments to one, lying
305	* a one page request is never in violation.	305	* within a single page.
306	* (Note: it is very unlikely that a device with	306	* (Note: it is very unlikely that a device with
307	* merge_bvec_fn will be involved in multipath.)	307	* merge_bvec_fn will be involved in multipath.)
308	*/	308	*/
309	if (q->merge_bvec_fn &&	309	if (q->merge_bvec_fn) {
310	queue_max_sectors(q) > (PAGE_SIZE>>9))	310	blk_queue_max_segments(mddev->queue, 1);
311	blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);	311	blk_queue_segment_boundary(mddev->queue,
		312	PAGE_CACHE_SIZE - 1);
		313	}
312		314
313	conf->working_disks++;	315	conf->working_disks++;
314	mddev->degraded--;	316	mddev->degraded--;
@@ -476,9 +478,11 @@ static int multipath_run (mddev_t *mddev)
476	/* as we don't honour merge_bvec_fn, we must never risk	478	/* as we don't honour merge_bvec_fn, we must never risk
477	* violating it, not that we ever expect a device with	479	* violating it, not that we ever expect a device with
478	* a merge_bvec_fn to be involved in multipath */	480	* a merge_bvec_fn to be involved in multipath */
479	if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&	481	if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
480	queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))	482	blk_queue_max_segments(mddev->queue, 1);
481	blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);	483	blk_queue_segment_boundary(mddev->queue,
		484	PAGE_CACHE_SIZE - 1);
		485	}
482		486
483	if (!test_bit(Faulty, &rdev->flags))	487	if (!test_bit(Faulty, &rdev->flags))
484	conf->working_disks++;	488	conf->working_disks++;


diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c index a1f7147b757f..377cf2a3c333 100644 --- a/drivers/md/raid0.c +++ b/drivers/md/raid0.c
@@ -176,14 +176,15 @@ static int create_strip_zones(mddev_t *mddev)
176	disk_stack_limits(mddev->gendisk, rdev1->bdev,	176	disk_stack_limits(mddev->gendisk, rdev1->bdev,
177	rdev1->data_offset << 9);	177	rdev1->data_offset << 9);
178	/* as we don't honour merge_bvec_fn, we must never risk	178	/* as we don't honour merge_bvec_fn, we must never risk
179	* violating it, so limit ->max_sector to one PAGE, as	179	* violating it, so limit ->max_segments to 1, lying within
180	* a one page request is never in violation.	180	* a single page.
181	*/	181	*/
182		182
183	if (rdev1->bdev->bd_disk->queue->merge_bvec_fn &&	183	if (rdev1->bdev->bd_disk->queue->merge_bvec_fn) {
184	queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))	184	blk_queue_max_segments(mddev->queue, 1);
185	blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);	185	blk_queue_segment_boundary(mddev->queue,
186		186	PAGE_CACHE_SIZE - 1);
		187	}
187	if (!smallest \|\| (rdev1->sectors < smallest->sectors))	188	if (!smallest \|\| (rdev1->sectors < smallest->sectors))
188	smallest = rdev1;	189	smallest = rdev1;
189	cnt++;	190	cnt++;


diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index 5a06122abd3b..f741f77eeb2b 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c
@@ -1152,13 +1152,17 @@ static int raid1_add_disk(mddev_t mddev, mdk_rdev_t rdev)
1152		1152
1153	disk_stack_limits(mddev->gendisk, rdev->bdev,	1153	disk_stack_limits(mddev->gendisk, rdev->bdev,
1154	rdev->data_offset << 9);	1154	rdev->data_offset << 9);
1155	/* as we don't honour merge_bvec_fn, we must never risk	1155	/* as we don't honour merge_bvec_fn, we must
1156	* violating it, so limit ->max_sector to one PAGE, as	1156	* never risk violating it, so limit
1157	* a one page request is never in violation.	1157	* ->max_segments to one lying with a single
		1158	* page, as a one page request is never in
		1159	* violation.
1158	*/	1160	*/
1159	if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&	1161	if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
1160	queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))	1162	blk_queue_max_segments(mddev->queue, 1);
1161	blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);	1163	blk_queue_segment_boundary(mddev->queue,
		1164	PAGE_CACHE_SIZE - 1);
		1165	}
1162		1166
1163	p->head_position = 0;	1167	p->head_position = 0;
1164	rdev->raid_disk = mirror;	1168	rdev->raid_disk = mirror;
@@ -2098,12 +2102,14 @@ static int run(mddev_t *mddev)
2098	disk_stack_limits(mddev->gendisk, rdev->bdev,	2102	disk_stack_limits(mddev->gendisk, rdev->bdev,
2099	rdev->data_offset << 9);	2103	rdev->data_offset << 9);
2100	/* as we don't honour merge_bvec_fn, we must never risk	2104	/* as we don't honour merge_bvec_fn, we must never risk
2101	* violating it, so limit ->max_sector to one PAGE, as	2105	* violating it, so limit ->max_segments to 1 lying within
2102	* a one page request is never in violation.	2106	* a single page, as a one page request is never in violation.
2103	*/	2107	*/
2104	if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&	2108	if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
2105	queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))	2109	blk_queue_max_segments(mddev->queue, 1);
2106	blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);	2110	blk_queue_segment_boundary(mddev->queue,
		2111	PAGE_CACHE_SIZE - 1);
		2112	}
2107	}	2113	}
2108		2114
2109	mddev->degraded = 0;	2115	mddev->degraded = 0;


diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c index 7584f9ab9bcf..b4ba41ecbd20 100644 --- a/drivers/md/raid10.c +++ b/drivers/md/raid10.c
@@ -1155,13 +1155,17 @@ static int raid10_add_disk(mddev_t mddev, mdk_rdev_t rdev)
1155		1155
1156	disk_stack_limits(mddev->gendisk, rdev->bdev,	1156	disk_stack_limits(mddev->gendisk, rdev->bdev,
1157	rdev->data_offset << 9);	1157	rdev->data_offset << 9);
1158	/* as we don't honour merge_bvec_fn, we must never risk	1158	/* as we don't honour merge_bvec_fn, we must
1159	* violating it, so limit ->max_sector to one PAGE, as	1159	* never risk violating it, so limit
1160	* a one page request is never in violation.	1160	* ->max_segments to one lying with a single
		1161	* page, as a one page request is never in
		1162	* violation.
1161	*/	1163	*/
1162	if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&	1164	if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
1163	queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))	1165	blk_queue_max_segments(mddev->queue, 1);
1164	blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);	1166	blk_queue_segment_boundary(mddev->queue,
		1167	PAGE_CACHE_SIZE - 1);
		1168	}
1165		1169
1166	p->head_position = 0;	1170	p->head_position = 0;
1167	rdev->raid_disk = mirror;	1171	rdev->raid_disk = mirror;
@@ -2255,12 +2259,14 @@ static int run(mddev_t *mddev)
2255	disk_stack_limits(mddev->gendisk, rdev->bdev,	2259	disk_stack_limits(mddev->gendisk, rdev->bdev,
2256	rdev->data_offset << 9);	2260	rdev->data_offset << 9);
2257	/* as we don't honour merge_bvec_fn, we must never risk	2261	/* as we don't honour merge_bvec_fn, we must never risk
2258	* violating it, so limit ->max_sector to one PAGE, as	2262	* violating it, so limit max_segments to 1 lying
2259	* a one page request is never in violation.	2263	* within a single page.
2260	*/	2264	*/
2261	if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&	2265	if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
2262	queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))	2266	blk_queue_max_segments(mddev->queue, 1);
2263	blk_queue_max_hw_sectors(mddev->queue, PAGE_SIZE>>9);	2267	blk_queue_segment_boundary(mddev->queue,
		2268	PAGE_CACHE_SIZE - 1);
		2269	}
2264		2270
2265	disk->head_position = 0;	2271	disk->head_position = 0;
2266	}	2272	}