Message ID | 20201201160709.31748-1-snitzer@redhat.com (mailing list archive) |
---|---|
State | Accepted, archived |
Delegated to: | Mike Snitzer |
Headers | show |
Series | [v2] block: use gcd() to fix chunk_sectors limit stacking | expand |
On Tue, Dec 1, 2020 at 11:07 AM Mike Snitzer <snitzer@redhat.com> wrote: > > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > reflect the most limited of all devices in the IO stack. > > Otherwise malformed IO may result. E.g.: prior to this fix, > ->chunk_sectors = lcm_not_zero(8, 128) would result in > blk_max_size_offset() splitting IO at 128 sectors rather than the > required more restrictive 8 sectors. > > And since commit 07d098e6bbad ("block: allow 'chunk_sectors' to be > non-power-of-2") care must be taken to properly stack chunk_sectors to > be compatible with the possibility that a non-power-of-2 chunk_sectors > may be stacked. This is why gcd() is used instead of reverting back > to using min_not_zero(). > > Fixes: 22ada802ede8 ("block: use lcm_not_zero() when stacking chunk_sectors") > Fixes: 07d098e6bbad ("block: allow 'chunk_sectors' to be non-power-of-2") > Cc: stable@vger.kernel.org > Reported-by: John Dorminy <jdorminy@redhat.com> > Reported-by: Bruce Johnston <bjohnsto@redhat.com> > Signed-off-by: Mike Snitzer <snitzer@redhat.com> > --- > block/blk-settings.c | 5 ++++- > 1 file changed, 4 insertions(+), 1 deletion(-) > > v2: use gcd(), instead of min_not_zero(), as suggested by John Dorminy > > diff --git a/block/blk-settings.c b/block/blk-settings.c > index 9741d1d83e98..659cdb8a07fe 100644 > --- a/block/blk-settings.c > +++ b/block/blk-settings.c > @@ -547,7 +547,10 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, > > t->io_min = max(t->io_min, b->io_min); > t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); > - t->chunk_sectors = lcm_not_zero(t->chunk_sectors, b->chunk_sectors); > + > + /* Set non-power-of-2 compatible chunk_sectors boundary */ > + if (b->chunk_sectors) > + t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); > > /* Physical block size a multiple of the logical block size? */ > if (t->physical_block_size & (t->logical_block_size - 1)) { > -- > 2.15.0 > Reviewed-by: John Dorminy <jdorminy@redhat.com> Thanks! -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On 12/1/20 9:07 AM, Mike Snitzer wrote: > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > reflect the most limited of all devices in the IO stack. > > Otherwise malformed IO may result. E.g.: prior to this fix, > ->chunk_sectors = lcm_not_zero(8, 128) would result in > blk_max_size_offset() splitting IO at 128 sectors rather than the > required more restrictive 8 sectors. > > And since commit 07d098e6bbad ("block: allow 'chunk_sectors' to be > non-power-of-2") care must be taken to properly stack chunk_sectors to > be compatible with the possibility that a non-power-of-2 chunk_sectors > may be stacked. This is why gcd() is used instead of reverting back > to using min_not_zero(). Applied for 5.10, thanks.
Mike, > And since commit 07d098e6bbad ("block: allow 'chunk_sectors' to be > non-power-of-2") care must be taken to properly stack chunk_sectors to > be compatible with the possibility that a non-power-of-2 chunk_sectors > may be stacked. This is why gcd() is used instead of reverting back > to using min_not_zero(). This approach looks fine to me. Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
What you've done here is fairly chaotic/disruptive: 1) you emailed a patch out that isn't needed or ideal, I dealt already staged a DM fix in linux-next for 5.10-rcX, see: https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=f28de262ddf09b635095bdeaf0e07ff507b3c41b 2) you replied to your patch and started referencing snippets of this other patch's header (now staged for 5.10-rcX via Jens' block tree): https://git.kernel.dk/cgit/linux-block/commit/?h=block-5.10&id=7e7986f9d3ba69a7375a41080a1f8c8012cb0923 - why not reply to _that_ patch in response something stated in it? 3) you started telling me, and others on these lists, why you think I used lcm_not_zero(). - reality is I wanted gcd() behavior, I just didn't reason through the math to know it.. it was a stupid oversight on my part. Not designed with precision. 4) Why not check with me before you craft a patch like others reported the problem to you? I know it logical to follow the chain of implications based on one commit and see where else there might be gaps but... it is strange to just pickup someone else's work like that. All just _seems_ weird and overdone. This isn't the kind of help I need. That said, I _do_ appreciate you looking at making blk IO polling work with bio-based (and DM's bio splitting in particular), but the lack of importance you put on DM's splitting below makes me concerned. On Tue, Dec 01 2020 at 10:57pm -0500, JeffleXu <jefflexu@linux.alibaba.com> wrote: > Actually in terms of this issue, I think the dilemma here is that, > @chunk_sectors of dm device is mainly from two source. > > One is that from the underlying devices, which is calculated into one > composed one in blk_stack_limits(). > > > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > > reflect the most limited of all devices in the IO stack. > > > > Otherwise malformed IO may result. E.g.: prior to this fix, > > ->chunk_sectors = lcm_not_zero(8, 128) would result in > > blk_max_size_offset() splitting IO at 128 sectors rather than the > > required more restrictive 8 sectors. > > For this part, technically I can't agree that 'chunk_sectors must > reflect the most limited of all devices in the IO stack'. Even if the dm > device advertises chunk_sectors of 128K when the limits of two > underlying devices are 8K and 128K, and thus splitting is not done in dm > device phase, the underlying devices will split by themselves. DM targets themselves _do_ require their own splitting. You cannot just assume all IO that passes through DM targets doesn't need to be properly sized on entry. Sure underlying devices will do their own splitting, but those splits are based on their requirements. DM targets have their own IO size limits too. Each layer needs to enforce and respect the constraints of its layer while also factoring in those of the underlying devices. > > @@ -547,7 +547,10 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, > > > > t->io_min = max(t->io_min, b->io_min); > > t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); > > - t->chunk_sectors = lcm_not_zero(t->chunk_sectors, b->chunk_sectors); > > + > > + /* Set non-power-of-2 compatible chunk_sectors boundary */ > > + if (b->chunk_sectors) > > + t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); > > This may introduces a regression. Regression relative to what? 5.10 was the regression point. The commit header you pasted into your reply clearly conveys that commit 22ada802ede8 caused the regression. It makes no sense to try to create some other regression point. You cannot have both from a single commit in the most recent Linux 5.10 release. And so I have no idea why you think that restoring DM's _required_ splitting constraints is somehow a regression. > Suppose the @chunk_sectors limits of > two underlying devices are 8K and 128K, then @chunk_sectors of dm device > is 8K after the fix. So even when a 128K sized bio is actually > redirecting to the underlying device with 128K @chunk_sectors limit, > this 128K sized bio will actually split into 16 split bios, each 8K > sized。Obviously it is excessive split. And I think this is actually why > lcm_not_zero(a, b) is used originally. No. Not excessive splitting, required splitting. And as I explained in point 2) above, avoiding "excessive splits" isn't why lcm_not_zero() was improperly used to stack chunk_sectors. Some DM targets really do require the IO be split on specific boundaries -- however inconvenient for the underlying layers that DM splitting might be. > The other one source is dm device itself. DM device can set @max_io_len > through ->io_hint(), and then set @chunk_sectors from @max_io_len. ti->max_io_len should always be set in the DM target's .ctr DM core takes care of applying max_io_len to chunk_sectors since 5.10, you should know that given your patch is meant to fix commit 882ec4e609c1 And for 5.11 I've staged a change to have it impose max_io_len in terms of ->max_sectors too, see: https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.11&id=41dcb8f21a86edbe409b2bef9bb1df4cb9d66858 One thing I clearly need to do moving forward is: always post my changes to dm-devel; just so someone like yourself can follow along via email client. I just assumed others who care about DM changes also track the linux-dm.git tree's branches. Clearly not the best assumption or practice on my part. > This part is actually where 'chunk_sectors must reflect the most limited > of all devices in the IO stack' is true, and we have to apply the most > strict limitation here. This is actually what the following patch does. There is a very consistent and deliberate way that device limits must be handled, sometimes I too have missteps but that doesn't change the fact that there is a deliberate evenness to how limits are stacked. blk_stack_limits() needs to be the authority on how these limits stack up. So all DM's limits stacking wraps calls to it. My fix, shared in point 1) above, restores that design pattern by _not_ having DM duplicate a subset of how blk_stack_limits() does its stacking. Mike > On 12/2/20 11:38 AM, Jeffle Xu wrote: > > As it said in commit 7e7986f9d3ba ("block: use gcd() to fix > > chunk_sectors limit stacking"), chunk_sectors should reflect the most > > limited of all devices in the IO stack. > > > > The previous commit only fixes block/blk-settings.c:blk_stack_limits(), > > while leaving dm.c:dm_calculate_queue_limits() unfixed. > > > > Fixes: 882ec4e609c1 ("dm table: stack 'chunk_sectors' limit to account for target-specific splitting") > > cc: stable@vger.kernel.org > > Reported-by: John Dorminy <jdorminy@redhat.com> > > Reported-by: Bruce Johnston <bjohnsto@redhat.com> > > Signed-off-by: Jeffle Xu <jefflexu@linux.alibaba.com> > > --- > > drivers/md/dm-table.c | 3 ++- > > 1 file changed, 2 insertions(+), 1 deletion(-) > > > > diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c > > index ce543b761be7..dcc0a27355d7 100644 > > --- a/drivers/md/dm-table.c > > +++ b/drivers/md/dm-table.c > > @@ -22,6 +22,7 @@ > > #include <linux/blk-mq.h> > > #include <linux/mount.h> > > #include <linux/dax.h> > > +#include <linux/gcd.h> > > > > #define DM_MSG_PREFIX "table" > > > > @@ -1457,7 +1458,7 @@ int dm_calculate_queue_limits(struct dm_table *table, > > > > /* Stack chunk_sectors if target-specific splitting is required */ > > if (ti->max_io_len) > > - ti_limits.chunk_sectors = lcm_not_zero(ti->max_io_len, > > + ti_limits.chunk_sectors = gcd(ti->max_io_len, > > ti_limits.chunk_sectors); > > /* Set I/O hints portion of queue limits */ > > if (ti->type->io_hints) > > > > -- > Thanks, > Jeffle > -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Wed, Dec 02 2020 at 12:03am -0500, Mike Snitzer <snitzer@redhat.com> wrote: > What you've done here is fairly chaotic/disruptive: > 1) you emailed a patch out that isn't needed or ideal, I dealt already > staged a DM fix in linux-next for 5.10-rcX, see: > https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=f28de262ddf09b635095bdeaf0e07ff507b3c41b > 2) you replied to your patch and started referencing snippets of this > other patch's header (now staged for 5.10-rcX via Jens' block tree): > https://git.kernel.dk/cgit/linux-block/commit/?h=block-5.10&id=7e7986f9d3ba69a7375a41080a1f8c8012cb0923 > - why not reply to _that_ patch in response something stated in it? I now see you did reply to the original v2 patch: https://www.redhat.com/archives/dm-devel/2020-December/msg00006.html but you changed the Subject to have a "dm" prefix for some reason. Strange but OK.. though it got really weird when you cut-and-paste your other DM patch in reply at the bottom of your email. If you find yourself cross referencing emails and cutting and pasting like that, you probably shouldn't. Makes it chaotic for others to follow along. Thanks, Mike -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On 12/2/20 1:03 PM, Mike Snitzer wrote: > What you've done here is fairly chaotic/disruptive: > 1) you emailed a patch out that isn't needed or ideal, I dealt already > staged a DM fix in linux-next for 5.10-rcX, see: > https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=f28de262ddf09b635095bdeaf0e07ff507b3c41b Fine. I indeed didn't follow linux-dm.git. Sorry it's my fault. > 2) you replied to your patch and started referencing snippets of this > other patch's header (now staged for 5.10-rcX via Jens' block tree): > https://git.kernel.dk/cgit/linux-block/commit/?h=block-5.10&id=7e7986f9d3ba69a7375a41080a1f8c8012cb0923 > - why not reply to _that_ patch in response something stated in it? I just want to send in one email, which seems obviously improper. > 3) you started telling me, and others on these lists, why you think I > used lcm_not_zero(). > - reality is I wanted gcd() behavior, I just didn't reason through > the math to know it.. it was a stupid oversight on my part. Not > designed with precision. > 4) Why not check with me before you craft a patch like others reported > the problem to you? I know it logical to follow the chain of > implications based on one commit and see where else there might be > gaps but... it is strange to just pickup someone else's work like > that. > > All just _seems_ weird and overdone. This isn't the kind of help I > need. That said, I _do_ appreciate you looking at making blk IO polling > work with bio-based (and DM's bio splitting in particular), but the > lack of importance you put on DM's splitting below makes me concerned. > Though I have noticed this series discussion yesterday, I didn't read it thoroughly until today. When I noticed there may be one remained issue (I know it is not now), the patch, that is commit 22ada802ede8 has been adopt by Jens, so I send out a patch. If there's no Jens' reply, I will just reply under your mail. That's it. I have to admit that I get excited when I realized that I could send a patch. But it seems improper and more likely a misunderstanding. I apologize if I did wrong. > On Tue, Dec 01 2020 at 10:57pm -0500, > JeffleXu <jefflexu@linux.alibaba.com> wrote: > >> Actually in terms of this issue, I think the dilemma here is that, >> @chunk_sectors of dm device is mainly from two source. >> >> One is that from the underlying devices, which is calculated into one >> composed one in blk_stack_limits(). >> >>> commit 22ada802ede8 ("block: use lcm_not_zero() when stacking >>> chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must >>> reflect the most limited of all devices in the IO stack. >>> >>> Otherwise malformed IO may result. E.g.: prior to this fix, >>> ->chunk_sectors = lcm_not_zero(8, 128) would result in >>> blk_max_size_offset() splitting IO at 128 sectors rather than the >>> required more restrictive 8 sectors. >> >> For this part, technically I can't agree that 'chunk_sectors must >> reflect the most limited of all devices in the IO stack'. Even if the dm >> device advertises chunk_sectors of 128K when the limits of two >> underlying devices are 8K and 128K, and thus splitting is not done in dm >> device phase, the underlying devices will split by themselves. > > DM targets themselves _do_ require their own splitting. You cannot just > assume all IO that passes through DM targets doesn't need to be properly > sized on entry. Sure underlying devices will do their own splitting, > but those splits are based on their requirements. DM targets have their > own IO size limits too. Each layer needs to enforce and respect the > constraints of its layer while also factoring in those of the underlying > devices. > Got it. Thanks. >>> @@ -547,7 +547,10 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, >>> >>> t->io_min = max(t->io_min, b->io_min); >>> t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); >>> - t->chunk_sectors = lcm_not_zero(t->chunk_sectors, b->chunk_sectors); >>> + >>> + /* Set non-power-of-2 compatible chunk_sectors boundary */ >>> + if (b->chunk_sectors) >>> + t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); >> >> This may introduces a regression. > > Regression relative to what? 5.10 was the regression point. The commit > header you pasted into your reply clearly conveys that commit > 22ada802ede8 caused the regression. It makes no sense to try to create > some other regression point. You cannot have both from a single commit > in the most recent Linux 5.10 release. > > And so I have no idea why you think that restoring DM's _required_ > splitting constraints is somehow a regression. I mistakenly missed that all these changes are introduced in v5.10. Sorry for that. > >> Suppose the @chunk_sectors limits of >> two underlying devices are 8K and 128K, then @chunk_sectors of dm device >> is 8K after the fix. So even when a 128K sized bio is actually >> redirecting to the underlying device with 128K @chunk_sectors limit, >> this 128K sized bio will actually split into 16 split bios, each 8K >> sized。Obviously it is excessive split. And I think this is actually why >> lcm_not_zero(a, b) is used originally. > > No. Not excessive splitting, required splitting. And as I explained in > point 2) above, avoiding "excessive splits" isn't why lcm_not_zero() was > improperly used to stack chunk_sectors. This is indeed a difference between 5.9 and 5.10. In 5.10 there may be more small split bios, since a smaller chunk_sectors is applied for the underlying device with larger chunk_sectors (that is, the underlying device with 128K chunk_sectors). I can not say that more small split bios will cause worse performance since I have not tested it. > > Some DM targets really do require the IO be split on specific boundaries > -- however inconvenient for the underlying layers that DM splitting > might be. > >> The other one source is dm device itself. DM device can set @max_io_len >> through ->io_hint(), and then set @chunk_sectors from @max_io_len. > > ti->max_io_len should always be set in the DM target's .ctr > Yes I misremember it. > DM core takes care of applying max_io_len to chunk_sectors since 5.10, > you should know that given your patch is meant to fix commit > 882ec4e609c1 > > And for 5.11 I've staged a change to have it impose max_io_len in terms > of ->max_sectors too, see: > https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.11&id=41dcb8f21a86edbe409b2bef9bb1df4cb9d66858 > Thanks. > One thing I clearly need to do moving forward is: always post my changes > to dm-devel; just so someone like yourself can follow along via email > client. I just assumed others who care about DM changes also track the > linux-dm.git tree's branches. Clearly not the best assumption or > practice on my part. I used Linus' tree as my code base, which seems improper... > >> This part is actually where 'chunk_sectors must reflect the most limited >> of all devices in the IO stack' is true, and we have to apply the most >> strict limitation here. This is actually what the following patch does. > > There is a very consistent and deliberate way that device limits must be > handled, sometimes I too have missteps but that doesn't change the fact > that there is a deliberate evenness to how limits are stacked. > blk_stack_limits() needs to be the authority on how these limits stack > up. So all DM's limits stacking wraps calls to it. My fix, shared in > point 1) above, restores that design pattern by _not_ having DM > duplicate a subset of how blk_stack_limits() does its stacking. > > Mike
On 12/2/20 1:14 PM, Mike Snitzer wrote: > On Wed, Dec 02 2020 at 12:03am -0500, > Mike Snitzer <snitzer@redhat.com> wrote: > >> What you've done here is fairly chaotic/disruptive: >> 1) you emailed a patch out that isn't needed or ideal, I dealt already >> staged a DM fix in linux-next for 5.10-rcX, see: >> https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=f28de262ddf09b635095bdeaf0e07ff507b3c41b >> 2) you replied to your patch and started referencing snippets of this >> other patch's header (now staged for 5.10-rcX via Jens' block tree): >> https://git.kernel.dk/cgit/linux-block/commit/?h=block-5.10&id=7e7986f9d3ba69a7375a41080a1f8c8012cb0923 >> - why not reply to _that_ patch in response something stated in it? > > I now see you did reply to the original v2 patch: > https://www.redhat.com/archives/dm-devel/2020-December/msg00006.html > > but you changed the Subject to have a "dm" prefix for some reason. In my original purpose, this is a new patch, 'dm: XXXXXXXX'. This patch should coexist with your patch 'block: XXXXXX'. Can I say that it's totally a mistake ;) > Strange but OK.. though it got really weird when you cut-and-paste your > other DM patch in reply at the bottom of your email. If you find > yourself cross referencing emails and cutting and pasting like that, you > probably shouldn't. Makes it chaotic for others to follow along. > > Thanks, > Mike >
On 12/2/20 2:31 PM, JeffleXu wrote: > > > On 12/2/20 1:14 PM, Mike Snitzer wrote: >> On Wed, Dec 02 2020 at 12:03am -0500, >> Mike Snitzer <snitzer@redhat.com> wrote: >> >>> What you've done here is fairly chaotic/disruptive: >>> 1) you emailed a patch out that isn't needed or ideal, I dealt already >>> staged a DM fix in linux-next for 5.10-rcX, see: >>> https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=f28de262ddf09b635095bdeaf0e07ff507b3c41b >>> 2) you replied to your patch and started referencing snippets of this >>> other patch's header (now staged for 5.10-rcX via Jens' block tree): >>> https://git.kernel.dk/cgit/linux-block/commit/?h=block-5.10&id=7e7986f9d3ba69a7375a41080a1f8c8012cb0923 >>> - why not reply to _that_ patch in response something stated in it? >> >> I now see you did reply to the original v2 patch: >> https://www.redhat.com/archives/dm-devel/2020-December/msg00006.html >> >> but you changed the Subject to have a "dm" prefix for some reason. > > In my original purpose, this is a new patch, 'dm: XXXXXXXX'. This patch > should coexist with your patch 'block: XXXXXX'. > > Can I say that it's totally a mistake ;) s/mistake/misunderstanding > > >> Strange but OK.. though it got really weird when you cut-and-paste your >> other DM patch in reply at the bottom of your email. If you find >> yourself cross referencing emails and cutting and pasting like that, you >> probably shouldn't. Makes it chaotic for others to follow along. >> >> Thanks, >> Mike >> >
On 12/2/20 1:03 PM, Mike Snitzer wrote: > What you've done here is fairly chaotic/disruptive: > 1) you emailed a patch out that isn't needed or ideal, I dealt already > staged a DM fix in linux-next for 5.10-rcX, see: > https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=f28de262ddf09b635095bdeaf0e07ff507b3c41b Then ti->type->io_hints() is still bypassed when type->iterate_devices() not defined?
On Wed, Dec 02 2020 at 2:10am -0500, JeffleXu <jefflexu@linux.alibaba.com> wrote: > > > On 12/2/20 1:03 PM, Mike Snitzer wrote: > > What you've done here is fairly chaotic/disruptive: > > 1) you emailed a patch out that isn't needed or ideal, I dealt already > > staged a DM fix in linux-next for 5.10-rcX, see: > > https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=f28de262ddf09b635095bdeaf0e07ff507b3c41b > > Then ti->type->io_hints() is still bypassed when type->iterate_devices() > not defined? Yes, the stacking of limits really is tightly coupled to device-based influence. Hypothetically some DM target that doesn't remap to any data devices may want to override limits... in practice there isn't a need for this. If that changes we can take action to accommodate it.. but I'm definitely not interested in modifying DM core in this area when there isn't a demonstrated need. Mike -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On 12/2/20 11:11 PM, Mike Snitzer wrote: > On Wed, Dec 02 2020 at 2:10am -0500, > JeffleXu <jefflexu@linux.alibaba.com> wrote: > >> >> >> On 12/2/20 1:03 PM, Mike Snitzer wrote: >>> What you've done here is fairly chaotic/disruptive: >>> 1) you emailed a patch out that isn't needed or ideal, I dealt already >>> staged a DM fix in linux-next for 5.10-rcX, see: >>> https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=f28de262ddf09b635095bdeaf0e07ff507b3c41b >> >> Then ti->type->io_hints() is still bypassed when type->iterate_devices() >> not defined? > > Yes, the stacking of limits really is tightly coupled to device-based > influence. Hypothetically some DM target that doesn't remap to any data > devices may want to override limits... in practice there isn't a need > for this. If that changes we can take action to accommodate it.. but I'm > definitely not interested in modifying DM core in this area when there > isn't a demonstrated need. Thanks.
On Tue, Dec 01, 2020 at 11:07:09AM -0500, Mike Snitzer wrote: > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > reflect the most limited of all devices in the IO stack. > > Otherwise malformed IO may result. E.g.: prior to this fix, > ->chunk_sectors = lcm_not_zero(8, 128) would result in > blk_max_size_offset() splitting IO at 128 sectors rather than the > required more restrictive 8 sectors. What is the user-visible result of splitting IO at 128 sectors? I understand it isn't related with correctness, because the underlying queue can split by its own chunk_sectors limit further. So is the issue too many further-splitting on queue with chunk_sectors 8? then CPU utilization is increased? Or other issue? > > And since commit 07d098e6bbad ("block: allow 'chunk_sectors' to be > non-power-of-2") care must be taken to properly stack chunk_sectors to > be compatible with the possibility that a non-power-of-2 chunk_sectors > may be stacked. This is why gcd() is used instead of reverting back > to using min_not_zero(). I guess gcd() won't be better because gcd(a,b) is <= max(a, b), so bio size is decreased much with gcd(a, b), and IO performance should be affected. Maybe worse than min_not_zero(a, b) which is often > gcd(a, b). Thanks, Ming -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Wed, Dec 02 2020 at 10:26pm -0500, Ming Lei <ming.lei@redhat.com> wrote: > On Tue, Dec 01, 2020 at 11:07:09AM -0500, Mike Snitzer wrote: > > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > > reflect the most limited of all devices in the IO stack. > > > > Otherwise malformed IO may result. E.g.: prior to this fix, > > ->chunk_sectors = lcm_not_zero(8, 128) would result in > > blk_max_size_offset() splitting IO at 128 sectors rather than the > > required more restrictive 8 sectors. > > What is the user-visible result of splitting IO at 128 sectors? The VDO dm target fails because it requires IO it receives to be split as it advertised (8 sectors). > I understand it isn't related with correctness, because the underlying > queue can split by its own chunk_sectors limit further. So is the issue > too many further-splitting on queue with chunk_sectors 8? then CPU > utilization is increased? Or other issue? No, this is all about correctness. Seems you're confining the definition of the possible stacking so that the top-level device isn't allowed to have its own hard requirements on IO sizes it sends to its internal implementation. Just because the underlying device can split further doesn't mean that the top-level virtual driver can service larger IO sizes (not if the chunk_sectors stacking throws away the hint the virtual driver provided because it used lcm_not_zero). > > And since commit 07d098e6bbad ("block: allow 'chunk_sectors' to be > > non-power-of-2") care must be taken to properly stack chunk_sectors to > > be compatible with the possibility that a non-power-of-2 chunk_sectors > > may be stacked. This is why gcd() is used instead of reverting back > > to using min_not_zero(). > > I guess gcd() won't be better because gcd(a,b) is <= max(a, b), so bio > size is decreased much with gcd(a, b), and IO performance should be affected. > Maybe worse than min_not_zero(a, b) which is often > gcd(a, b). Doesn't matter, it is about correctness. We cannot stack up a chunk_sectors that violates requirements of a given layer. Mike -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: > On Wed, Dec 02 2020 at 10:26pm -0500, > Ming Lei <ming.lei@redhat.com> wrote: > > > I understand it isn't related with correctness, because the underlying > > queue can split by its own chunk_sectors limit further. So is the issue > > too many further-splitting on queue with chunk_sectors 8? then CPU > > utilization is increased? Or other issue? > > No, this is all about correctness. > > Seems you're confining the definition of the possible stacking so that > the top-level device isn't allowed to have its own hard requirements on > IO sizes it sends to its internal implementation. Just because the > underlying device can split further doesn't mean that the top-level > virtual driver can service larger IO sizes (not if the chunk_sectors > stacking throws away the hint the virtual driver provided because it > used lcm_not_zero). I may be missing something obvious here, but if the lower layers split to their desired boundary already, why does this limit need to stack? Won't it also work if each layer sets their desired chunk_sectors without considering their lower layers? The commit that initially stacked chunk_sectors doesn't provide any explanation. -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Thu, Dec 03 2020 at 11:27am -0500, Keith Busch <kbusch@kernel.org> wrote: > On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: > > On Wed, Dec 02 2020 at 10:26pm -0500, > > Ming Lei <ming.lei@redhat.com> wrote: > > > > > I understand it isn't related with correctness, because the underlying > > > queue can split by its own chunk_sectors limit further. So is the issue > > > too many further-splitting on queue with chunk_sectors 8? then CPU > > > utilization is increased? Or other issue? > > > > No, this is all about correctness. > > > > Seems you're confining the definition of the possible stacking so that > > the top-level device isn't allowed to have its own hard requirements on > > IO sizes it sends to its internal implementation. Just because the > > underlying device can split further doesn't mean that the top-level > > virtual driver can service larger IO sizes (not if the chunk_sectors > > stacking throws away the hint the virtual driver provided because it > > used lcm_not_zero). > > I may be missing something obvious here, but if the lower layers split > to their desired boundary already, why does this limit need to stack? The problematic scenario is when the topmost layer, or layers, are the more constrained. _That_ is why the top-level's chunk_sectors limit cannot be relaxed. For example (in extreme where chunk_sectors is stacked via gcd): dm VDO target (chunk_sectors=4K) on dm-thin (ideally chunk_sectors=1280K, reality chunk_sectors=128K) on 10+2 RAID6 (chunk_sectors=128K, io_opt=1280K) on raid members (chunk_sectors=0) Results in the following bottom up blk_stack_limits() stacking: gcd(128K, 0) = 128K -> but MD just sets chunk_sectors, no stacking is done afaik gcd(1280K, 128K) = 128K -> this one hurts dm-thin, needless splitting gcd(4K, 128K) = 4K -> vdo _must_ receive 4K IOs, hurts but "this is the way" ;) So this is one extreme that shows stacking chunk_sectors is _not_ helpful (if the resulting chunk_sectors were actually used as basis for splitting). Better for each layer to just impose its own chunk_sectors without concern for the layers below. Think I'd be fine with block core removing the chunk_sectors stacking from blk_stack_limits()... (and as you see below, I've been forced to revert to _not_ using stacked chunk_sectors based splitting in DM) > Won't it also work if each layer sets their desired chunk_sectors > without considering their lower layers? The commit that initially > stacked chunk_sectors doesn't provide any explanation. Yes, I think it would work. The current stacking doesn't have the luxury of knowing which layer a blk_stack_limits() maps too. BUT within a layer chunk_sectors really does need to be compatible/symbiotic. So it is unfortunately all or nothing as you build up the stack. And that all-or-nothing stacking of chunk_sectors is why I've now (just last night, based on further review by jdorminy) had to punt on using stacked chunk_sectors and revert DM back to doing its own fine-grained (and varied) splitting on a per DM target basis, see: https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=6bb38bcc33bf3093c08bd1b71e4f20c82bb60dd1 Kind of depressing that I went so far down the rabbit hole, of wanting to lean on block core, that I lost sight of an important "tenet of DM": + * Does the target need to split IO even further? + * - varied (per target) IO splitting is a tenet of DM; this + * explains why stacked chunk_sectors based splitting via + * blk_max_size_offset() isn't possible here. And it is because of this that DM is forced to lean on human creation of an optimal IO stack.. which is prone to human error when a particular thinp "blocksize" is selected, etc. Mike -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: > On Wed, Dec 02 2020 at 10:26pm -0500, > Ming Lei <ming.lei@redhat.com> wrote: > > > On Tue, Dec 01, 2020 at 11:07:09AM -0500, Mike Snitzer wrote: > > > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > > > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > > > reflect the most limited of all devices in the IO stack. > > > > > > Otherwise malformed IO may result. E.g.: prior to this fix, > > > ->chunk_sectors = lcm_not_zero(8, 128) would result in > > > blk_max_size_offset() splitting IO at 128 sectors rather than the > > > required more restrictive 8 sectors. > > > > What is the user-visible result of splitting IO at 128 sectors? > > The VDO dm target fails because it requires IO it receives to be split > as it advertised (8 sectors). OK, looks VDO's chunk_sector limit is one hard constraint, even though it is one DM device, so I guess you are talking about DM over VDO? Another reason should be that VDO doesn't use blk_queue_split(), otherwise it won't be a trouble, right? Frankly speaking, if the stacking driver/device has its own hard queue limit like normal hardware drive, the driver should be responsible for the splitting. > > > I understand it isn't related with correctness, because the underlying > > queue can split by its own chunk_sectors limit further. So is the issue > > too many further-splitting on queue with chunk_sectors 8? then CPU > > utilization is increased? Or other issue? > > No, this is all about correctness. > > Seems you're confining the definition of the possible stacking so that > the top-level device isn't allowed to have its own hard requirements on I just don't know this story, thanks for your clarification. As I mentioned above, if the stacking driver has its own hard queue limit, it should be the driver's responsibility to respect it via blk_queue_split() or whatever. Thanks, Ming -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Thu, Dec 03, 2020 at 08:27:38AM -0800, Keith Busch wrote: > On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: > > On Wed, Dec 02 2020 at 10:26pm -0500, > > Ming Lei <ming.lei@redhat.com> wrote: > > > > > I understand it isn't related with correctness, because the underlying > > > queue can split by its own chunk_sectors limit further. So is the issue > > > too many further-splitting on queue with chunk_sectors 8? then CPU > > > utilization is increased? Or other issue? > > > > No, this is all about correctness. > > > > Seems you're confining the definition of the possible stacking so that > > the top-level device isn't allowed to have its own hard requirements on > > IO sizes it sends to its internal implementation. Just because the > > underlying device can split further doesn't mean that the top-level > > virtual driver can service larger IO sizes (not if the chunk_sectors > > stacking throws away the hint the virtual driver provided because it > > used lcm_not_zero). > > I may be missing something obvious here, but if the lower layers split > to their desired boundary already, why does this limit need to stack? > Won't it also work if each layer sets their desired chunk_sectors > without considering their lower layers? The commit that initially > stacked chunk_sectors doesn't provide any explanation. There could be several reasons: 1) some limits have to be stacking, such as logical block size, because lower layering may not handle un-aligned IO 2) performance reason, if every limits are stacked on topmost layer, in theory IO just needs to be splitted in top layer, and not need to be splitted further from all lower layer at all. But there should be exceptions in unusual case, such as, lowering queue's limit changed after the stacking limits are setup. 3) history reason, bio splitting is much younger than stacking queue limits. Maybe others? Thanks, Ming -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Thu, Dec 03 2020 at 8:12pm -0500, Ming Lei <ming.lei@redhat.com> wrote: > On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: > > On Wed, Dec 02 2020 at 10:26pm -0500, > > Ming Lei <ming.lei@redhat.com> wrote: > > > > > On Tue, Dec 01, 2020 at 11:07:09AM -0500, Mike Snitzer wrote: > > > > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > > > > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > > > > reflect the most limited of all devices in the IO stack. > > > > > > > > Otherwise malformed IO may result. E.g.: prior to this fix, > > > > ->chunk_sectors = lcm_not_zero(8, 128) would result in > > > > blk_max_size_offset() splitting IO at 128 sectors rather than the > > > > required more restrictive 8 sectors. > > > > > > What is the user-visible result of splitting IO at 128 sectors? > > > > The VDO dm target fails because it requires IO it receives to be split > > as it advertised (8 sectors). > > OK, looks VDO's chunk_sector limit is one hard constraint, even though it > is one DM device, so I guess you are talking about DM over VDO? > > Another reason should be that VDO doesn't use blk_queue_split(), otherwise it > won't be a trouble, right? > > Frankly speaking, if the stacking driver/device has its own hard queue limit > like normal hardware drive, the driver should be responsible for the splitting. DM core does the splitting for VDO (just like any other DM target). In 5.9 I updated DM to use chunk_sectors, use blk_stack_limits() stacking of it, and also use blk_max_size_offset(). But all that block core code has shown itself to be too rigid for DM. I tried to force the issue by stacking DM targets' ti->max_io_len with chunk_sectors. But really I'd need to be able to pass in the per-target max_io_len to blk_max_size_offset() to salvage using it. Stacking chunk_sectors seems ill-conceived. One size-fits-all splitting is too rigid. > > > I understand it isn't related with correctness, because the underlying > > > queue can split by its own chunk_sectors limit further. So is the issue > > > too many further-splitting on queue with chunk_sectors 8? then CPU > > > utilization is increased? Or other issue? > > > > No, this is all about correctness. > > > > Seems you're confining the definition of the possible stacking so that > > the top-level device isn't allowed to have its own hard requirements on > > I just don't know this story, thanks for your clarification. > > As I mentioned above, if the stacking driver has its own hard queue > limit, it should be the driver's responsibility to respect it via > blk_queue_split() or whatever. Again, DM does its own splitting... that aspect of it isn't an issue. The problem is the basis for splitting cannot be the stacked up chunk_sectors. Mike -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Thu, Dec 03 2020 at 8:45pm -0500, Ming Lei <ming.lei@redhat.com> wrote: > On Thu, Dec 03, 2020 at 08:27:38AM -0800, Keith Busch wrote: > > On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: > > > On Wed, Dec 02 2020 at 10:26pm -0500, > > > Ming Lei <ming.lei@redhat.com> wrote: > > > > > > > I understand it isn't related with correctness, because the underlying > > > > queue can split by its own chunk_sectors limit further. So is the issue > > > > too many further-splitting on queue with chunk_sectors 8? then CPU > > > > utilization is increased? Or other issue? > > > > > > No, this is all about correctness. > > > > > > Seems you're confining the definition of the possible stacking so that > > > the top-level device isn't allowed to have its own hard requirements on > > > IO sizes it sends to its internal implementation. Just because the > > > underlying device can split further doesn't mean that the top-level > > > virtual driver can service larger IO sizes (not if the chunk_sectors > > > stacking throws away the hint the virtual driver provided because it > > > used lcm_not_zero). > > > > I may be missing something obvious here, but if the lower layers split > > to their desired boundary already, why does this limit need to stack? > > Won't it also work if each layer sets their desired chunk_sectors > > without considering their lower layers? The commit that initially > > stacked chunk_sectors doesn't provide any explanation. > > There could be several reasons: > > 1) some limits have to be stacking, such as logical block size, because > lower layering may not handle un-aligned IO > > 2) performance reason, if every limits are stacked on topmost layer, in > theory IO just needs to be splitted in top layer, and not need to be > splitted further from all lower layer at all. But there should be exceptions > in unusual case, such as, lowering queue's limit changed after the stacking > limits are setup. > > 3) history reason, bio splitting is much younger than stacking queue > limits. > > Maybe others? Hannes didn't actually justify why he added chunk_sectors to blk_stack_limits: commit 987b3b26eb7b19960160505faf9b2f50ae77e14d Author: Hannes Reinecke <hare@suse.de> Date: Tue Oct 18 15:40:31 2016 +0900 block: update chunk_sectors in blk_stack_limits() Signed-off-by: Hannes Reinecke <hare@suse.com> Signed-off-by: Damien Le Moal <damien.lemoal@hgst.com> Reviewed-by: Christoph Hellwig <hch@lst.de> Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com> Reviewed-by: Shaun Tancheff <shaun.tancheff@seagate.com> Tested-by: Shaun Tancheff <shaun.tancheff@seagate.com> Signed-off-by: Jens Axboe <axboe@fb.com> Likely felt it needed for zoned or NVMe devices.. dunno. But given how we now have a model where block core, or DM core, will split as needed I don't think normalizing chunk_sectors (to the degree full use of blk_stack_limits does) and than using it as basis for splitting makes a lot of sense. Mike -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On Thu, Dec 03, 2020 at 09:03:43PM -0500, Mike Snitzer wrote: > On Thu, Dec 03 2020 at 8:12pm -0500, > Ming Lei <ming.lei@redhat.com> wrote: > > > On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: > > > On Wed, Dec 02 2020 at 10:26pm -0500, > > > Ming Lei <ming.lei@redhat.com> wrote: > > > > > > > On Tue, Dec 01, 2020 at 11:07:09AM -0500, Mike Snitzer wrote: > > > > > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > > > > > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > > > > > reflect the most limited of all devices in the IO stack. > > > > > > > > > > Otherwise malformed IO may result. E.g.: prior to this fix, > > > > > ->chunk_sectors = lcm_not_zero(8, 128) would result in > > > > > blk_max_size_offset() splitting IO at 128 sectors rather than the > > > > > required more restrictive 8 sectors. > > > > > > > > What is the user-visible result of splitting IO at 128 sectors? > > > > > > The VDO dm target fails because it requires IO it receives to be split > > > as it advertised (8 sectors). > > > > OK, looks VDO's chunk_sector limit is one hard constraint, even though it > > is one DM device, so I guess you are talking about DM over VDO? > > > > Another reason should be that VDO doesn't use blk_queue_split(), otherwise it > > won't be a trouble, right? > > > > Frankly speaking, if the stacking driver/device has its own hard queue limit > > like normal hardware drive, the driver should be responsible for the splitting. > > DM core does the splitting for VDO (just like any other DM target). > In 5.9 I updated DM to use chunk_sectors, use blk_stack_limits() > stacking of it, and also use blk_max_size_offset(). > > But all that block core code has shown itself to be too rigid for DM. I > tried to force the issue by stacking DM targets' ti->max_io_len with > chunk_sectors. But really I'd need to be able to pass in the per-target > max_io_len to blk_max_size_offset() to salvage using it. > > Stacking chunk_sectors seems ill-conceived. One size-fits-all splitting > is too rigid. DM/VDO knows exactly it is one hard chunk_sectors limit, and DM shouldn't play the stacking trick on VDO's chunk_sectors limit, should it? Thanks, Ming -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
On 2020/12/04 11:11, Mike Snitzer wrote: > On Thu, Dec 03 2020 at 8:45pm -0500, > Ming Lei <ming.lei@redhat.com> wrote: > >> On Thu, Dec 03, 2020 at 08:27:38AM -0800, Keith Busch wrote: >>> On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: >>>> On Wed, Dec 02 2020 at 10:26pm -0500, >>>> Ming Lei <ming.lei@redhat.com> wrote: >>>> >>>>> I understand it isn't related with correctness, because the underlying >>>>> queue can split by its own chunk_sectors limit further. So is the issue >>>>> too many further-splitting on queue with chunk_sectors 8? then CPU >>>>> utilization is increased? Or other issue? >>>> >>>> No, this is all about correctness. >>>> >>>> Seems you're confining the definition of the possible stacking so that >>>> the top-level device isn't allowed to have its own hard requirements on >>>> IO sizes it sends to its internal implementation. Just because the >>>> underlying device can split further doesn't mean that the top-level >>>> virtual driver can service larger IO sizes (not if the chunk_sectors >>>> stacking throws away the hint the virtual driver provided because it >>>> used lcm_not_zero). >>> >>> I may be missing something obvious here, but if the lower layers split >>> to their desired boundary already, why does this limit need to stack? >>> Won't it also work if each layer sets their desired chunk_sectors >>> without considering their lower layers? The commit that initially >>> stacked chunk_sectors doesn't provide any explanation. >> >> There could be several reasons: >> >> 1) some limits have to be stacking, such as logical block size, because >> lower layering may not handle un-aligned IO >> >> 2) performance reason, if every limits are stacked on topmost layer, in >> theory IO just needs to be splitted in top layer, and not need to be >> splitted further from all lower layer at all. But there should be exceptions >> in unusual case, such as, lowering queue's limit changed after the stacking >> limits are setup. >> >> 3) history reason, bio splitting is much younger than stacking queue >> limits. >> >> Maybe others? > > Hannes didn't actually justify why he added chunk_sectors to > blk_stack_limits: > > commit 987b3b26eb7b19960160505faf9b2f50ae77e14d > Author: Hannes Reinecke <hare@suse.de> > Date: Tue Oct 18 15:40:31 2016 +0900 > > block: update chunk_sectors in blk_stack_limits() > > Signed-off-by: Hannes Reinecke <hare@suse.com> > Signed-off-by: Damien Le Moal <damien.lemoal@hgst.com> > Reviewed-by: Christoph Hellwig <hch@lst.de> > Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com> > Reviewed-by: Shaun Tancheff <shaun.tancheff@seagate.com> > Tested-by: Shaun Tancheff <shaun.tancheff@seagate.com> > Signed-off-by: Jens Axboe <axboe@fb.com> > > Likely felt it needed for zoned or NVMe devices.. dunno. For zoned drives, chunk_sectors indicates the zone size so the stacking propagates that value to the upper layer, if said layer is also zoned. If it is not zoned (e.g. dm-zoned device), chunk_sectors can actually be 0: it would be the responsibility of that layer to not issue BIO that cross zone boundaries to the lower zoned layer. Since all of this depends on the upper layer zoned model, removing the stacking of chunk_sectors would be fine, as long as the target initialization code sets it based on the drive model being exposed. E.g.: * dm-linear on zoned dev will be zoned with the same zone size * dm-zoned on zoned dev is not zoned, so chunk_sectors can be 0 * dm-linear on RAID volume can have chunk_sectors set to the underlying volume chunk_sectors (stripe size), if dm-linear is aligned to stripes. * etc. > But given how we now have a model where block core, or DM core, will > split as needed I don't think normalizing chunk_sectors (to the degree > full use of blk_stack_limits does) and than using it as basis for > splitting makes a lot of sense. For zoned dev, I agree. DM-core can set chunk_sectors for the DM device based on its zone model for DM driver that supports zones (dm-linear, dm-flakey and dm-zoned).
On Thu, Dec 03 2020 at 10:59pm -0500, Ming Lei <ming.lei@redhat.com> wrote: > On Thu, Dec 03, 2020 at 09:03:43PM -0500, Mike Snitzer wrote: > > On Thu, Dec 03 2020 at 8:12pm -0500, > > Ming Lei <ming.lei@redhat.com> wrote: > > > > > On Thu, Dec 03, 2020 at 09:33:59AM -0500, Mike Snitzer wrote: > > > > On Wed, Dec 02 2020 at 10:26pm -0500, > > > > Ming Lei <ming.lei@redhat.com> wrote: > > > > > > > > > On Tue, Dec 01, 2020 at 11:07:09AM -0500, Mike Snitzer wrote: > > > > > > commit 22ada802ede8 ("block: use lcm_not_zero() when stacking > > > > > > chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must > > > > > > reflect the most limited of all devices in the IO stack. > > > > > > > > > > > > Otherwise malformed IO may result. E.g.: prior to this fix, > > > > > > ->chunk_sectors = lcm_not_zero(8, 128) would result in > > > > > > blk_max_size_offset() splitting IO at 128 sectors rather than the > > > > > > required more restrictive 8 sectors. > > > > > > > > > > What is the user-visible result of splitting IO at 128 sectors? > > > > > > > > The VDO dm target fails because it requires IO it receives to be split > > > > as it advertised (8 sectors). > > > > > > OK, looks VDO's chunk_sector limit is one hard constraint, even though it > > > is one DM device, so I guess you are talking about DM over VDO? > > > > > > Another reason should be that VDO doesn't use blk_queue_split(), otherwise it > > > won't be a trouble, right? > > > > > > Frankly speaking, if the stacking driver/device has its own hard queue limit > > > like normal hardware drive, the driver should be responsible for the splitting. > > > > DM core does the splitting for VDO (just like any other DM target). > > In 5.9 I updated DM to use chunk_sectors, use blk_stack_limits() > > stacking of it, and also use blk_max_size_offset(). > > > > But all that block core code has shown itself to be too rigid for DM. I > > tried to force the issue by stacking DM targets' ti->max_io_len with > > chunk_sectors. But really I'd need to be able to pass in the per-target > > max_io_len to blk_max_size_offset() to salvage using it. > > > > Stacking chunk_sectors seems ill-conceived. One size-fits-all splitting > > is too rigid. > > DM/VDO knows exactly it is one hard chunk_sectors limit, and DM shouldn't play > the stacking trick on VDO's chunk_sectors limit, should it? Feel like I already answered this in detail but... correct, DM cannot and should not use stacked chunk_sectors as basis for splitting. Up until 5.9, where I changed DM core to set and then use chunk_sectors for splitting via blk_max_size_offset(), DM only used its own per-target ti->max_io_len in drivers/md/dm.c:max_io_len(). But I reverted back to DM's pre-5.9 splitting in this stable@ fix that I'll be sending to Linus today for 5.10-rcX: https://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm.git/commit/?h=dm-5.10-rcX&id=6bb38bcc33bf3093c08bd1b71e4f20c82bb60dd1 DM is now back to pre-5.9 behavior where it doesn't even consider chunk_sectors for splitting (NOTE: dm-zoned sets ti->max_io_len though so it is effectively achieves the same boundary splits via max_io_len). With that baseline established, what I'm now saying is: if DM, the most common limits stacking consumer, cannot benefit from stacked chunk_sectors then what stacked device does benefit? Could be block core's stacked chunk_sectors based splitting is good enough for others, just not yet seeing how. Feels like it predates blk_queue_split() and the stacking of chunk_sectors could/should be removed now. All said, I'm fine with leaving stacked chunk_sectors for others to care about... think I've raised enough awareness on this topic now ;) Mike -- dm-devel mailing list dm-devel@redhat.com https://www.redhat.com/mailman/listinfo/dm-devel
diff --git a/block/blk-settings.c b/block/blk-settings.c index 9741d1d83e98..659cdb8a07fe 100644 --- a/block/blk-settings.c +++ b/block/blk-settings.c @@ -547,7 +547,10 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, t->io_min = max(t->io_min, b->io_min); t->io_opt = lcm_not_zero(t->io_opt, b->io_opt); - t->chunk_sectors = lcm_not_zero(t->chunk_sectors, b->chunk_sectors); + + /* Set non-power-of-2 compatible chunk_sectors boundary */ + if (b->chunk_sectors) + t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors); /* Physical block size a multiple of the logical block size? */ if (t->physical_block_size & (t->logical_block_size - 1)) {
commit 22ada802ede8 ("block: use lcm_not_zero() when stacking chunk_sectors") broke chunk_sectors limit stacking. chunk_sectors must reflect the most limited of all devices in the IO stack. Otherwise malformed IO may result. E.g.: prior to this fix, ->chunk_sectors = lcm_not_zero(8, 128) would result in blk_max_size_offset() splitting IO at 128 sectors rather than the required more restrictive 8 sectors. And since commit 07d098e6bbad ("block: allow 'chunk_sectors' to be non-power-of-2") care must be taken to properly stack chunk_sectors to be compatible with the possibility that a non-power-of-2 chunk_sectors may be stacked. This is why gcd() is used instead of reverting back to using min_not_zero(). Fixes: 22ada802ede8 ("block: use lcm_not_zero() when stacking chunk_sectors") Fixes: 07d098e6bbad ("block: allow 'chunk_sectors' to be non-power-of-2") Cc: stable@vger.kernel.org Reported-by: John Dorminy <jdorminy@redhat.com> Reported-by: Bruce Johnston <bjohnsto@redhat.com> Signed-off-by: Mike Snitzer <snitzer@redhat.com> --- block/blk-settings.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) v2: use gcd(), instead of min_not_zero(), as suggested by John Dorminy