Skip to contentSkip to conversation

block: allow device to have both virt_boundary_mask and max segment size

PATCH Applied Ming Lei 6 participants 13 messages Apr 7, 2024 – Apr 24, 2024

Subsystems (3)
lore
Share & tools
lore

Ming Lei

author
#0 lore raw

PATCH 1/1 block: allow device to have both virt_boundary_mask and max segment size

When one stacking device is over one device with virt_boundary_mask and another one with max segment size, the stacking device have both limits set. This way is allowed before d690cb8ae14b ("block: add an API to atomically update queue limits").

Relax the limit so that we won't break such kind of stacking setting.

Reported-by [email protected]
Fixes d690cb8ae14b ("block: add an API to atomically update queue limits")
Cc Christoph Hellwig <[email protected]>
Cc Mike Snitzer <[email protected]>
Cc Song Liu <[email protected]>
---
 block/blk-settings.c | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)
block/blk-settings.c +6 -10
index cdbaef159c4b..d2731843f2fc 100644
@@ -182,17 +182,13 @@ static int blk_validate_limits(struct queue_limits *lim)
 		return -EINVAL;
 
 	/*
-	 * Devices that require a virtual boundary do not support scatter/gather
-	 * I/O natively, but instead require a descriptor list entry for each
-	 * page (which might not be identical to the Linux PAGE_SIZE).  Because
-	 * of that they are not limited by our notion of "segment size".
+	 * Stacking device may have both virtual boundary and max segment
+	 * size limit, so allow this setting now, and long-term the two
+	 * might need to move out of stacking limits since we have immutable
+	 * bvec and lower layer bio splitting is supposed to handle the two
+	 * correctly.
 	 */
-	if (lim->virt_boundary_mask) {
-		if (WARN_ON_ONCE(lim->max_segment_size &&
-				 lim->max_segment_size != UINT_MAX))
-			return -EINVAL;
-		lim->max_segment_size = UINT_MAX;
-	} else {
+	if (!lim->virt_boundary_mask) {
 		/*
 		 * The maximum segment size has an odd historic 64k default that
 		 * drivers probably should override.  Just like the I/O size we
Signature · 1 line
2.41.0
maintainer Reviewed-by on v1 1/1
#1 lore raw
Quoted 52 lines · Ming Lei

When one stacking device is over one device with virt_boundary_mask and another one with max segment size, the stacking device have both limits set. This way is allowed before d690cb8ae14b ("block: add an API to atomically update queue limits").

Relax the limit so that we won't break such kind of stacking setting.

Reported-by [email protected]
Fixes d690cb8ae14b ("block: add an API to atomically update queue limits")
Cc Christoph Hellwig <[email protected]>
Cc Mike Snitzer <[email protected]>
Cc Song Liu <[email protected]>
---
 block/blk-settings.c | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)
block/blk-settings.c +6 -10
index cdbaef159c4b..d2731843f2fc 100644
@@ -182,17 +182,13 @@ static int blk_validate_limits(struct queue_limits *lim)
 		return -EINVAL;
 
 	/*
-	 * Devices that require a virtual boundary do not support scatter/gather
-	 * I/O natively, but instead require a descriptor list entry for each
-	 * page (which might not be identical to the Linux PAGE_SIZE).  Because
-	 * of that they are not limited by our notion of "segment size".
+	 * Stacking device may have both virtual boundary and max segment
+	 * size limit, so allow this setting now, and long-term the two
+	 * might need to move out of stacking limits since we have immutable
+	 * bvec and lower layer bio splitting is supposed to handle the two
+	 * correctly.
 	 */
-	if (lim->virt_boundary_mask) {
-		if (WARN_ON_ONCE(lim->max_segment_size &&
-				 lim->max_segment_size != UINT_MAX))
-			return -EINVAL;
-		lim->max_segment_size = UINT_MAX;
-	} else {
+	if (!lim->virt_boundary_mask) {
 		/*
 		 * The maximum segment size has an odd historic 64k default that
 		 * drivers probably should override.  Just like the I/O size we
Signature · 1 line
2.41.0
maintainer Applied
#2 lore raw
In reply to Ming Lei
Quoted 8 lines · Ming Lei

When one stacking device is over one device with virt_boundary_mask and another one with max segment size, the stacking device have both limits set. This way is allowed before d690cb8ae14b ("block: add an API to atomically update queue limits").

Relax the limit so that we won't break such kind of stacking setting.

[...]

Applied, thanks!

[1/1] block: allow device to have both virt_boundary_mask and max segment size

      commit: b561ea56a26415bf44ce8ca6a8e625c7c390f1ea

Best regards,

Signature · 1 line
Jens Axboe
#3 lore raw
In reply to Ming Lei
Quoted 6 lines · Ming Lei

When one stacking device is over one device with virt_boundary_mask and another one with max segment size, the stacking device have both limits set. This way is allowed before d690cb8ae14b ("block: add an API to atomically update queue limits").

Relax the limit so that we won't break such kind of stacking setting.

No, this is broken as discussed before. With a virt_boundary_mask we create a segment for every page (that is device page, which usually but not always is the same as the Linux page size). If we now also limit the segment size, we fail to produce valid I/O.

The problem is that that neither the segment_size nor the virtual_boundary should be inherited by a stackable device and we need to fix that.

author
#4 lore raw
Quoted 6 lines · Christoph Hellwig
Quoted 5 lines · Ming Lei

When one stacking device is over one device with virt_boundary_mask and another one with max segment size, the stacking device have both limits set. This way is allowed before d690cb8ae14b ("block: add an API to atomically update queue limits").

Quoted 6 lines
Quoted 1 line

Relax the limit so that we won't break such kind of stacking setting.

No, this is broken as discussed before. With a virt_boundary_mask we create a segment for every page (that is device page, which usually but not always is the same as the Linux page size). If we now also limit the segment size, we fail to produce valid I/O.

It isn't now we put the limit, and this way has been done for stacking device since beginning, it is actually added by commit d690cb8ae14b in v6.9-rc1.

If max segment size isn't aligned with virt_boundary_mask, bio_split_rw() will split the bio with max segment size, this way still works, just not efficiently. And in reality, the two are often aligned.

Quoted 4 lines

The problem is that that neither the segment_size nor the virtual_boundary should be inherited by a stackable device and we need to fix that.

It is one big change with regression risk, which may not be good after -rc3.

Thanks,
Ming

#5 lore raw
Quoted 6 lines · Ming Lei

It isn't now we put the limit, and this way has been done for stacking device since beginning, it is actually added by commit d690cb8ae14b in v6.9-rc1.

If max segment size isn't aligned with virt_boundary_mask, bio_split_rw() will split the bio with max segment size, this way still works, just not efficiently. And in reality, the two are often aligned.

We've had real bugs due to this, which is why we have the check. We also had a warning before the commit, it's just it got skipped for stacking. So even if we want to return to the broken pre-6.9-rc behavior it should only be for stacking. I don't think that is a good outcome, though.

author Reviewed-by Reviewed-by Hannes Reinecke
#6 lore raw
Quoted 8 lines · Christoph Hellwig
Quoted 6 lines · Ming Lei

It isn't now we put the limit, and this way has been done for stacking device since beginning, it is actually added by commit d690cb8ae14b in v6.9-rc1.

If max segment size isn't aligned with virt_boundary_mask, bio_split_rw() will split the bio with max segment size, this way still works, just not efficiently. And in reality, the two are often aligned.

Quoted 5 lines

We've had real bugs due to this, which is why we have the check. We also had a warning before the commit, it's just it got skipped for stacking. So even if we want to return to the broken pre-6.9-rc behavior it should only be for stacking. I don't think that is a good outcome, though.

The limit is from commit 09324d32d2a0 ("block: force an unlimited segment size on queues with a virt boundary") which claims to fix f6970f83ef79 ("block: don't check if adjacent bvecs in one bio can be mergeable").

However commit f6970f83ef79 only covers merge code which isn't used by bio driver at all, so not sure pre-6.9-rc is broken for stacking driver.

Also commit 09324d32d2a0 mentioned that it did not cause problem, actually 64K default segment size limits always exists even though the device doesn't provide one, so looks there isn't report as 'real bugs', or maybe I miss something?

commit 09324d32d2a0843e66652a087da6f77924358e62

Author: Christoph Hellwig <[email protected]>
Date:   Tue May 21 09:01:41 2019 +0200

block: force an unlimited segment size on queues with a virt boundary

We currently fail to update the front/back segment size in the bio when deciding to allow an otherwise gappy segement to a device with a virt boundary. The reason why this did not cause problems is that devices with a virt boundary fundamentally don't use segments as we know it and thus don't care. Make that assumption formal by forcing an unlimited segement size in this case.

Fixes f6970f83ef79 ("block: don't check if adjacent bvecs in one bio can be mergeable")

Thanks,
Ming

#7 lore raw
Quoted 6 lines · Ming Lei

The limit is from commit 09324d32d2a0 ("block: force an unlimited segment size on queues with a virt boundary") which claims to fix f6970f83ef79 ("block: don't check if adjacent bvecs in one bio can be mergeable").

However commit f6970f83ef79 only covers merge code which isn't used by bio driver at all, so not sure pre-6.9-rc is broken for stacking driver.

We can stack rq drivers as well.

Quoted 4 lines

Also commit 09324d32d2a0 mentioned that it did not cause problem, actually 64K default segment size limits always exists even though the device doesn't provide one, so looks there isn't report as 'real bugs', or maybe I miss something?

The problem is when the segment size does not align to the boundary mask as you'll now start feeding malformed segments/entris to the device.

author
#8 lore raw
Quoted 10 lines · Christoph Hellwig
Quoted 6 lines · Ming Lei

The limit is from commit 09324d32d2a0 ("block: force an unlimited segment size on queues with a virt boundary") which claims to fix f6970f83ef79 ("block: don't check if adjacent bvecs in one bio can be mergeable").

However commit f6970f83ef79 only covers merge code which isn't used by bio driver at all, so not sure pre-6.9-rc is broken for stacking driver.

We can stack rq drivers as well.

Quoted 8 lines
Quoted 4 lines

Also commit 09324d32d2a0 mentioned that it did not cause problem, actually 64K default segment size limits always exists even though the device doesn't provide one, so looks there isn't report as 'real bugs', or maybe I miss something?

The problem is when the segment size does not align to the boundary mask as you'll now start feeding malformed segments/entris to the device.

In case of single bio, this bio will be split with max segment size if segment size doesn't align with virt boundary, so the resulted bio is still valid because virt-boundary allows the last bvec to be unaligned.

In case of bio merge, bio_will_gap() is always called to make sure there isn't gap between the two bios wrt. virt boundary.

Can you explain a bit how one malformed bio is made?

Thanks,
Ming

#9 lore raw
In reply to Ming Lei
Quoted 7 lines · Ming Lei

It isn't now we put the limit, and this way has been done for stacking device since beginning, it is actually added by commit d690cb8ae14b in v6.9-rc1.

If max segment size isn't aligned with virt_boundary_mask, bio_split_rw() will split the bio with max segment size, this way still works, just not efficiently. And in reality, the two are often aligned.

I take it as a compliment, building exotic configurations is something I'd love to be good at.
But, as far as I understand, this warning is caused by my raid config, right?
How is it possible that a raid6 array has a queue/max_segment_size of (2^16 - 1) in sysfs while 2 others on the same system have a queue/max_segment_size of (2^32 - 1)? they are all rotational devices on the same SAS controller, just this malfunctioning one uses SATA drives while the other 2 are SAS. Understanding this would help me to avoid this unwanted behavior.

Kind regards,

Janpieter Sollie

#10 lore raw
In reply to Ming Lei

Hi Ming,

Quoted 7 lines · Ming Lei

When one stacking device is over one device with virt_boundary_mask and another one with max segment size, the stacking device have both limits set. This way is allowed before d690cb8ae14b ("block: add an API to atomically update queue limits").

Relax the limit so that we won't break such kind of stacking setting.

Quoted 10 lines
Reported-by [email protected]
Fixes d690cb8ae14b ("block: add an API to atomically update queue limits")
Cc Christoph Hellwig <[email protected]>
Cc Mike Snitzer <[email protected]>
Cc Song Liu <[email protected]>

Thanks for your patch, which is now commit b561ea56a26415bf ("block:
allow device to have both virt_boundary_mask and max segment size") in v6.9-rc4.

With CONFIG_DMA_API_DEBUG_SG=y and IOMMU support enabled, this causes a warning on R-Car Gen3/Gen4 platforms:

    DMA-API: renesas_sdhi_internal_dmac ee160000.mmc: mapping sg segment longer than device claims to support [len=86016] [max=65536]
    WARNING: CPU: 1 PID: 281 at kernel/dma/debug.c:1178 debug_dma_map_sg+0x2ac/0x330
    Modules linked in:
    CPU: 1 PID: 281 Comm: systemd-udevd Tainted: G        W          6.9.0-rc2-ebisu-00012-gb561ea56a264 #596
    Hardware name: Renesas Ebisu board based on r8a77990 (DT)
    pstate: 60400005 (nZCv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--)
    pc : debug_dma_map_sg+0x2ac/0x330
    lr : debug_dma_map_sg+0x2ac/0x330
    sp : ffffffc083643470
    x29: ffffffc083643470 x28: 0000000000000080 x27: 0000000000010000
    x26: 0000000000000000 x25: 0000000000000001 x24: ffffffc0810afc30
    x23: ffffffffffffffff x22: ffffffc080c8366f x21: ffffff8008849f80
    x20: ffffff800cd24000 x19: ffffff80099a2810 x18: 0000000000000000
    x17: ffffff800801a000 x16: ffffffc080453f00 x15: ffffffc0836430f0
    x14: ffffffc08099fb50 x13: 0000000000000007 x12: 0000000000000000
    x11: 0000000000000202 x10: ffffffc0810d99d0 x9 : ffffffc081189bb0
    x8 : ffffffc083643178 x7 : ffffffc083643180 x6 : 00000000ffffdfff
    x5 : 0000000000000000 x4 : 0000000000000000 x3 : 0000000000000000
    x2 : 0000000000000000 x1 : 0000000000000000 x0 : ffffff800ebad280
    Call trace:
     debug_dma_map_sg+0x2ac/0x330
     __dma_map_sg_attrs+0xcc/0xd0
     dma_map_sg_attrs+0xc/0x1c
     renesas_sdhi_internal_dmac_map+0x64/0x94
     renesas_sdhi_internal_dmac_pre_req+0x20/0x2c
     mmc_blk_mq_issue_rq+0x62c/0x6c8
     mmc_mq_queue_rq+0x194/0x218
     blk_mq_dispatch_rq_list+0x36c/0x4d4
     __blk_mq_sched_dispatch_requests+0x344/0x4e0
     blk_mq_sched_dispatch_requests+0x28/0x5c
     blk_mq_run_hw_queue+0x1a4/0x218
     blk_mq_flush_plug_list+0x2fc/0x4a0
     __blk_flush_plug+0x70/0x134
     blk_finish_plug+0x24/0x34
     read_pages+0x60/0x158
     page_cache_ra_unbounded+0x98/0x184
     do_page_cache_ra+0x44/0x50
     force_page_cache_ra+0x98/0x9c
     page_cache_sync_ra+0x30/0x54
     filemap_get_pages+0xfc/0x4f8
     filemap_read+0xe8/0x2b8
     blkdev_read_iter+0x12c/0x144
     vfs_read+0x104/0x150
     ksys_read+0x6c/0xd4
     __arm64_sys_read+0x14/0x1c
     invoke_syscall+0x70/0xf4
     el0_svc_common.constprop.0+0xb0/0xcc
     do_el0_svc+0x1c/0x24
     el0_svc+0x34/0x8c
     el0t_64_sync_handler+0x88/0x124
     el0t_64_sync+0x150/0x154
    irq event stamp: 0
    hardirqs last  enabled at (0): [<0000000000000000>] 0x0
    hardirqs last disabled at (0): [<ffffffc08007efa4>] copy_process+0x6ac/0x18d4
    softirqs last  enabled at (0): [<ffffffc08007efa4>] copy_process+0x6ac/0x18d4
    softirqs last disabled at (0): [<0000000000000000>] 0x0

Reverting this commit, or disabling IOMMU support fixes the issue.

Quoted 16 lines
block/blk-settings.c +5 -4
@@ -182,17 +182,13 @@ static int blk_validate_limits(struct queue_limits *lim)
 		return -EINVAL;
 
 	/*
-	 * Devices that require a virtual boundary do not support scatter/gather
-	 * I/O natively, but instead require a descriptor list entry for each
-	 * page (which might not be identical to the Linux PAGE_SIZE).  Because
-	 * of that they are not limited by our notion of "segment size".
+	 * Stacking device may have both virtual boundary and max segment
+	 * size limit, so allow this setting now, and long-term the two
+	 * might need to move out of stacking limits since we have immutable
+	 * bvec and lower layer bio splitting is supposed to handle the two
+	 * correctly.
 	 */

block/blk-settings.c static int blk_validate_limits(struct queue_limits *lim) · line 194

Quoted 10 lines
block/blk-settings.c +1 -6
-	if (lim->virt_boundary_mask) {
-		if (WARN_ON_ONCE(lim->max_segment_size &&
-				 lim->max_segment_size != UINT_MAX))
-			return -EINVAL;
-		lim->max_segment_size = UINT_MAX;
-	} else {
+	if (!lim->virt_boundary_mask) {
 		/*
 		 * The maximum segment size has an odd historic 64k default that
 		 * drivers probably should override.  Just like the I/O size we

Gr{oetje,eeting}s,

Geert

--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds

author
#11 lore raw
Quoted 85 lines · Geert Uytterhoeven

Hi Ming,

Quoted 7 lines · Ming Lei

When one stacking device is over one device with virt_boundary_mask and another one with max segment size, the stacking device have both limits set. This way is allowed before d690cb8ae14b ("block: add an API to atomically update queue limits").

Relax the limit so that we won't break such kind of stacking setting.

Quoted 10 lines
Reported-by [email protected]
Fixes d690cb8ae14b ("block: add an API to atomically update queue limits")
Cc Christoph Hellwig <[email protected]>
Cc Mike Snitzer <[email protected]>
Cc Song Liu <[email protected]>

Thanks for your patch, which is now commit b561ea56a26415bf ("block:
allow device to have both virt_boundary_mask and max segment size") in v6.9-rc4.

With CONFIG_DMA_API_DEBUG_SG=y and IOMMU support enabled, this causes a warning on R-Car Gen3/Gen4 platforms:

    DMA-API: renesas_sdhi_internal_dmac ee160000.mmc: mapping sg segment longer than device claims to support [len=86016] [max=65536]
    WARNING: CPU: 1 PID: 281 at kernel/dma/debug.c:1178 debug_dma_map_sg+0x2ac/0x330
    Modules linked in:
    CPU: 1 PID: 281 Comm: systemd-udevd Tainted: G        W          6.9.0-rc2-ebisu-00012-gb561ea56a264 #596
    Hardware name: Renesas Ebisu board based on r8a77990 (DT)
    pstate: 60400005 (nZCv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--)
    pc : debug_dma_map_sg+0x2ac/0x330
    lr : debug_dma_map_sg+0x2ac/0x330
    sp : ffffffc083643470
    x29: ffffffc083643470 x28: 0000000000000080 x27: 0000000000010000
    x26: 0000000000000000 x25: 0000000000000001 x24: ffffffc0810afc30
    x23: ffffffffffffffff x22: ffffffc080c8366f x21: ffffff8008849f80
    x20: ffffff800cd24000 x19: ffffff80099a2810 x18: 0000000000000000
    x17: ffffff800801a000 x16: ffffffc080453f00 x15: ffffffc0836430f0
    x14: ffffffc08099fb50 x13: 0000000000000007 x12: 0000000000000000
    x11: 0000000000000202 x10: ffffffc0810d99d0 x9 : ffffffc081189bb0
    x8 : ffffffc083643178 x7 : ffffffc083643180 x6 : 00000000ffffdfff
    x5 : 0000000000000000 x4 : 0000000000000000 x3 : 0000000000000000
    x2 : 0000000000000000 x1 : 0000000000000000 x0 : ffffff800ebad280
    Call trace:
     debug_dma_map_sg+0x2ac/0x330
     __dma_map_sg_attrs+0xcc/0xd0
     dma_map_sg_attrs+0xc/0x1c
     renesas_sdhi_internal_dmac_map+0x64/0x94
     renesas_sdhi_internal_dmac_pre_req+0x20/0x2c
     mmc_blk_mq_issue_rq+0x62c/0x6c8
     mmc_mq_queue_rq+0x194/0x218
     blk_mq_dispatch_rq_list+0x36c/0x4d4
     __blk_mq_sched_dispatch_requests+0x344/0x4e0
     blk_mq_sched_dispatch_requests+0x28/0x5c
     blk_mq_run_hw_queue+0x1a4/0x218
     blk_mq_flush_plug_list+0x2fc/0x4a0
     __blk_flush_plug+0x70/0x134
     blk_finish_plug+0x24/0x34
     read_pages+0x60/0x158
     page_cache_ra_unbounded+0x98/0x184
     do_page_cache_ra+0x44/0x50
     force_page_cache_ra+0x98/0x9c
     page_cache_sync_ra+0x30/0x54
     filemap_get_pages+0xfc/0x4f8
     filemap_read+0xe8/0x2b8
     blkdev_read_iter+0x12c/0x144
     vfs_read+0x104/0x150
     ksys_read+0x6c/0xd4
     __arm64_sys_read+0x14/0x1c
     invoke_syscall+0x70/0xf4
     el0_svc_common.constprop.0+0xb0/0xcc
     do_el0_svc+0x1c/0x24
     el0_svc+0x34/0x8c
     el0t_64_sync_handler+0x88/0x124
     el0t_64_sync+0x150/0x154
    irq event stamp: 0
    hardirqs last  enabled at (0): [<0000000000000000>] 0x0
    hardirqs last disabled at (0): [<ffffffc08007efa4>] copy_process+0x6ac/0x18d4
    softirqs last  enabled at (0): [<ffffffc08007efa4>] copy_process+0x6ac/0x18d4
    softirqs last disabled at (0): [<0000000000000000>] 0x0
Quoted 1 line

Reverting this commit, or disabling IOMMU support fixes the issue.

Hello Geert,

Can you test the following patch?

block/blk-settings.c +4 -1
index 8e1d7ed52fef..ebba05a2bc7f 100644
@@ -188,7 +188,10 @@ static int blk_validate_limits(struct queue_limits *lim)
 	 * bvec and lower layer bio splitting is supposed to handle the two
 	 * correctly.
 	 */
-	if (!lim->virt_boundary_mask) {
+	if (lim->virt_boundary_mask) {
+		if (!lim->max_segment_size)
+			lim->max_segment_size = UINT_MAX;
+	} else {
 		/*
 		 * The maximum segment size has an odd historic 64k default that
 		 * drivers probably should override.  Just like the I/O size we

thanks
Ming

#12 lore raw

Hi Ming,

Quoted 41 lines · Ming Lei
Quoted 23 lines · Geert Uytterhoeven
Quoted 7 lines · Ming Lei

When one stacking device is over one device with virt_boundary_mask and another one with max segment size, the stacking device have both limits set. This way is allowed before d690cb8ae14b ("block: add an API to atomically update queue limits").

Relax the limit so that we won't break such kind of stacking setting.

Quoted 10 lines
Reported-by [email protected]
Fixes d690cb8ae14b ("block: add an API to atomically update queue limits")
Cc Christoph Hellwig <[email protected]>
Cc Mike Snitzer <[email protected]>
Cc Song Liu <[email protected]>

Thanks for your patch, which is now commit b561ea56a26415bf ("block:
allow device to have both virt_boundary_mask and max segment size") in v6.9-rc4.

Quoted 7 lines

With CONFIG_DMA_API_DEBUG_SG=y and IOMMU support enabled, this causes a warning on R-Car Gen3/Gen4 platforms:

DMA-API: renesas_sdhi_internal_dmac ee160000.mmc: mapping sg segment longer than device claims to support [len=86016] [max=65536]
WARNING: CPU: 1 PID: 281 at kernel/dma/debug.c:1178 debug_dma_map_sg+0x2ac/0x330

Reverting this commit, or disabling IOMMU support fixes the issue.

Can you test the following patch?

block/blk-settings.c +0 -0
index 8e1d7ed52fef..ebba05a2bc7f 100644
@@ -188,7 +188,10 @@ static int blk_validate_limits(struct queue_limits *lim)
         * bvec and lower layer bio splitting is supposed to handle the two

block/blk-settings.c static int blk_validate_limits(struct queue_limits *lim) · line 197

Quoted 10 lines
block/blk-settings.c +4 -1
         * correctly.
         */
-       if (!lim->virt_boundary_mask) {
+       if (lim->virt_boundary_mask) {
+               if (!lim->max_segment_size)
+                       lim->max_segment_size = UINT_MAX;
+       } else {
                /*
                 * The maximum segment size has an odd historic 64k default that
                 * drivers probably should override.  Just like the I/O size we

Thanks, that works for me (both with/without IOMMU support)!

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
                                -- Linus Torvalds