Skip to contentSkip to conversation

Revert "block/mq-deadline: Add cgroup support"

PATCH In review Tejun Heo 5 participants 17 messages Aug 11, 2021 – Aug 13, 2021 Block layer

lore
Share & tools
lore

Tejun Heo

author
#0 lore raw

PATCH 1/1 Revert "block/mq-deadline: Add cgroup support"

From e150c6478e453fe27b5cf83ed5d03b7582b6d35e Mon Sep 17 00:00:00 2001
From: Tejun Heo <[email protected]>
Date: Wed, 11 Aug 2021 07:29:20 -1000

This reverts commit 08a9ad8bf607 ("block/mq-deadline: Add cgroup support") and a follow-up commit c06bc5a3fb42 ("block/mq-deadline: Remove a WARN_ON_ONCE() call"). The added cgroup support has the following issues:

* It breaks cgroup interface file format rule by adding custom elements to a nested key-value file.

* It registers mq-deadline as a cgroup-aware policy even though all it's doing is collecting per-cgroup stats. Even if we need these stats, this isn't the right way to add them.

* It hasn't been reviewed from cgroup side.

Cc Bart Van Assche <[email protected]>
Cc Jens Axboe <[email protected]>
---
 block/Kconfig.iosched                       |   6 -
 block/Makefile                              |   2 -
 block/mq-deadline-cgroup.c                  | 126 --------------------
 block/mq-deadline-cgroup.h                  | 114 ------------------
 block/{mq-deadline-main.c => mq-deadline.c} |  73 +++---------
 5 files changed, 14 insertions(+), 307 deletions(-)
 delete mode 100644 block/mq-deadline-cgroup.c
 delete mode 100644 block/mq-deadline-cgroup.h
 rename block/{mq-deadline-main.c => mq-deadline.c} (95%)
block/Kconfig.iosched +0 -6
index 64053d67a97b7..2f2158e05a91c 100644
@@ -9,12 +9,6 @@ config MQ_IOSCHED_DEADLINE
 	help
 	  MQ version of the deadline IO scheduler.
 
-config MQ_IOSCHED_DEADLINE_CGROUP
-       tristate
-       default y
-       depends on MQ_IOSCHED_DEADLINE
-       depends on BLK_CGROUP
-
 config MQ_IOSCHED_KYBER
 	tristate "Kyber I/O scheduler"
 	default y
block/Makefile +0 -2
index bfbe4e13ca1ef..1e1afa10f869d 100644
@@ -22,8 +22,6 @@ obj-$(CONFIG_BLK_CGROUP_IOPRIO)	+= blk-ioprio.o
 obj-$(CONFIG_BLK_CGROUP_IOLATENCY)	+= blk-iolatency.o
 obj-$(CONFIG_BLK_CGROUP_IOCOST)	+= blk-iocost.o
 obj-$(CONFIG_MQ_IOSCHED_DEADLINE)	+= mq-deadline.o
-mq-deadline-y += mq-deadline-main.o
-mq-deadline-$(CONFIG_MQ_IOSCHED_DEADLINE_CGROUP)+= mq-deadline-cgroup.o
 obj-$(CONFIG_MQ_IOSCHED_KYBER)	+= kyber-iosched.o
 bfq-y				:= bfq-iosched.o bfq-wf2q.o bfq-cgroup.o
 obj-$(CONFIG_IOSCHED_BFQ)	+= bfq.o
block/mq-deadline-cgroup.c deleted +0 -126

126 lines not on this page · raw message

block/mq-deadline-cgroup.h deleted +0 -114

114 lines not on this page · raw message

block/mq-deadline.c renamed from block/mq-deadline-main.c +14 -59

187 lines not on this page · raw message

Signature · 1 line
2.32.0
#1 lore raw
Quoted 8 lines · Tejun Heo

From e150c6478e453fe27b5cf83ed5d03b7582b6d35e Mon Sep 17 00:00:00 2001
From: Tejun Heo <[email protected]>
Date: Wed, 11 Aug 2021 07:29:20 -1000

This reverts commit 08a9ad8bf607 ("block/mq-deadline: Add cgroup support") and a follow-up commit c06bc5a3fb42 ("block/mq-deadline: Remove a WARN_ON_ONCE() call"). The added cgroup support has the following issues:

Quoted 8 lines

* It breaks cgroup interface file format rule by adding custom elements to a nested key-value file.

* It registers mq-deadline as a cgroup-aware policy even though all it's doing is collecting per-cgroup stats. Even if we need these stats, this isn't the right way to add them.

* It hasn't been reviewed from cgroup side.

Agreed that I should have Cc-ed you on the cgroup patches. But where were you while my mq-deadline patch series was out for review? The first version of that patch series was published on May 27 and the patch series was merged on June 21 so there was almost one month time to post review feedback.

Additionally, the above description is not very helpful. If it is not allowed to add custom elements by adding more pd_stat_fn callbacks, why does that callback even exist? Why does the cgroup core not complain if a new policy is registered that defines a pd_stat_fn callback?

You write that this isn't the right way to collect per cgroup stats. What is the "right way"? Has this been documented somewhere?

Bart.

author
#2 lore raw

Hello, Bart.

Quoted 4 lines · Bart Van Assche

Agreed that I should have Cc-ed you on the cgroup patches. But where were you while my mq-deadline patch series was out for review? The first version of that patch series was published on May 27 and the patch series was merged on June 21 so there was almost one month time to post review feedback.

Regardless of where I've been, I can't really review things which don't show up in my radar. The patches didn't even cc cgroups mailing list. How would I know that I needed to review the patches?

Quoted 4 lines

Additionally, the above description is not very helpful. If it is not allowed to add custom elements by adding more pd_stat_fn callbacks, why does that callback even exist? Why does the cgroup core not complain if a new policy is registered that defines a pd_stat_fn callback?

That part of the comment was on the specific fomatting that you used. cgroup interface files follow a few styles to stay consistent and ease parsing. Please refer to Documentation/admin-guide/cgroup-v2.rst.

Quoted 2 lines

You write that this isn't the right way to collect per cgroup stats. What is the "right way"? Has this been documented somewhere?

Well, there's nothing specific to mq-deadline or any other elevator or controller about the stats that your patch collected and showed. That seems like a pretty straight forward sign that it likely doens't belong there.

Thanks.

Signature · 1 line
tejun
#3 lore raw
Quoted 8 lines · Tejun Heo
Quoted 2 lines · Bart Van Assche

You write that this isn't the right way to collect per cgroup stats. What is the "right way"? Has this been documented somewhere?

Well, there's nothing specific to mq-deadline or any other elevator or controller about the stats that your patch collected and showed. That seems like a pretty straight forward sign that it likely doens't belong there.

Do you perhaps want these statistics to be reported via read-only cgroup attributes of a new cgroup policy that is independent of any particular I/O scheduler?

Thanks,

Bart.

author
#4 lore raw
Quoted 5 lines · Bart Van Assche
Quoted 4 lines · Tejun Heo
Quoted 2 lines · Bart Van Assche

You write that this isn't the right way to collect per cgroup stats. What is the "right way"? Has this been documented somewhere?

Quoted 8 lines
Quoted 4 lines

Well, there's nothing specific to mq-deadline or any other elevator or controller about the stats that your patch collected and showed. That seems like a pretty straight forward sign that it likely doens't belong there.

Do you perhaps want these statistics to be reported via read-only cgroup attributes of a new cgroup policy that is independent of any particular I/O scheduler?

There's an almost fundamental conflict between ioprio and cgroup IO control. bfq layers it so that ioprio classes define the global priority above weights and then ioprio modifies the weights within each class. mq-deadline isn't cgroup aware and who knows what kind of priority inversions it's creating when its ioprio enforcement is interacting with other cgroup controllers.

The problem is that as currently used, they're specifying the same things - how IO should be distributed globally in the system, and there's no right way to make the two configuration configuration regimes agree on what should happen on the system.

I can see two paths forward:

1. Accept that ioprio isn't something which makes senes with cgroup IO control in a generic manner and approach it in per-configuration manner, either by doing whatever the specific combination decided to do with ioprio or ignoring it.

2. The only generic way to integrate ioprio and cgroup IO control would be nesting ioprio inside cgroup IO control, so that ioprio can express per-process priority within each cgroup. While this makes semantic sense and can be useful in certain scenarios, this is also a departure from how people have been using ioprio and it'd be involve quite a bit of effort and complexity, likely too much to be justified by its inherent usefulness.

Jens, what do you think?

Thanks.

Signature · 1 line
tejun
#5 lore raw
Quoted 6 lines · Tejun Heo

There's an almost fundamental conflict between ioprio and cgroup IO control. bfq layers it so that ioprio classes define the global priority above weights and then ioprio modifies the weights within each class. mq-deadline isn't cgroup aware and who knows what kind of priority inversions it's creating when its ioprio enforcement is interacting with other cgroup controllers.

Are you perhaps referring to the iocost and iolatency cgroup controllers? Is it ever useful to combine these controllers with the ioprio controller? The ioprio controller was introduced with the goal to provide the information to the storage controller about which I/O request to handle first. My understanding of the iocost and iolatency controllers is that these cgroup controllers decide in which order to process I/O requests. Neither controller has the last word over I/O order if the queue depth is larger than one, something that is essential to achieve reasonable performance.

Bart.

author
#6 lore raw

Hello,

Quoted 1 line · Bart Van Assche

Are you perhaps referring to the iocost and iolatency cgroup controllers? Is

and blk-throtl

Quoted 1 line

it ever useful to combine these controllers with the ioprio controller? The

So, I used controller as in cgroup IO controller, something which can distribute IO resources hierarchically according to either weights or limits. In that sense, there is no such thing as an ioprio controller.

Quoted 2 lines

ioprio controller was introduced with the goal to provide the information to the storage controller about which I/O request to handle first. My

My experience has been that this isn't all that useful for generic IO control scenarios involving cgroups. The configuration is too flexible and granular to map to hardware priorities and there are way more significant factors than how a controller manages its iternal ordering on most commodity SSDs. For situations where such feature is useful, cgroup might be able to help with tagging the associated priorities but I don't think there's much beyond that and I have a hard time seeing why the existing ioprio interface wouldn't be enough.

Quoted 4 lines

understanding of the iocost and iolatency controllers is that these cgroup controllers decide in which order to process I/O requests. Neither controller has the last word over I/O order if the queue depth is larger than one, something that is essential to achieve reasonable performance.

Well, whoever owns the queue can control the latencies and it isn't difficult to mess up while issuing one command at a time, so if the strategy is stuffing device queue as much as possible and telling the device what to do, the end result is gonna be pretty sad.

Thanks.

Signature · 1 line
tejun
#7 lore raw
Quoted 30 lines · Tejun Heo

Hello,

Quoted 1 line · Bart Van Assche

Are you perhaps referring to the iocost and iolatency cgroup controllers? Is

and blk-throtl

Quoted 1 line

it ever useful to combine these controllers with the ioprio controller? The

So, I used controller as in cgroup IO controller, something which can distribute IO resources hierarchically according to either weights or limits. In that sense, there is no such thing as an ioprio controller.

Quoted 2 lines

ioprio controller was introduced with the goal to provide the information to the storage controller about which I/O request to handle first. My

My experience has been that this isn't all that useful for generic IO control scenarios involving cgroups. The configuration is too flexible and granular to map to hardware priorities and there are way more significant factors than how a controller manages its iternal ordering on most commodity SSDs. For situations where such feature is useful, cgroup might be able to help with tagging the associated priorities but I don't think there's much beyond that and I have a hard time seeing why the existing ioprio interface wouldn't be enough.

Quoted 4 lines

understanding of the iocost and iolatency controllers is that these cgroup controllers decide in which order to process I/O requests. Neither controller has the last word over I/O order if the queue depth is larger than one, something that is essential to achieve reasonable performance.

Quoted 4 lines

Well, whoever owns the queue can control the latencies and it isn't difficult to mess up while issuing one command at a time, so if the strategy is stuffing device queue as much as possible and telling the device what to do, the end result is gonna be pretty sad.

Let me throw in more information related to this.

Command duration limits (CDL) and Sequestered commands features are being drafted in SPC/SBC and ACS to give the device better hints than just a on/off high priority bit. I am currently prototyping these features and I am reusing the ioprio interface for that. Here is how this works:
1) The drives exposes a set of command duration limits descriptors (up to 7 for reads and 7 for writes) that define duration limits for a command execution:
overall processing time, queuing time and execution time. Each duration time has a policy associated with it that is applied if a command processing exceeds one of the defined time limit: continue, continue but signal limit exceeded, abort.
2) Users can change the drive command duration limits to whatever they need (e.g. change the policies for the limits to get a fast-fail behavior for commands instead of having the drive retry for a long time)
3) When issuing IOs, users (or FSes) can apply a command duration limit descriptor by specifying the IOPRIO_CLASS_DL priority class. The priority level for that class indicates the descriptor to apply to the command.
4) At SCSI/ATA level, read and write commands have 3 bits defined to specify the command descriptor to apply to the command (1 to 7 or 0 for no limit)

With that in place, the disk firmware can now make more intelligent decisions on command scheduling to keep performance high at high queue depth without increasing latency for commands that have low duration limits. And based on the policy defined for a limit, this can be a "soft" best-effort optimization by the disk, or a hard one with aborts if the drive decides that what the user is asking for is not possible.

CDL can completely replace the existing binary on/off NCQ priority in a more flexible manner as the user can set different duration limits for high vs low priority. E.g. high priority is equivalent to a very short limit while low priority is equivalent to longer or no limits.

I think that CDL has the potential for better interactions with cgroups as cgroup controllers can install a set of limits on the drive that fits the controller target policy. E.g., the latency controller can set duration limits and use the IOPRIO_CLASS_DL class to tell the drive the exact latency target to use.

In my implementation, I have not yet looked into cgroups integration for CDL though. I am still wondering what the best approach is: defining a new controller or integrating into existing controllers. The former is likely easier than the latter, but having hardware support for existing controllers has the potential to improve them seamlessly without forcing the user to change anything to there application setup.

CDL is still in draft state in the specs though. So I will not be sending this yet.

Quoted 3 lines

Thanks.

Signature · 2 lines
Damien Le Moal
Western Digital Research
author
#8 lore raw

Hello, Damien.

Quoted 4 lines · Damien Le Moal

Command duration limits (CDL) and Sequestered commands features are being drafted in SPC/SBC and ACS to give the device better hints than just a on/off high priority bit. I am currently prototyping these features and I am reusing the ioprio interface for that. Here is how this works:

And I think ioprio would be the right interface for it, combined with some mechanism which can limit which class can take up how many of the available command slots. Without that, it'd be really easy for anyone to saturate the command queues and expressing priorities inside the device won't do much.

Quoted 4 lines

CDL can completely replace the existing binary on/off NCQ priority in a more flexible manner as the user can set different duration limits for high vs low priority. E.g. high priority is equivalent to a very short limit while low priority is equivalent to longer or no limits.

The problem with complex optional hardware features is often the accompanying variability in terms of availability, reliability and behavior. The track record has been pretty sad. That isn't to say this won't be useful for anybody but it'd need careful coordination in terms of picking hardware vendor and model and ensuring vendor support, which kinda severely limits the usefulness.

Thanks.

Signature · 1 line
tejun
#9 lore raw
Quoted 6 lines · Tejun Heo

The problem with complex optional hardware features is often the accompanying variability in terms of availability, reliability and behavior. The track record has been pretty sad. That isn't to say this won't be useful for anybody but it'd need careful coordination in terms of picking hardware vendor and model and ensuring vendor support, which kinda severely limits the usefulness.

I think the above view is too negative. Companies that store large amounts of data have the power to make this happen by only buying storage devices that support I/O prioritization well enough.

Bart.

author
#10 lore raw
Quoted 11 lines · Bart Van Assche
Quoted 6 lines · Tejun Heo

The problem with complex optional hardware features is often the accompanying variability in terms of availability, reliability and behavior. The track record has been pretty sad. That isn't to say this won't be useful for anybody but it'd need careful coordination in terms of picking hardware vendor and model and ensuring vendor support, which kinda severely limits the usefulness.

I think the above view is too negative. Companies that store large amounts of data have the power to make this happen by only buying storage devices that support I/O prioritization well enough.

The problem usually is that there always are other ways to skin that cat which don't depend on having complex optional features. So, the comparison isn't just about or among devices that support such extra feature but with other solutions which don't need them in the first place. Throw in the many inherent problems in expanding hardware interface such as variability and timescale mismatch (hardware changes a lot faster than software stack), the long term result tends to skew pretty clearly.

Thanks.

Signature · 1 line
tejun
#11 lore raw
In reply to Damien Le Moal
Quoted 37 lines · Damien Le Moal

Let me throw in more information related to this.

Command duration limits (CDL) and Sequestered commands features are being drafted in SPC/SBC and ACS to give the device better hints than just a on/off high priority bit. I am currently prototyping these features and I am reusing the ioprio interface for that. Here is how this works:
1) The drives exposes a set of command duration limits descriptors (up to 7 for reads and 7 for writes) that define duration limits for a command execution:
overall processing time, queuing time and execution time. Each duration time has a policy associated with it that is applied if a command processing exceeds one of the defined time limit: continue, continue but signal limit exceeded, abort.
2) Users can change the drive command duration limits to whatever they need (e.g. change the policies for the limits to get a fast-fail behavior for commands instead of having the drive retry for a long time)
3) When issuing IOs, users (or FSes) can apply a command duration limit descriptor by specifying the IOPRIO_CLASS_DL priority class. The priority level for that class indicates the descriptor to apply to the command.
4) At SCSI/ATA level, read and write commands have 3 bits defined to specify the command descriptor to apply to the command (1 to 7 or 0 for no limit)

With that in place, the disk firmware can now make more intelligent decisions on command scheduling to keep performance high at high queue depth without increasing latency for commands that have low duration limits. And based on the policy defined for a limit, this can be a "soft" best-effort optimization by the disk, or a hard one with aborts if the drive decides that what the user is asking for is not possible.

CDL can completely replace the existing binary on/off NCQ priority in a more flexible manner as the user can set different duration limits for high vs low priority. E.g. high priority is equivalent to a very short limit while low priority is equivalent to longer or no limits.

I think that CDL has the potential for better interactions with cgroups as cgroup controllers can install a set of limits on the drive that fits the controller target policy. E.g., the latency controller can set duration limits and use the IOPRIO_CLASS_DL class to tell the drive the exact latency target to use.

Quoted 8 lines

In my implementation, I have not yet looked into cgroups integration for CDL though. I am still wondering what the best approach is: defining a new controller or integrating into existing controllers. The former is likely easier than the latter, but having hardware support for existing controllers has the potential to improve them seamlessly without forcing the user to change anything to there application setup.

CDL is still in draft state in the specs though. So I will not be sending this yet.

Thanks Damien for having provided this additional information. This is very helpful. I see this as a welcome evolution since the disk firmware has more information than the CPU (e.g. about the disk head position) and hence can make a better decision than an I/O scheduler or cgroup policy.

For the cloud use case, are all disks used to implement disaggregated storage? I'm asking this because in a disaggregated storage setup the I/O submitter runs on another server than the server to which the disks are connected. In such a setup I expect that the I/O priority will be provided from user space instead of being provided by a cgroup.

Bart.

maintainer
#12 lore raw
In reply to Tejun Heo
Quoted 42 lines · Tejun Heo
Quoted 5 lines · Bart Van Assche
Quoted 4 lines · Tejun Heo
Quoted 2 lines · Bart Van Assche

You write that this isn't the right way to collect per cgroup stats. What is the "right way"? Has this been documented somewhere?

Quoted 8 lines
Quoted 4 lines

Well, there's nothing specific to mq-deadline or any other elevator or controller about the stats that your patch collected and showed. That seems like a pretty straight forward sign that it likely doens't belong there.

Do you perhaps want these statistics to be reported via read-only cgroup attributes of a new cgroup policy that is independent of any particular I/O scheduler?

There's an almost fundamental conflict between ioprio and cgroup IO control. bfq layers it so that ioprio classes define the global priority above weights and then ioprio modifies the weights within each class. mq-deadline isn't cgroup aware and who knows what kind of priority inversions it's creating when its ioprio enforcement is interacting with other cgroup controllers.

The problem is that as currently used, they're specifying the same things - how IO should be distributed globally in the system, and there's no right way to make the two configuration configuration regimes agree on what should happen on the system.

I can see two paths forward:

1. Accept that ioprio isn't something which makes senes with cgroup IO control in a generic manner and approach it in per-configuration manner, either by doing whatever the specific combination decided to do with ioprio or ignoring it.

2. The only generic way to integrate ioprio and cgroup IO control would be nesting ioprio inside cgroup IO control, so that ioprio can express per-process priority within each cgroup. While this makes semantic sense and can be useful in certain scenarios, this is also a departure from how people have been using ioprio and it'd be involve quite a bit of effort and complexity, likely too much to be justified by its inherent usefulness.

Quoted 1 line

Jens, what do you think?

On the surface, #2 makes the most sense. But you'd then have to apply some scaling before it reaches the hardware side or is factored in by the underlying scheduler, or you could have a high priority from a cgroup that has small share of the total resources, yet ends up being regarded as more important than a lower priority request from a cgroup that has a much higher share of the total resources.

Hence not really sure it makes a lot of sense... We could probably come up with some heuristics that make some sense, but they'd still just be heuristics.

Signature · 1 line
Jens Axboe
author
#13 lore raw

Hello,

Quoted 6 lines · Jens Axboe

On the surface, #2 makes the most sense. But you'd then have to apply some scaling before it reaches the hardware side or is factored in by the underlying scheduler, or you could have a high priority from a cgroup that has small share of the total resources, yet ends up being regarded as more important than a lower priority request from a cgroup that has a much higher share of the total resources.

I don't think hardware side support is all that useful for mainstream use cases. Whatever is controlling IO has to own the queue by being the most throttling portion of the pipeline anyway and at least my experience has been that what matters a lot more is the overall rate of throttling rather than how specific IO is handled - ie. you can try to feed one IO at a time to a SSD with the right priority marking but it won't do much good if the sequence includes a lot of back-to-back writes which can saturate some portion of the SSD in terms of buffering and GC. Also, the configuration granularity is too coarse to adapt to generic use cases and the history is pretty clear on optional advanced features on mainstream storage devices.

Quoted 3 lines

Hence not really sure it makes a lot of sense... We could probably come up with some heuristics that make some sense, but they'd still just be heuristics.

Yeah, I have a hard time imagining a sane and logical mapping between cgroup IO control and hardware prioritization features. For use cases and hardware configuration which can benefit from prioritization on the hardware side, I think the right solution is doing it outside the cgroup framework, or at least the usual IO controllers.

Thanks.

Signature · 1 line
tejun
maintainer
#14 lore raw
In reply to Tejun Heo
Quoted 8 lines · Tejun Heo

From e150c6478e453fe27b5cf83ed5d03b7582b6d35e Mon Sep 17 00:00:00 2001
From: Tejun Heo <[email protected]>
Date: Wed, 11 Aug 2021 07:29:20 -1000

This reverts commit 08a9ad8bf607 ("block/mq-deadline: Add cgroup support") and a follow-up commit c06bc5a3fb42 ("block/mq-deadline: Remove a WARN_ON_ONCE() call"). The added cgroup support has the following issues:

Quoted 8 lines

* It breaks cgroup interface file format rule by adding custom elements to a nested key-value file.

* It registers mq-deadline as a cgroup-aware policy even though all it's doing is collecting per-cgroup stats. Even if we need these stats, this isn't the right way to add them.

* It hasn't been reviewed from cgroup side.

I missed that the cgroup side hadn't seen or signed off on this one. I have applied this revert for 5.14.

Signature · 1 line
Jens Axboe
#15 lore raw

Hi.

Quoted 15 lines · On středa 11. srpna 2021 21:48:19 CEST Jens Axboe wrote:
Quoted 14 lines · Tejun Heo

From e150c6478e453fe27b5cf83ed5d03b7582b6d35e Mon Sep 17 00:00:00 2001
From: Tejun Heo <[email protected]>
Date: Wed, 11 Aug 2021 07:29:20 -1000

This reverts commit 08a9ad8bf607 ("block/mq-deadline: Add cgroup support") and a follow-up commit c06bc5a3fb42 ("block/mq-deadline: Remove a WARN_ON_ONCE() call"). The added cgroup support has the following issues:

* It breaks cgroup interface file format rule by adding custom elements to a>
nested key-value file.

* It registers mq-deadline as a cgroup-aware policy even though all it's

Quoted 7 lines
Quoted 4 lines

doing is collecting per-cgroup stats. Even if we need these stats, this isn't the right way to add them.

* It hasn't been reviewed from cgroup side.

I missed that the cgroup side hadn't seen or signed off on this one. I have applied this revert for 5.14.

Should my commit [1] be reverted too?

Thanks.

[1] https://git.kernel.dk/cgit/linux-block/commit/?h=block-5.14&id=ec645dc96699ea6c37b6de86c84d7288ea9a4ddf

Signature · 1 line
Oleksandr Natalenko (post-factum)
maintainer
#16 lore raw
Quoted 23 lines · Oleksandr Natalenko

Hi.

Quoted 20 lines · On středa 11. srpna 2021 21:48:19 CEST Jens Axboe wrote:
Quoted 18 lines · Tejun Heo

From e150c6478e453fe27b5cf83ed5d03b7582b6d35e Mon Sep 17 00:00:00 2001
From: Tejun Heo <[email protected]>
Date: Wed, 11 Aug 2021 07:29:20 -1000

This reverts commit 08a9ad8bf607 ("block/mq-deadline: Add cgroup support") and a follow-up commit c06bc5a3fb42 ("block/mq-deadline: Remove a WARN_ON_ONCE() call"). The added cgroup support has the following issues:

* It breaks cgroup interface file format rule by adding custom elements to a>
nested key-value file.

* It registers mq-deadline as a cgroup-aware policy even though all it's

doing is collecting per-cgroup stats. Even if we need these stats, this isn't the right way to add them.

* It hasn't been reviewed from cgroup side.

Quoted 8 lines
Quoted 2 lines

I missed that the cgroup side hadn't seen or signed off on this one. I have applied this revert for 5.14.

Should my commit [1] be reverted too?

Thanks.

[1] https://git.kernel.dk/cgit/linux-block/commit/?h=block-5.14&id=ec645dc96699ea6c37b6de86c84d7288ea9a4ddf

It could be, but may as well leave it for now as we're super close to the limit anyway.

Signature · 1 line
Jens Axboe