block: allow device to have both virt_boundary_mask and max segment size
Subsystems (3)
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.
--- block/blk-settings.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-)
block/blk-settings.c +6 -10
@@ -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
Quoted 52 lines · Ming Lei
When one stacking device is over one device with
virt_boundary_maskand another one with max segment size, the stacking device have both limits set. This way is allowed befored690cb8ae14b("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]>Signed-off-by Ming Lei <[email protected]>--- block/blk-settings.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-)block/blk-settings.c +6
-10@@ -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
Quoted 8 lines · Ming Lei
When one stacking device is over one device with
virt_boundary_maskand another one with max segment size, the stacking device have both limits set. This way is allowed befored690cb8ae14b("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
Quoted 6 lines · Ming Lei
When one stacking device is over one device with
virt_boundary_maskand another one with max segment size, the stacking device have both limits set. This way is allowed befored690cb8ae14b("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.
Quoted 6 lines · Christoph Hellwig
Quoted 5 lines · Ming Lei
When one stacking device is over one device with
virt_boundary_maskand another one with max segment size, the stacking device have both limits set. This way is allowed befored690cb8ae14b("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_maskwe 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_sizenor thevirtual_boundaryshould 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
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
d690cb8ae14bin 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.
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
d690cb8ae14bin 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.
Thanks,
Ming
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 fixf6970f83ef79("block: don't check if adjacent bvecs in one bio can be mergeable").However commit
f6970f83ef79only 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
09324d32d2a0mentioned 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.
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 fixf6970f83ef79("block: don't check if adjacent bvecs in one bio can be mergeable").However commit
f6970f83ef79only 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
09324d32d2a0mentioned 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
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
d690cb8ae14bin 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
Hi Ming,
Quoted 7 lines · Ming Lei
When one stacking device is over one device with
virt_boundary_maskand another one with max segment size, the stacking device have both limits set. This way is allowed befored690cb8ae14b("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]>Signed-off-by Ming Lei <[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>] 0x0Reverting 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
Quoted 85 lines · Geert Uytterhoeven
Hi Ming,
Quoted 7 lines · Ming Lei
When one stacking device is over one device with
virt_boundary_maskand another one with max segment size, the stacking device have both limits set. This way is allowed befored690cb8ae14b("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]>Signed-off-by Ming Lei <[email protected]>Thanks for your patch, which is now commit
b561ea56a26415bf("block:
allow device to have bothvirt_boundary_maskand max segment size") in v6.9-rc4.With
CONFIG_DMA_API_DEBUG_SG=yand 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
@@ -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
Geert Uytterhoeven
Tested-byHi 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_maskand another one with max segment size, the stacking device have both limits set. This way is allowed befored690cb8ae14b("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]>Signed-off-by Ming Lei <[email protected]>Thanks for your patch, which is now commit
b561ea56a26415bf("block:
allow device to have bothvirt_boundary_maskand max segment size") in v6.9-rc4.Quoted 7 lines
With
CONFIG_DMA_API_DEBUG_SG=yand IOMMU support enabled, this causes a warning on R-Car Gen3/Gen4 platforms:DMA-API:
renesas_sdhi_internal_dmacee160000.mmc: mapping sg segment longer than device claims to support [len=86016] [max=65536]
WARNING: CPU: 1 PID: 281 atkernel/dma/debug.c:1178debug_dma_map_sg+0x2ac/0x330Reverting this commit, or disabling IOMMU support fixes the issue.
Can you test the following patch?
block/blk-settings.c +0
-0@@ -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