2009-12-04 01:59:42 +08:00
|
|
|
#ifndef _BLK_CGROUP_H
|
|
|
|
#define _BLK_CGROUP_H
|
|
|
|
/*
|
|
|
|
* Common Block IO controller cgroup interface
|
|
|
|
*
|
|
|
|
* Based on ideas and code from CFQ, CFS and BFQ:
|
|
|
|
* Copyright (C) 2003 Jens Axboe <axboe@kernel.dk>
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Fabio Checconi <fabio@gandalf.sssup.it>
|
|
|
|
* Paolo Valente <paolo.valente@unimore.it>
|
|
|
|
*
|
|
|
|
* Copyright (C) 2009 Vivek Goyal <vgoyal@redhat.com>
|
|
|
|
* Nauman Rafique <nauman@google.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/cgroup.h>
|
2011-05-20 03:38:29 +08:00
|
|
|
#include <linux/u64_stats_sync.h>
|
2012-04-02 05:38:43 +08:00
|
|
|
#include <linux/seq_file.h>
|
2012-04-20 07:29:24 +08:00
|
|
|
#include <linux/radix-tree.h>
|
blkcg: implement per-blkg request allocation
Currently, request_queue has one request_list to allocate requests
from regardless of blkcg of the IO being issued. When the unified
request pool is used up, cfq proportional IO limits become meaningless
- whoever grabs the next request being freed wins the race regardless
of the configured weights.
This can be easily demonstrated by creating a blkio cgroup w/ very low
weight, put a program which can issue a lot of random direct IOs there
and running a sequential IO from a different cgroup. As soon as the
request pool is used up, the sequential IO bandwidth crashes.
This patch implements per-blkg request_list. Each blkg has its own
request_list and any IO allocates its request from the matching blkg
making blkcgs completely isolated in terms of request allocation.
* Root blkcg uses the request_list embedded in each request_queue,
which was renamed to @q->root_rl from @q->rq. While making blkcg rl
handling a bit harier, this enables avoiding most overhead for root
blkcg.
* Queue fullness is properly per request_list but bdi isn't blkcg
aware yet, so congestion state currently just follows the root
blkcg. As writeback isn't aware of blkcg yet, this works okay for
async congestion but readahead may get the wrong signals. It's
better than blkcg completely collapsing with shared request_list but
needs to be improved with future changes.
* After this change, each block cgroup gets a full request pool making
resource consumption of each cgroup higher. This makes allowing
non-root users to create cgroups less desirable; however, note that
allowing non-root users to directly manage cgroups is already
severely broken regardless of this patch - each block cgroup
consumes kernel memory and skews IO weight (IO weights are not
hierarchical).
v2: queue-sysfs.txt updated and patch description udpated as suggested
by Vivek.
v3: blk_get_rl() wasn't checking error return from
blkg_lookup_create() and may cause oops on lookup failure. Fix it
by falling back to root_rl on blkg lookup failures. This problem
was spotted by Rakesh Iyer <rni@google.com>.
v4: Updated to accomodate 458f27a982 "block: Avoid missed wakeup in
request waitqueue". blk_drain_queue() now wakes up waiters on all
blkg->rl on the target queue.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-06-27 06:05:44 +08:00
|
|
|
#include <linux/blkdev.h>
|
blkcg: fix use-after-free in __blkg_release_rcu() by making blkcg_gq refcnt an atomic_t
Hello,
So, this patch should do. Joe, Vivek, can one of you guys please
verify that the oops goes away with this patch?
Jens, the original thread can be read at
http://thread.gmane.org/gmane.linux.kernel/1720729
The fix converts blkg->refcnt from int to atomic_t. It does some
overhead but it should be minute compared to everything else which is
going on and the involved cacheline bouncing, so I think it's highly
unlikely to cause any noticeable difference. Also, the refcnt in
question should be converted to a perpcu_ref for blk-mq anyway, so the
atomic_t is likely to go away pretty soon anyway.
Thanks.
------- 8< -------
__blkg_release_rcu() may be invoked after the associated request_queue
is released with a RCU grace period inbetween. As such, the function
and callbacks invoked from it must not dereference the associated
request_queue. This is clearly indicated in the comment above the
function.
Unfortunately, while trying to fix a different issue, 2a4fd070ee85
("blkcg: move bulk of blkcg_gq release operations to the RCU
callback") ignored this and added [un]locking of @blkg->q->queue_lock
to __blkg_release_rcu(). This of course can cause oops as the
request_queue may be long gone by the time this code gets executed.
general protection fault: 0000 [#1] SMP
CPU: 21 PID: 30 Comm: rcuos/21 Not tainted 3.15.0 #1
Hardware name: Stratus ftServer 6400/G7LAZ, BIOS BIOS Version 6.3:57 12/25/2013
task: ffff880854021de0 ti: ffff88085403c000 task.ti: ffff88085403c000
RIP: 0010:[<ffffffff8162e9e5>] [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP: 0018:ffff88085403fdf0 EFLAGS: 00010086
RAX: 0000000000020000 RBX: 0000000000000010 RCX: 0000000000000000
RDX: 000060ef80008248 RSI: 0000000000000286 RDI: 6b6b6b6b6b6b6b6b
RBP: ffff88085403fdf0 R08: 0000000000000286 R09: 0000000000009f39
R10: 0000000000020001 R11: 0000000000020001 R12: ffff88103c17a130
R13: ffff88103c17a080 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88107fca0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000006e5ab8 CR3: 000000000193d000 CR4: 00000000000407e0
Stack:
ffff88085403fe18 ffffffff812cbfc2 ffff88103c17a130 0000000000000000
ffff88103c17a130 ffff88085403fec0 ffffffff810d1d28 ffff880854021de0
ffff880854021de0 ffff88107fcaec58 ffff88085403fe80 ffff88107fcaec30
Call Trace:
[<ffffffff812cbfc2>] __blkg_release_rcu+0x72/0x150
[<ffffffff810d1d28>] rcu_nocb_kthread+0x1e8/0x300
[<ffffffff81091d81>] kthread+0xe1/0x100
[<ffffffff8163813c>] ret_from_fork+0x7c/0xb0
Code: ff 47 04 48 8b 7d 08 be 00 02 00 00 e8 55 48 a4 ff 5d c3 0f 1f 00 66 66 66 66 90 55 48 89 e5
+fa 66 66 90 66 66 90 b8 00 00 02 00 <f0> 0f c1 07 89 c2 c1 ea 10 66 39 c2 75 02 5d c3 83 e2 fe 0f
+b7
RIP [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP <ffff88085403fdf0>
The request_queue locking was added because blkcg_gq->refcnt is an int
protected with the queue lock and __blkg_release_rcu() needs to put
the parent. Let's fix it by making blkcg_gq->refcnt an atomic_t and
dropping queue locking in the function.
Given the general heavy weight of the current request_queue and blkcg
operations, this is unlikely to cause any noticeable overhead.
Moreover, blkcg_gq->refcnt is likely to be converted to percpu_ref in
the near future, so whatever (most likely negligible) overhead it may
add is temporary.
Signed-off-by: Tejun Heo <tj@kernel.org>
Reported-by: Joe Lawrence <joe.lawrence@stratus.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Link: http://lkml.kernel.org/g/alpine.DEB.2.02.1406081816540.17948@jlaw-desktop.mno.stratus.com
Cc: stable@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2014-06-20 05:42:57 +08:00
|
|
|
#include <linux/atomic.h>
|
2009-12-04 01:59:42 +08:00
|
|
|
|
2010-10-02 03:16:41 +08:00
|
|
|
/* Max limits for throttle policy */
|
|
|
|
#define THROTL_IOPS_MAX UINT_MAX
|
|
|
|
|
2012-04-14 04:11:25 +08:00
|
|
|
#ifdef CONFIG_BLK_CGROUP
|
|
|
|
|
2012-04-02 05:38:42 +08:00
|
|
|
enum blkg_rwstat_type {
|
|
|
|
BLKG_RWSTAT_READ,
|
|
|
|
BLKG_RWSTAT_WRITE,
|
|
|
|
BLKG_RWSTAT_SYNC,
|
|
|
|
BLKG_RWSTAT_ASYNC,
|
|
|
|
|
|
|
|
BLKG_RWSTAT_NR,
|
|
|
|
BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,
|
2010-04-02 06:01:24 +08:00
|
|
|
};
|
|
|
|
|
2012-04-20 07:29:24 +08:00
|
|
|
struct blkcg_gq;
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg {
|
2012-04-17 04:57:24 +08:00
|
|
|
struct cgroup_subsys_state css;
|
|
|
|
spinlock_t lock;
|
2012-04-20 07:29:24 +08:00
|
|
|
|
|
|
|
struct radix_tree_root blkg_tree;
|
|
|
|
struct blkcg_gq *blkg_hint;
|
2012-04-17 04:57:24 +08:00
|
|
|
struct hlist_head blkg_list;
|
2012-03-20 06:10:56 +08:00
|
|
|
|
block, cgroup: implement policy-specific per-blkcg data
The block IO (blkio) controller enables the block layer to provide service
guarantees in a hierarchical fashion. Specifically, service guarantees
are provided by registered request-accounting policies. As of now, a
proportional-share and a throttling policy are available. They are
implemented, respectively, by the CFQ I/O scheduler and the blk-throttle
subsystem. Unfortunately, as for adding new policies, the current
implementation of the block IO controller is only halfway ready to allow
new policies to be plugged in. This commit provides a solution to make
the block IO controller fully ready to handle new policies.
In what follows, we first describe briefly the current state, and then
list the changes made by this commit.
The throttling policy does not need any per-cgroup information to perform
its task. In contrast, the proportional share policy uses, for each cgroup,
both the weight assigned by the user to the cgroup, and a set of dynamically-
computed weights, one for each device.
The first, user-defined weight is stored in the blkcg data structure: the
block IO controller allocates a private blkcg data structure for each
cgroup in the blkio cgroups hierarchy (regardless of which policy is active).
In other words, the block IO controller internally mirrors the blkio cgroups
with private blkcg data structures.
On the other hand, for each cgroup and device, the corresponding dynamically-
computed weight is maintained in the following, different way. For each device,
the block IO controller keeps a private blkcg_gq structure for each cgroup in
blkio. In other words, block IO also keeps one private mirror copy of the blkio
cgroups hierarchy for each device, made of blkcg_gq structures.
Each blkcg_gq structure keeps per-policy information in a generic array of
dynamically-allocated 'dedicated' data structures, one for each registered
policy (so currently the array contains two elements). To be inserted into the
generic array, each dedicated data structure embeds a generic blkg_policy_data
structure. Consider now the array contained in the blkcg_gq structure
corresponding to a given pair of cgroup and device: one of the elements
of the array contains the dedicated data structure for the proportional-share
policy, and this dedicated data structure contains the dynamically-computed
weight for that pair of cgroup and device.
The generic strategy adopted for storing per-policy data in blkcg_gq structures
is already capable of handling new policies, whereas the one adopted with blkcg
structures is not, because per-policy data are hard-coded in the blkcg
structures themselves (currently only data related to the proportional-
share policy).
This commit addresses the above issues through the following changes:
. It generalizes blkcg structures so that per-policy data are stored in the same
way as in blkcg_gq structures.
Specifically, it lets also the blkcg structure store per-policy data in a
generic array of dynamically-allocated dedicated data structures. We will
refer to these data structures as blkcg dedicated data structures, to
distinguish them from the dedicated data structures inserted in the generic
arrays kept by blkcg_gq structures.
To allow blkcg dedicated data structures to be inserted in the generic array
inside a blkcg structure, this commit also introduces a new blkcg_policy_data
structure, which is the equivalent of blkg_policy_data for blkcg dedicated
data structures.
. It adds to the blkcg_policy structure, i.e., to the descriptor of a policy, a
cpd_size field and a cpd_init field, to be initialized by the policy with,
respectively, the size of the blkcg dedicated data structures, and the
address of a constructor function for blkcg dedicated data structures.
. It moves the CFQ-specific fields embedded in the blkcg data structure (i.e.,
the fields related to the proportional-share policy), into a new blkcg
dedicated data structure called cfq_group_data.
Signed-off-by: Paolo Valente <paolo.valente@unimore.it>
Signed-off-by: Arianna Avanzini <avanzini.arianna@gmail.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: Jens Axboe <axboe@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-06-06 05:38:42 +08:00
|
|
|
struct blkcg_policy_data *pd[BLKCG_MAX_POLS];
|
2015-05-23 05:13:37 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_CGROUP_WRITEBACK
|
|
|
|
struct list_head cgwb_list;
|
|
|
|
#endif
|
2009-12-04 01:59:42 +08:00
|
|
|
};
|
|
|
|
|
2012-04-02 05:38:42 +08:00
|
|
|
struct blkg_stat {
|
|
|
|
struct u64_stats_sync syncp;
|
|
|
|
uint64_t cnt;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct blkg_rwstat {
|
|
|
|
struct u64_stats_sync syncp;
|
|
|
|
uint64_t cnt[BLKG_RWSTAT_NR];
|
|
|
|
};
|
|
|
|
|
2012-04-17 04:57:26 +08:00
|
|
|
/*
|
|
|
|
* A blkcg_gq (blkg) is association between a block cgroup (blkcg) and a
|
|
|
|
* request_queue (q). This is used by blkcg policies which need to track
|
|
|
|
* information per blkcg - q pair.
|
|
|
|
*
|
|
|
|
* There can be multiple active blkcg policies and each has its private
|
|
|
|
* data on each blkg, the size of which is determined by
|
|
|
|
* blkcg_policy->pd_size. blkcg core allocates and frees such areas
|
|
|
|
* together with blkg and invokes pd_init/exit_fn() methods.
|
|
|
|
*
|
|
|
|
* Such private data must embed struct blkg_policy_data (pd) at the
|
|
|
|
* beginning and pd_size can't be smaller than pd.
|
|
|
|
*/
|
2012-03-06 05:15:14 +08:00
|
|
|
struct blkg_policy_data {
|
2013-01-10 00:05:12 +08:00
|
|
|
/* the blkg and policy id this per-policy data belongs to */
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg_gq *blkg;
|
2013-01-10 00:05:12 +08:00
|
|
|
int plid;
|
2012-03-06 05:15:14 +08:00
|
|
|
|
2012-04-14 04:11:33 +08:00
|
|
|
/* used during policy activation */
|
2012-04-17 04:57:24 +08:00
|
|
|
struct list_head alloc_node;
|
2012-03-06 05:15:14 +08:00
|
|
|
};
|
|
|
|
|
block, cgroup: implement policy-specific per-blkcg data
The block IO (blkio) controller enables the block layer to provide service
guarantees in a hierarchical fashion. Specifically, service guarantees
are provided by registered request-accounting policies. As of now, a
proportional-share and a throttling policy are available. They are
implemented, respectively, by the CFQ I/O scheduler and the blk-throttle
subsystem. Unfortunately, as for adding new policies, the current
implementation of the block IO controller is only halfway ready to allow
new policies to be plugged in. This commit provides a solution to make
the block IO controller fully ready to handle new policies.
In what follows, we first describe briefly the current state, and then
list the changes made by this commit.
The throttling policy does not need any per-cgroup information to perform
its task. In contrast, the proportional share policy uses, for each cgroup,
both the weight assigned by the user to the cgroup, and a set of dynamically-
computed weights, one for each device.
The first, user-defined weight is stored in the blkcg data structure: the
block IO controller allocates a private blkcg data structure for each
cgroup in the blkio cgroups hierarchy (regardless of which policy is active).
In other words, the block IO controller internally mirrors the blkio cgroups
with private blkcg data structures.
On the other hand, for each cgroup and device, the corresponding dynamically-
computed weight is maintained in the following, different way. For each device,
the block IO controller keeps a private blkcg_gq structure for each cgroup in
blkio. In other words, block IO also keeps one private mirror copy of the blkio
cgroups hierarchy for each device, made of blkcg_gq structures.
Each blkcg_gq structure keeps per-policy information in a generic array of
dynamically-allocated 'dedicated' data structures, one for each registered
policy (so currently the array contains two elements). To be inserted into the
generic array, each dedicated data structure embeds a generic blkg_policy_data
structure. Consider now the array contained in the blkcg_gq structure
corresponding to a given pair of cgroup and device: one of the elements
of the array contains the dedicated data structure for the proportional-share
policy, and this dedicated data structure contains the dynamically-computed
weight for that pair of cgroup and device.
The generic strategy adopted for storing per-policy data in blkcg_gq structures
is already capable of handling new policies, whereas the one adopted with blkcg
structures is not, because per-policy data are hard-coded in the blkcg
structures themselves (currently only data related to the proportional-
share policy).
This commit addresses the above issues through the following changes:
. It generalizes blkcg structures so that per-policy data are stored in the same
way as in blkcg_gq structures.
Specifically, it lets also the blkcg structure store per-policy data in a
generic array of dynamically-allocated dedicated data structures. We will
refer to these data structures as blkcg dedicated data structures, to
distinguish them from the dedicated data structures inserted in the generic
arrays kept by blkcg_gq structures.
To allow blkcg dedicated data structures to be inserted in the generic array
inside a blkcg structure, this commit also introduces a new blkcg_policy_data
structure, which is the equivalent of blkg_policy_data for blkcg dedicated
data structures.
. It adds to the blkcg_policy structure, i.e., to the descriptor of a policy, a
cpd_size field and a cpd_init field, to be initialized by the policy with,
respectively, the size of the blkcg dedicated data structures, and the
address of a constructor function for blkcg dedicated data structures.
. It moves the CFQ-specific fields embedded in the blkcg data structure (i.e.,
the fields related to the proportional-share policy), into a new blkcg
dedicated data structure called cfq_group_data.
Signed-off-by: Paolo Valente <paolo.valente@unimore.it>
Signed-off-by: Arianna Avanzini <avanzini.arianna@gmail.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: Jens Axboe <axboe@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-06-06 05:38:42 +08:00
|
|
|
/*
|
|
|
|
* Policies that need to keep per-blkcg data which is independent
|
|
|
|
* from any request_queue associated to it must specify its size
|
|
|
|
* with the cpd_size field of the blkcg_policy structure and
|
|
|
|
* embed a blkcg_policy_data in it. blkcg core allocates
|
|
|
|
* policy-specific per-blkcg structures lazily the first time
|
|
|
|
* they are actually needed, so it handles them together with
|
|
|
|
* blkgs. cpd_init() is invoked to let each policy handle
|
|
|
|
* per-blkcg data.
|
|
|
|
*/
|
|
|
|
struct blkcg_policy_data {
|
|
|
|
/* the policy id this per-policy data belongs to */
|
|
|
|
int plid;
|
|
|
|
|
|
|
|
/* used during policy activation */
|
|
|
|
struct list_head alloc_node;
|
|
|
|
};
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
/* association between a blk cgroup and a request queue */
|
|
|
|
struct blkcg_gq {
|
2012-03-06 05:15:22 +08:00
|
|
|
/* Pointer to the associated request_queue */
|
2012-04-17 04:57:24 +08:00
|
|
|
struct request_queue *q;
|
|
|
|
struct list_head q_node;
|
|
|
|
struct hlist_node blkcg_node;
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg *blkcg;
|
2013-01-10 00:05:10 +08:00
|
|
|
|
2015-05-23 05:13:38 +08:00
|
|
|
/*
|
|
|
|
* Each blkg gets congested separately and the congestion state is
|
|
|
|
* propagated to the matching bdi_writeback_congested.
|
|
|
|
*/
|
|
|
|
struct bdi_writeback_congested *wb_congested;
|
|
|
|
|
2013-01-10 00:05:10 +08:00
|
|
|
/* all non-root blkcg_gq's are guaranteed to have access to parent */
|
|
|
|
struct blkcg_gq *parent;
|
|
|
|
|
blkcg: implement per-blkg request allocation
Currently, request_queue has one request_list to allocate requests
from regardless of blkcg of the IO being issued. When the unified
request pool is used up, cfq proportional IO limits become meaningless
- whoever grabs the next request being freed wins the race regardless
of the configured weights.
This can be easily demonstrated by creating a blkio cgroup w/ very low
weight, put a program which can issue a lot of random direct IOs there
and running a sequential IO from a different cgroup. As soon as the
request pool is used up, the sequential IO bandwidth crashes.
This patch implements per-blkg request_list. Each blkg has its own
request_list and any IO allocates its request from the matching blkg
making blkcgs completely isolated in terms of request allocation.
* Root blkcg uses the request_list embedded in each request_queue,
which was renamed to @q->root_rl from @q->rq. While making blkcg rl
handling a bit harier, this enables avoiding most overhead for root
blkcg.
* Queue fullness is properly per request_list but bdi isn't blkcg
aware yet, so congestion state currently just follows the root
blkcg. As writeback isn't aware of blkcg yet, this works okay for
async congestion but readahead may get the wrong signals. It's
better than blkcg completely collapsing with shared request_list but
needs to be improved with future changes.
* After this change, each block cgroup gets a full request pool making
resource consumption of each cgroup higher. This makes allowing
non-root users to create cgroups less desirable; however, note that
allowing non-root users to directly manage cgroups is already
severely broken regardless of this patch - each block cgroup
consumes kernel memory and skews IO weight (IO weights are not
hierarchical).
v2: queue-sysfs.txt updated and patch description udpated as suggested
by Vivek.
v3: blk_get_rl() wasn't checking error return from
blkg_lookup_create() and may cause oops on lookup failure. Fix it
by falling back to root_rl on blkg lookup failures. This problem
was spotted by Rakesh Iyer <rni@google.com>.
v4: Updated to accomodate 458f27a982 "block: Avoid missed wakeup in
request waitqueue". blk_drain_queue() now wakes up waiters on all
blkg->rl on the target queue.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-06-27 06:05:44 +08:00
|
|
|
/* request allocation list for this blkcg-q pair */
|
|
|
|
struct request_list rl;
|
2013-01-10 00:05:10 +08:00
|
|
|
|
2012-03-06 05:15:15 +08:00
|
|
|
/* reference count */
|
blkcg: fix use-after-free in __blkg_release_rcu() by making blkcg_gq refcnt an atomic_t
Hello,
So, this patch should do. Joe, Vivek, can one of you guys please
verify that the oops goes away with this patch?
Jens, the original thread can be read at
http://thread.gmane.org/gmane.linux.kernel/1720729
The fix converts blkg->refcnt from int to atomic_t. It does some
overhead but it should be minute compared to everything else which is
going on and the involved cacheline bouncing, so I think it's highly
unlikely to cause any noticeable difference. Also, the refcnt in
question should be converted to a perpcu_ref for blk-mq anyway, so the
atomic_t is likely to go away pretty soon anyway.
Thanks.
------- 8< -------
__blkg_release_rcu() may be invoked after the associated request_queue
is released with a RCU grace period inbetween. As such, the function
and callbacks invoked from it must not dereference the associated
request_queue. This is clearly indicated in the comment above the
function.
Unfortunately, while trying to fix a different issue, 2a4fd070ee85
("blkcg: move bulk of blkcg_gq release operations to the RCU
callback") ignored this and added [un]locking of @blkg->q->queue_lock
to __blkg_release_rcu(). This of course can cause oops as the
request_queue may be long gone by the time this code gets executed.
general protection fault: 0000 [#1] SMP
CPU: 21 PID: 30 Comm: rcuos/21 Not tainted 3.15.0 #1
Hardware name: Stratus ftServer 6400/G7LAZ, BIOS BIOS Version 6.3:57 12/25/2013
task: ffff880854021de0 ti: ffff88085403c000 task.ti: ffff88085403c000
RIP: 0010:[<ffffffff8162e9e5>] [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP: 0018:ffff88085403fdf0 EFLAGS: 00010086
RAX: 0000000000020000 RBX: 0000000000000010 RCX: 0000000000000000
RDX: 000060ef80008248 RSI: 0000000000000286 RDI: 6b6b6b6b6b6b6b6b
RBP: ffff88085403fdf0 R08: 0000000000000286 R09: 0000000000009f39
R10: 0000000000020001 R11: 0000000000020001 R12: ffff88103c17a130
R13: ffff88103c17a080 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88107fca0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000006e5ab8 CR3: 000000000193d000 CR4: 00000000000407e0
Stack:
ffff88085403fe18 ffffffff812cbfc2 ffff88103c17a130 0000000000000000
ffff88103c17a130 ffff88085403fec0 ffffffff810d1d28 ffff880854021de0
ffff880854021de0 ffff88107fcaec58 ffff88085403fe80 ffff88107fcaec30
Call Trace:
[<ffffffff812cbfc2>] __blkg_release_rcu+0x72/0x150
[<ffffffff810d1d28>] rcu_nocb_kthread+0x1e8/0x300
[<ffffffff81091d81>] kthread+0xe1/0x100
[<ffffffff8163813c>] ret_from_fork+0x7c/0xb0
Code: ff 47 04 48 8b 7d 08 be 00 02 00 00 e8 55 48 a4 ff 5d c3 0f 1f 00 66 66 66 66 90 55 48 89 e5
+fa 66 66 90 66 66 90 b8 00 00 02 00 <f0> 0f c1 07 89 c2 c1 ea 10 66 39 c2 75 02 5d c3 83 e2 fe 0f
+b7
RIP [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP <ffff88085403fdf0>
The request_queue locking was added because blkcg_gq->refcnt is an int
protected with the queue lock and __blkg_release_rcu() needs to put
the parent. Let's fix it by making blkcg_gq->refcnt an atomic_t and
dropping queue locking in the function.
Given the general heavy weight of the current request_queue and blkcg
operations, this is unlikely to cause any noticeable overhead.
Moreover, blkcg_gq->refcnt is likely to be converted to percpu_ref in
the near future, so whatever (most likely negligible) overhead it may
add is temporary.
Signed-off-by: Tejun Heo <tj@kernel.org>
Reported-by: Joe Lawrence <joe.lawrence@stratus.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Link: http://lkml.kernel.org/g/alpine.DEB.2.02.1406081816540.17948@jlaw-desktop.mno.stratus.com
Cc: stable@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2014-06-20 05:42:57 +08:00
|
|
|
atomic_t refcnt;
|
2009-12-04 01:59:49 +08:00
|
|
|
|
2013-01-10 00:05:12 +08:00
|
|
|
/* is this blkg online? protected by both blkcg and q locks */
|
|
|
|
bool online;
|
|
|
|
|
2012-04-17 04:57:24 +08:00
|
|
|
struct blkg_policy_data *pd[BLKCG_MAX_POLS];
|
2012-03-06 05:15:15 +08:00
|
|
|
|
2012-04-17 04:57:24 +08:00
|
|
|
struct rcu_head rcu_head;
|
2009-12-04 01:59:42 +08:00
|
|
|
};
|
|
|
|
|
block, cgroup: implement policy-specific per-blkcg data
The block IO (blkio) controller enables the block layer to provide service
guarantees in a hierarchical fashion. Specifically, service guarantees
are provided by registered request-accounting policies. As of now, a
proportional-share and a throttling policy are available. They are
implemented, respectively, by the CFQ I/O scheduler and the blk-throttle
subsystem. Unfortunately, as for adding new policies, the current
implementation of the block IO controller is only halfway ready to allow
new policies to be plugged in. This commit provides a solution to make
the block IO controller fully ready to handle new policies.
In what follows, we first describe briefly the current state, and then
list the changes made by this commit.
The throttling policy does not need any per-cgroup information to perform
its task. In contrast, the proportional share policy uses, for each cgroup,
both the weight assigned by the user to the cgroup, and a set of dynamically-
computed weights, one for each device.
The first, user-defined weight is stored in the blkcg data structure: the
block IO controller allocates a private blkcg data structure for each
cgroup in the blkio cgroups hierarchy (regardless of which policy is active).
In other words, the block IO controller internally mirrors the blkio cgroups
with private blkcg data structures.
On the other hand, for each cgroup and device, the corresponding dynamically-
computed weight is maintained in the following, different way. For each device,
the block IO controller keeps a private blkcg_gq structure for each cgroup in
blkio. In other words, block IO also keeps one private mirror copy of the blkio
cgroups hierarchy for each device, made of blkcg_gq structures.
Each blkcg_gq structure keeps per-policy information in a generic array of
dynamically-allocated 'dedicated' data structures, one for each registered
policy (so currently the array contains two elements). To be inserted into the
generic array, each dedicated data structure embeds a generic blkg_policy_data
structure. Consider now the array contained in the blkcg_gq structure
corresponding to a given pair of cgroup and device: one of the elements
of the array contains the dedicated data structure for the proportional-share
policy, and this dedicated data structure contains the dynamically-computed
weight for that pair of cgroup and device.
The generic strategy adopted for storing per-policy data in blkcg_gq structures
is already capable of handling new policies, whereas the one adopted with blkcg
structures is not, because per-policy data are hard-coded in the blkcg
structures themselves (currently only data related to the proportional-
share policy).
This commit addresses the above issues through the following changes:
. It generalizes blkcg structures so that per-policy data are stored in the same
way as in blkcg_gq structures.
Specifically, it lets also the blkcg structure store per-policy data in a
generic array of dynamically-allocated dedicated data structures. We will
refer to these data structures as blkcg dedicated data structures, to
distinguish them from the dedicated data structures inserted in the generic
arrays kept by blkcg_gq structures.
To allow blkcg dedicated data structures to be inserted in the generic array
inside a blkcg structure, this commit also introduces a new blkcg_policy_data
structure, which is the equivalent of blkg_policy_data for blkcg dedicated
data structures.
. It adds to the blkcg_policy structure, i.e., to the descriptor of a policy, a
cpd_size field and a cpd_init field, to be initialized by the policy with,
respectively, the size of the blkcg dedicated data structures, and the
address of a constructor function for blkcg dedicated data structures.
. It moves the CFQ-specific fields embedded in the blkcg data structure (i.e.,
the fields related to the proportional-share policy), into a new blkcg
dedicated data structure called cfq_group_data.
Signed-off-by: Paolo Valente <paolo.valente@unimore.it>
Signed-off-by: Arianna Avanzini <avanzini.arianna@gmail.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: Jens Axboe <axboe@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-06-06 05:38:42 +08:00
|
|
|
typedef void (blkcg_pol_init_cpd_fn)(const struct blkcg *blkcg);
|
2012-04-17 04:57:25 +08:00
|
|
|
typedef void (blkcg_pol_init_pd_fn)(struct blkcg_gq *blkg);
|
2013-01-10 00:05:12 +08:00
|
|
|
typedef void (blkcg_pol_online_pd_fn)(struct blkcg_gq *blkg);
|
|
|
|
typedef void (blkcg_pol_offline_pd_fn)(struct blkcg_gq *blkg);
|
2012-04-17 04:57:25 +08:00
|
|
|
typedef void (blkcg_pol_exit_pd_fn)(struct blkcg_gq *blkg);
|
|
|
|
typedef void (blkcg_pol_reset_pd_stats_fn)(struct blkcg_gq *blkg);
|
2009-12-04 23:36:42 +08:00
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg_policy {
|
2012-04-17 04:57:24 +08:00
|
|
|
int plid;
|
|
|
|
/* policy specific private data size */
|
2012-04-17 04:57:26 +08:00
|
|
|
size_t pd_size;
|
block, cgroup: implement policy-specific per-blkcg data
The block IO (blkio) controller enables the block layer to provide service
guarantees in a hierarchical fashion. Specifically, service guarantees
are provided by registered request-accounting policies. As of now, a
proportional-share and a throttling policy are available. They are
implemented, respectively, by the CFQ I/O scheduler and the blk-throttle
subsystem. Unfortunately, as for adding new policies, the current
implementation of the block IO controller is only halfway ready to allow
new policies to be plugged in. This commit provides a solution to make
the block IO controller fully ready to handle new policies.
In what follows, we first describe briefly the current state, and then
list the changes made by this commit.
The throttling policy does not need any per-cgroup information to perform
its task. In contrast, the proportional share policy uses, for each cgroup,
both the weight assigned by the user to the cgroup, and a set of dynamically-
computed weights, one for each device.
The first, user-defined weight is stored in the blkcg data structure: the
block IO controller allocates a private blkcg data structure for each
cgroup in the blkio cgroups hierarchy (regardless of which policy is active).
In other words, the block IO controller internally mirrors the blkio cgroups
with private blkcg data structures.
On the other hand, for each cgroup and device, the corresponding dynamically-
computed weight is maintained in the following, different way. For each device,
the block IO controller keeps a private blkcg_gq structure for each cgroup in
blkio. In other words, block IO also keeps one private mirror copy of the blkio
cgroups hierarchy for each device, made of blkcg_gq structures.
Each blkcg_gq structure keeps per-policy information in a generic array of
dynamically-allocated 'dedicated' data structures, one for each registered
policy (so currently the array contains two elements). To be inserted into the
generic array, each dedicated data structure embeds a generic blkg_policy_data
structure. Consider now the array contained in the blkcg_gq structure
corresponding to a given pair of cgroup and device: one of the elements
of the array contains the dedicated data structure for the proportional-share
policy, and this dedicated data structure contains the dynamically-computed
weight for that pair of cgroup and device.
The generic strategy adopted for storing per-policy data in blkcg_gq structures
is already capable of handling new policies, whereas the one adopted with blkcg
structures is not, because per-policy data are hard-coded in the blkcg
structures themselves (currently only data related to the proportional-
share policy).
This commit addresses the above issues through the following changes:
. It generalizes blkcg structures so that per-policy data are stored in the same
way as in blkcg_gq structures.
Specifically, it lets also the blkcg structure store per-policy data in a
generic array of dynamically-allocated dedicated data structures. We will
refer to these data structures as blkcg dedicated data structures, to
distinguish them from the dedicated data structures inserted in the generic
arrays kept by blkcg_gq structures.
To allow blkcg dedicated data structures to be inserted in the generic array
inside a blkcg structure, this commit also introduces a new blkcg_policy_data
structure, which is the equivalent of blkg_policy_data for blkcg dedicated
data structures.
. It adds to the blkcg_policy structure, i.e., to the descriptor of a policy, a
cpd_size field and a cpd_init field, to be initialized by the policy with,
respectively, the size of the blkcg dedicated data structures, and the
address of a constructor function for blkcg dedicated data structures.
. It moves the CFQ-specific fields embedded in the blkcg data structure (i.e.,
the fields related to the proportional-share policy), into a new blkcg
dedicated data structure called cfq_group_data.
Signed-off-by: Paolo Valente <paolo.valente@unimore.it>
Signed-off-by: Arianna Avanzini <avanzini.arianna@gmail.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: Jens Axboe <axboe@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-06-06 05:38:42 +08:00
|
|
|
/* policy specific per-blkcg data size */
|
|
|
|
size_t cpd_size;
|
2012-04-17 04:57:24 +08:00
|
|
|
/* cgroup files for the policy */
|
|
|
|
struct cftype *cftypes;
|
2012-04-17 04:57:27 +08:00
|
|
|
|
|
|
|
/* operations */
|
block, cgroup: implement policy-specific per-blkcg data
The block IO (blkio) controller enables the block layer to provide service
guarantees in a hierarchical fashion. Specifically, service guarantees
are provided by registered request-accounting policies. As of now, a
proportional-share and a throttling policy are available. They are
implemented, respectively, by the CFQ I/O scheduler and the blk-throttle
subsystem. Unfortunately, as for adding new policies, the current
implementation of the block IO controller is only halfway ready to allow
new policies to be plugged in. This commit provides a solution to make
the block IO controller fully ready to handle new policies.
In what follows, we first describe briefly the current state, and then
list the changes made by this commit.
The throttling policy does not need any per-cgroup information to perform
its task. In contrast, the proportional share policy uses, for each cgroup,
both the weight assigned by the user to the cgroup, and a set of dynamically-
computed weights, one for each device.
The first, user-defined weight is stored in the blkcg data structure: the
block IO controller allocates a private blkcg data structure for each
cgroup in the blkio cgroups hierarchy (regardless of which policy is active).
In other words, the block IO controller internally mirrors the blkio cgroups
with private blkcg data structures.
On the other hand, for each cgroup and device, the corresponding dynamically-
computed weight is maintained in the following, different way. For each device,
the block IO controller keeps a private blkcg_gq structure for each cgroup in
blkio. In other words, block IO also keeps one private mirror copy of the blkio
cgroups hierarchy for each device, made of blkcg_gq structures.
Each blkcg_gq structure keeps per-policy information in a generic array of
dynamically-allocated 'dedicated' data structures, one for each registered
policy (so currently the array contains two elements). To be inserted into the
generic array, each dedicated data structure embeds a generic blkg_policy_data
structure. Consider now the array contained in the blkcg_gq structure
corresponding to a given pair of cgroup and device: one of the elements
of the array contains the dedicated data structure for the proportional-share
policy, and this dedicated data structure contains the dynamically-computed
weight for that pair of cgroup and device.
The generic strategy adopted for storing per-policy data in blkcg_gq structures
is already capable of handling new policies, whereas the one adopted with blkcg
structures is not, because per-policy data are hard-coded in the blkcg
structures themselves (currently only data related to the proportional-
share policy).
This commit addresses the above issues through the following changes:
. It generalizes blkcg structures so that per-policy data are stored in the same
way as in blkcg_gq structures.
Specifically, it lets also the blkcg structure store per-policy data in a
generic array of dynamically-allocated dedicated data structures. We will
refer to these data structures as blkcg dedicated data structures, to
distinguish them from the dedicated data structures inserted in the generic
arrays kept by blkcg_gq structures.
To allow blkcg dedicated data structures to be inserted in the generic array
inside a blkcg structure, this commit also introduces a new blkcg_policy_data
structure, which is the equivalent of blkg_policy_data for blkcg dedicated
data structures.
. It adds to the blkcg_policy structure, i.e., to the descriptor of a policy, a
cpd_size field and a cpd_init field, to be initialized by the policy with,
respectively, the size of the blkcg dedicated data structures, and the
address of a constructor function for blkcg dedicated data structures.
. It moves the CFQ-specific fields embedded in the blkcg data structure (i.e.,
the fields related to the proportional-share policy), into a new blkcg
dedicated data structure called cfq_group_data.
Signed-off-by: Paolo Valente <paolo.valente@unimore.it>
Signed-off-by: Arianna Avanzini <avanzini.arianna@gmail.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: Jens Axboe <axboe@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-06-06 05:38:42 +08:00
|
|
|
blkcg_pol_init_cpd_fn *cpd_init_fn;
|
2012-04-17 04:57:27 +08:00
|
|
|
blkcg_pol_init_pd_fn *pd_init_fn;
|
2013-01-10 00:05:12 +08:00
|
|
|
blkcg_pol_online_pd_fn *pd_online_fn;
|
|
|
|
blkcg_pol_offline_pd_fn *pd_offline_fn;
|
2012-04-17 04:57:27 +08:00
|
|
|
blkcg_pol_exit_pd_fn *pd_exit_fn;
|
|
|
|
blkcg_pol_reset_pd_stats_fn *pd_reset_stats_fn;
|
2009-12-04 23:36:42 +08:00
|
|
|
};
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
extern struct blkcg blkcg_root;
|
2015-05-23 05:13:21 +08:00
|
|
|
extern struct cgroup_subsys_state * const blkcg_root_css;
|
2012-04-17 04:57:24 +08:00
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, struct request_queue *q);
|
|
|
|
struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
|
|
|
|
struct request_queue *q);
|
2012-04-17 04:57:24 +08:00
|
|
|
int blkcg_init_queue(struct request_queue *q);
|
|
|
|
void blkcg_drain_queue(struct request_queue *q);
|
|
|
|
void blkcg_exit_queue(struct request_queue *q);
|
2012-03-06 05:15:12 +08:00
|
|
|
|
2009-12-04 23:36:42 +08:00
|
|
|
/* Blkio controller policy registration */
|
2014-06-23 06:31:56 +08:00
|
|
|
int blkcg_policy_register(struct blkcg_policy *pol);
|
2012-04-17 04:57:25 +08:00
|
|
|
void blkcg_policy_unregister(struct blkcg_policy *pol);
|
2012-04-17 04:57:24 +08:00
|
|
|
int blkcg_activate_policy(struct request_queue *q,
|
2012-04-17 04:57:25 +08:00
|
|
|
const struct blkcg_policy *pol);
|
2012-04-17 04:57:24 +08:00
|
|
|
void blkcg_deactivate_policy(struct request_queue *q,
|
2012-04-17 04:57:25 +08:00
|
|
|
const struct blkcg_policy *pol);
|
2009-12-04 23:36:42 +08:00
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
|
2012-04-17 04:57:26 +08:00
|
|
|
u64 (*prfill)(struct seq_file *,
|
|
|
|
struct blkg_policy_data *, int),
|
2012-04-17 04:57:25 +08:00
|
|
|
const struct blkcg_policy *pol, int data,
|
2012-04-14 04:11:27 +08:00
|
|
|
bool show_total);
|
2012-04-17 04:57:26 +08:00
|
|
|
u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v);
|
|
|
|
u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
|
2012-04-02 05:38:43 +08:00
|
|
|
const struct blkg_rwstat *rwstat);
|
2012-04-17 04:57:26 +08:00
|
|
|
u64 blkg_prfill_stat(struct seq_file *sf, struct blkg_policy_data *pd, int off);
|
|
|
|
u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
|
|
|
|
int off);
|
2012-04-02 05:38:43 +08:00
|
|
|
|
2013-01-10 00:05:12 +08:00
|
|
|
u64 blkg_stat_recursive_sum(struct blkg_policy_data *pd, int off);
|
|
|
|
struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkg_policy_data *pd,
|
|
|
|
int off);
|
|
|
|
|
2012-04-02 05:38:43 +08:00
|
|
|
struct blkg_conf_ctx {
|
2012-04-17 04:57:24 +08:00
|
|
|
struct gendisk *disk;
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg_gq *blkg;
|
2012-04-17 04:57:24 +08:00
|
|
|
u64 v;
|
2012-04-02 05:38:43 +08:00
|
|
|
};
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
|
|
|
|
const char *input, struct blkg_conf_ctx *ctx);
|
2012-04-02 05:38:43 +08:00
|
|
|
void blkg_conf_finish(struct blkg_conf_ctx *ctx);
|
|
|
|
|
|
|
|
|
2013-08-09 08:11:23 +08:00
|
|
|
static inline struct blkcg *css_to_blkcg(struct cgroup_subsys_state *css)
|
|
|
|
{
|
|
|
|
return css ? container_of(css, struct blkcg, css) : NULL;
|
|
|
|
}
|
|
|
|
|
2012-06-05 11:40:57 +08:00
|
|
|
static inline struct blkcg *task_blkcg(struct task_struct *tsk)
|
|
|
|
{
|
2014-02-08 23:36:58 +08:00
|
|
|
return css_to_blkcg(task_css(tsk, blkio_cgrp_id));
|
2012-06-05 11:40:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct blkcg *bio_blkcg(struct bio *bio)
|
|
|
|
{
|
|
|
|
if (bio && bio->bi_css)
|
2013-08-09 08:11:23 +08:00
|
|
|
return css_to_blkcg(bio->bi_css);
|
2012-06-05 11:40:57 +08:00
|
|
|
return task_blkcg(current);
|
|
|
|
}
|
|
|
|
|
2015-05-23 05:13:23 +08:00
|
|
|
static inline struct cgroup_subsys_state *
|
|
|
|
task_get_blkcg_css(struct task_struct *task)
|
|
|
|
{
|
|
|
|
return task_get_css(task, blkio_cgrp_id);
|
|
|
|
}
|
|
|
|
|
2013-01-10 00:05:10 +08:00
|
|
|
/**
|
|
|
|
* blkcg_parent - get the parent of a blkcg
|
|
|
|
* @blkcg: blkcg of interest
|
|
|
|
*
|
|
|
|
* Return the parent blkcg of @blkcg. Can be called anytime.
|
|
|
|
*/
|
|
|
|
static inline struct blkcg *blkcg_parent(struct blkcg *blkcg)
|
|
|
|
{
|
2014-05-17 01:22:48 +08:00
|
|
|
return css_to_blkcg(blkcg->css.parent);
|
2013-01-10 00:05:10 +08:00
|
|
|
}
|
|
|
|
|
2012-03-06 05:15:14 +08:00
|
|
|
/**
|
|
|
|
* blkg_to_pdata - get policy private data
|
|
|
|
* @blkg: blkg of interest
|
|
|
|
* @pol: policy of interest
|
|
|
|
*
|
|
|
|
* Return pointer to private data associated with the @blkg-@pol pair.
|
|
|
|
*/
|
2012-04-17 04:57:26 +08:00
|
|
|
static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
|
|
|
|
struct blkcg_policy *pol)
|
2012-03-06 05:15:14 +08:00
|
|
|
{
|
2012-04-17 04:57:26 +08:00
|
|
|
return blkg ? blkg->pd[pol->plid] : NULL;
|
2012-03-06 05:15:14 +08:00
|
|
|
}
|
|
|
|
|
block, cgroup: implement policy-specific per-blkcg data
The block IO (blkio) controller enables the block layer to provide service
guarantees in a hierarchical fashion. Specifically, service guarantees
are provided by registered request-accounting policies. As of now, a
proportional-share and a throttling policy are available. They are
implemented, respectively, by the CFQ I/O scheduler and the blk-throttle
subsystem. Unfortunately, as for adding new policies, the current
implementation of the block IO controller is only halfway ready to allow
new policies to be plugged in. This commit provides a solution to make
the block IO controller fully ready to handle new policies.
In what follows, we first describe briefly the current state, and then
list the changes made by this commit.
The throttling policy does not need any per-cgroup information to perform
its task. In contrast, the proportional share policy uses, for each cgroup,
both the weight assigned by the user to the cgroup, and a set of dynamically-
computed weights, one for each device.
The first, user-defined weight is stored in the blkcg data structure: the
block IO controller allocates a private blkcg data structure for each
cgroup in the blkio cgroups hierarchy (regardless of which policy is active).
In other words, the block IO controller internally mirrors the blkio cgroups
with private blkcg data structures.
On the other hand, for each cgroup and device, the corresponding dynamically-
computed weight is maintained in the following, different way. For each device,
the block IO controller keeps a private blkcg_gq structure for each cgroup in
blkio. In other words, block IO also keeps one private mirror copy of the blkio
cgroups hierarchy for each device, made of blkcg_gq structures.
Each blkcg_gq structure keeps per-policy information in a generic array of
dynamically-allocated 'dedicated' data structures, one for each registered
policy (so currently the array contains two elements). To be inserted into the
generic array, each dedicated data structure embeds a generic blkg_policy_data
structure. Consider now the array contained in the blkcg_gq structure
corresponding to a given pair of cgroup and device: one of the elements
of the array contains the dedicated data structure for the proportional-share
policy, and this dedicated data structure contains the dynamically-computed
weight for that pair of cgroup and device.
The generic strategy adopted for storing per-policy data in blkcg_gq structures
is already capable of handling new policies, whereas the one adopted with blkcg
structures is not, because per-policy data are hard-coded in the blkcg
structures themselves (currently only data related to the proportional-
share policy).
This commit addresses the above issues through the following changes:
. It generalizes blkcg structures so that per-policy data are stored in the same
way as in blkcg_gq structures.
Specifically, it lets also the blkcg structure store per-policy data in a
generic array of dynamically-allocated dedicated data structures. We will
refer to these data structures as blkcg dedicated data structures, to
distinguish them from the dedicated data structures inserted in the generic
arrays kept by blkcg_gq structures.
To allow blkcg dedicated data structures to be inserted in the generic array
inside a blkcg structure, this commit also introduces a new blkcg_policy_data
structure, which is the equivalent of blkg_policy_data for blkcg dedicated
data structures.
. It adds to the blkcg_policy structure, i.e., to the descriptor of a policy, a
cpd_size field and a cpd_init field, to be initialized by the policy with,
respectively, the size of the blkcg dedicated data structures, and the
address of a constructor function for blkcg dedicated data structures.
. It moves the CFQ-specific fields embedded in the blkcg data structure (i.e.,
the fields related to the proportional-share policy), into a new blkcg
dedicated data structure called cfq_group_data.
Signed-off-by: Paolo Valente <paolo.valente@unimore.it>
Signed-off-by: Arianna Avanzini <avanzini.arianna@gmail.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: Jens Axboe <axboe@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-06-06 05:38:42 +08:00
|
|
|
static inline struct blkcg_policy_data *blkcg_to_cpd(struct blkcg *blkcg,
|
|
|
|
struct blkcg_policy *pol)
|
|
|
|
{
|
|
|
|
return blkcg ? blkcg->pd[pol->plid] : NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-06 05:15:14 +08:00
|
|
|
/**
|
|
|
|
* pdata_to_blkg - get blkg associated with policy private data
|
2012-04-17 04:57:26 +08:00
|
|
|
* @pd: policy private data of interest
|
2012-03-06 05:15:14 +08:00
|
|
|
*
|
2012-04-17 04:57:26 +08:00
|
|
|
* @pd is policy private data. Determine the blkg it's associated with.
|
2012-03-06 05:15:14 +08:00
|
|
|
*/
|
2012-04-17 04:57:26 +08:00
|
|
|
static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd)
|
2012-03-06 05:15:14 +08:00
|
|
|
{
|
2012-04-17 04:57:26 +08:00
|
|
|
return pd ? pd->blkg : NULL;
|
2012-03-06 05:15:14 +08:00
|
|
|
}
|
|
|
|
|
2012-04-17 04:57:23 +08:00
|
|
|
/**
|
|
|
|
* blkg_path - format cgroup path of blkg
|
|
|
|
* @blkg: blkg of interest
|
|
|
|
* @buf: target buffer
|
|
|
|
* @buflen: target buffer length
|
|
|
|
*
|
|
|
|
* Format the path of the cgroup of @blkg into @buf.
|
|
|
|
*/
|
2012-04-17 04:57:25 +08:00
|
|
|
static inline int blkg_path(struct blkcg_gq *blkg, char *buf, int buflen)
|
2010-04-27 01:27:56 +08:00
|
|
|
{
|
2014-02-12 22:29:50 +08:00
|
|
|
char *p;
|
2012-04-17 04:57:23 +08:00
|
|
|
|
2014-02-12 22:29:50 +08:00
|
|
|
p = cgroup_path(blkg->blkcg->css.cgroup, buf, buflen);
|
|
|
|
if (!p) {
|
2012-04-17 04:57:23 +08:00
|
|
|
strncpy(buf, "<unavailable>", buflen);
|
2014-02-12 22:29:50 +08:00
|
|
|
return -ENAMETOOLONG;
|
|
|
|
}
|
|
|
|
|
|
|
|
memmove(buf, p, buf + buflen - p);
|
|
|
|
return 0;
|
2010-04-27 01:27:56 +08:00
|
|
|
}
|
|
|
|
|
2012-03-06 05:15:15 +08:00
|
|
|
/**
|
|
|
|
* blkg_get - get a blkg reference
|
|
|
|
* @blkg: blkg to get
|
|
|
|
*
|
blkcg: fix use-after-free in __blkg_release_rcu() by making blkcg_gq refcnt an atomic_t
Hello,
So, this patch should do. Joe, Vivek, can one of you guys please
verify that the oops goes away with this patch?
Jens, the original thread can be read at
http://thread.gmane.org/gmane.linux.kernel/1720729
The fix converts blkg->refcnt from int to atomic_t. It does some
overhead but it should be minute compared to everything else which is
going on and the involved cacheline bouncing, so I think it's highly
unlikely to cause any noticeable difference. Also, the refcnt in
question should be converted to a perpcu_ref for blk-mq anyway, so the
atomic_t is likely to go away pretty soon anyway.
Thanks.
------- 8< -------
__blkg_release_rcu() may be invoked after the associated request_queue
is released with a RCU grace period inbetween. As such, the function
and callbacks invoked from it must not dereference the associated
request_queue. This is clearly indicated in the comment above the
function.
Unfortunately, while trying to fix a different issue, 2a4fd070ee85
("blkcg: move bulk of blkcg_gq release operations to the RCU
callback") ignored this and added [un]locking of @blkg->q->queue_lock
to __blkg_release_rcu(). This of course can cause oops as the
request_queue may be long gone by the time this code gets executed.
general protection fault: 0000 [#1] SMP
CPU: 21 PID: 30 Comm: rcuos/21 Not tainted 3.15.0 #1
Hardware name: Stratus ftServer 6400/G7LAZ, BIOS BIOS Version 6.3:57 12/25/2013
task: ffff880854021de0 ti: ffff88085403c000 task.ti: ffff88085403c000
RIP: 0010:[<ffffffff8162e9e5>] [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP: 0018:ffff88085403fdf0 EFLAGS: 00010086
RAX: 0000000000020000 RBX: 0000000000000010 RCX: 0000000000000000
RDX: 000060ef80008248 RSI: 0000000000000286 RDI: 6b6b6b6b6b6b6b6b
RBP: ffff88085403fdf0 R08: 0000000000000286 R09: 0000000000009f39
R10: 0000000000020001 R11: 0000000000020001 R12: ffff88103c17a130
R13: ffff88103c17a080 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88107fca0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000006e5ab8 CR3: 000000000193d000 CR4: 00000000000407e0
Stack:
ffff88085403fe18 ffffffff812cbfc2 ffff88103c17a130 0000000000000000
ffff88103c17a130 ffff88085403fec0 ffffffff810d1d28 ffff880854021de0
ffff880854021de0 ffff88107fcaec58 ffff88085403fe80 ffff88107fcaec30
Call Trace:
[<ffffffff812cbfc2>] __blkg_release_rcu+0x72/0x150
[<ffffffff810d1d28>] rcu_nocb_kthread+0x1e8/0x300
[<ffffffff81091d81>] kthread+0xe1/0x100
[<ffffffff8163813c>] ret_from_fork+0x7c/0xb0
Code: ff 47 04 48 8b 7d 08 be 00 02 00 00 e8 55 48 a4 ff 5d c3 0f 1f 00 66 66 66 66 90 55 48 89 e5
+fa 66 66 90 66 66 90 b8 00 00 02 00 <f0> 0f c1 07 89 c2 c1 ea 10 66 39 c2 75 02 5d c3 83 e2 fe 0f
+b7
RIP [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP <ffff88085403fdf0>
The request_queue locking was added because blkcg_gq->refcnt is an int
protected with the queue lock and __blkg_release_rcu() needs to put
the parent. Let's fix it by making blkcg_gq->refcnt an atomic_t and
dropping queue locking in the function.
Given the general heavy weight of the current request_queue and blkcg
operations, this is unlikely to cause any noticeable overhead.
Moreover, blkcg_gq->refcnt is likely to be converted to percpu_ref in
the near future, so whatever (most likely negligible) overhead it may
add is temporary.
Signed-off-by: Tejun Heo <tj@kernel.org>
Reported-by: Joe Lawrence <joe.lawrence@stratus.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Link: http://lkml.kernel.org/g/alpine.DEB.2.02.1406081816540.17948@jlaw-desktop.mno.stratus.com
Cc: stable@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2014-06-20 05:42:57 +08:00
|
|
|
* The caller should be holding an existing reference.
|
2012-03-06 05:15:15 +08:00
|
|
|
*/
|
2012-04-17 04:57:25 +08:00
|
|
|
static inline void blkg_get(struct blkcg_gq *blkg)
|
2012-03-06 05:15:15 +08:00
|
|
|
{
|
blkcg: fix use-after-free in __blkg_release_rcu() by making blkcg_gq refcnt an atomic_t
Hello,
So, this patch should do. Joe, Vivek, can one of you guys please
verify that the oops goes away with this patch?
Jens, the original thread can be read at
http://thread.gmane.org/gmane.linux.kernel/1720729
The fix converts blkg->refcnt from int to atomic_t. It does some
overhead but it should be minute compared to everything else which is
going on and the involved cacheline bouncing, so I think it's highly
unlikely to cause any noticeable difference. Also, the refcnt in
question should be converted to a perpcu_ref for blk-mq anyway, so the
atomic_t is likely to go away pretty soon anyway.
Thanks.
------- 8< -------
__blkg_release_rcu() may be invoked after the associated request_queue
is released with a RCU grace period inbetween. As such, the function
and callbacks invoked from it must not dereference the associated
request_queue. This is clearly indicated in the comment above the
function.
Unfortunately, while trying to fix a different issue, 2a4fd070ee85
("blkcg: move bulk of blkcg_gq release operations to the RCU
callback") ignored this and added [un]locking of @blkg->q->queue_lock
to __blkg_release_rcu(). This of course can cause oops as the
request_queue may be long gone by the time this code gets executed.
general protection fault: 0000 [#1] SMP
CPU: 21 PID: 30 Comm: rcuos/21 Not tainted 3.15.0 #1
Hardware name: Stratus ftServer 6400/G7LAZ, BIOS BIOS Version 6.3:57 12/25/2013
task: ffff880854021de0 ti: ffff88085403c000 task.ti: ffff88085403c000
RIP: 0010:[<ffffffff8162e9e5>] [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP: 0018:ffff88085403fdf0 EFLAGS: 00010086
RAX: 0000000000020000 RBX: 0000000000000010 RCX: 0000000000000000
RDX: 000060ef80008248 RSI: 0000000000000286 RDI: 6b6b6b6b6b6b6b6b
RBP: ffff88085403fdf0 R08: 0000000000000286 R09: 0000000000009f39
R10: 0000000000020001 R11: 0000000000020001 R12: ffff88103c17a130
R13: ffff88103c17a080 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88107fca0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000006e5ab8 CR3: 000000000193d000 CR4: 00000000000407e0
Stack:
ffff88085403fe18 ffffffff812cbfc2 ffff88103c17a130 0000000000000000
ffff88103c17a130 ffff88085403fec0 ffffffff810d1d28 ffff880854021de0
ffff880854021de0 ffff88107fcaec58 ffff88085403fe80 ffff88107fcaec30
Call Trace:
[<ffffffff812cbfc2>] __blkg_release_rcu+0x72/0x150
[<ffffffff810d1d28>] rcu_nocb_kthread+0x1e8/0x300
[<ffffffff81091d81>] kthread+0xe1/0x100
[<ffffffff8163813c>] ret_from_fork+0x7c/0xb0
Code: ff 47 04 48 8b 7d 08 be 00 02 00 00 e8 55 48 a4 ff 5d c3 0f 1f 00 66 66 66 66 90 55 48 89 e5
+fa 66 66 90 66 66 90 b8 00 00 02 00 <f0> 0f c1 07 89 c2 c1 ea 10 66 39 c2 75 02 5d c3 83 e2 fe 0f
+b7
RIP [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP <ffff88085403fdf0>
The request_queue locking was added because blkcg_gq->refcnt is an int
protected with the queue lock and __blkg_release_rcu() needs to put
the parent. Let's fix it by making blkcg_gq->refcnt an atomic_t and
dropping queue locking in the function.
Given the general heavy weight of the current request_queue and blkcg
operations, this is unlikely to cause any noticeable overhead.
Moreover, blkcg_gq->refcnt is likely to be converted to percpu_ref in
the near future, so whatever (most likely negligible) overhead it may
add is temporary.
Signed-off-by: Tejun Heo <tj@kernel.org>
Reported-by: Joe Lawrence <joe.lawrence@stratus.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Link: http://lkml.kernel.org/g/alpine.DEB.2.02.1406081816540.17948@jlaw-desktop.mno.stratus.com
Cc: stable@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2014-06-20 05:42:57 +08:00
|
|
|
WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
|
|
|
|
atomic_inc(&blkg->refcnt);
|
2012-03-06 05:15:15 +08:00
|
|
|
}
|
|
|
|
|
2013-05-15 04:52:31 +08:00
|
|
|
void __blkg_release_rcu(struct rcu_head *rcu);
|
2012-03-06 05:15:15 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* blkg_put - put a blkg reference
|
|
|
|
* @blkg: blkg to put
|
|
|
|
*/
|
2012-04-17 04:57:25 +08:00
|
|
|
static inline void blkg_put(struct blkcg_gq *blkg)
|
2012-03-06 05:15:15 +08:00
|
|
|
{
|
blkcg: fix use-after-free in __blkg_release_rcu() by making blkcg_gq refcnt an atomic_t
Hello,
So, this patch should do. Joe, Vivek, can one of you guys please
verify that the oops goes away with this patch?
Jens, the original thread can be read at
http://thread.gmane.org/gmane.linux.kernel/1720729
The fix converts blkg->refcnt from int to atomic_t. It does some
overhead but it should be minute compared to everything else which is
going on and the involved cacheline bouncing, so I think it's highly
unlikely to cause any noticeable difference. Also, the refcnt in
question should be converted to a perpcu_ref for blk-mq anyway, so the
atomic_t is likely to go away pretty soon anyway.
Thanks.
------- 8< -------
__blkg_release_rcu() may be invoked after the associated request_queue
is released with a RCU grace period inbetween. As such, the function
and callbacks invoked from it must not dereference the associated
request_queue. This is clearly indicated in the comment above the
function.
Unfortunately, while trying to fix a different issue, 2a4fd070ee85
("blkcg: move bulk of blkcg_gq release operations to the RCU
callback") ignored this and added [un]locking of @blkg->q->queue_lock
to __blkg_release_rcu(). This of course can cause oops as the
request_queue may be long gone by the time this code gets executed.
general protection fault: 0000 [#1] SMP
CPU: 21 PID: 30 Comm: rcuos/21 Not tainted 3.15.0 #1
Hardware name: Stratus ftServer 6400/G7LAZ, BIOS BIOS Version 6.3:57 12/25/2013
task: ffff880854021de0 ti: ffff88085403c000 task.ti: ffff88085403c000
RIP: 0010:[<ffffffff8162e9e5>] [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP: 0018:ffff88085403fdf0 EFLAGS: 00010086
RAX: 0000000000020000 RBX: 0000000000000010 RCX: 0000000000000000
RDX: 000060ef80008248 RSI: 0000000000000286 RDI: 6b6b6b6b6b6b6b6b
RBP: ffff88085403fdf0 R08: 0000000000000286 R09: 0000000000009f39
R10: 0000000000020001 R11: 0000000000020001 R12: ffff88103c17a130
R13: ffff88103c17a080 R14: 0000000000000000 R15: 0000000000000000
FS: 0000000000000000(0000) GS:ffff88107fca0000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00000000006e5ab8 CR3: 000000000193d000 CR4: 00000000000407e0
Stack:
ffff88085403fe18 ffffffff812cbfc2 ffff88103c17a130 0000000000000000
ffff88103c17a130 ffff88085403fec0 ffffffff810d1d28 ffff880854021de0
ffff880854021de0 ffff88107fcaec58 ffff88085403fe80 ffff88107fcaec30
Call Trace:
[<ffffffff812cbfc2>] __blkg_release_rcu+0x72/0x150
[<ffffffff810d1d28>] rcu_nocb_kthread+0x1e8/0x300
[<ffffffff81091d81>] kthread+0xe1/0x100
[<ffffffff8163813c>] ret_from_fork+0x7c/0xb0
Code: ff 47 04 48 8b 7d 08 be 00 02 00 00 e8 55 48 a4 ff 5d c3 0f 1f 00 66 66 66 66 90 55 48 89 e5
+fa 66 66 90 66 66 90 b8 00 00 02 00 <f0> 0f c1 07 89 c2 c1 ea 10 66 39 c2 75 02 5d c3 83 e2 fe 0f
+b7
RIP [<ffffffff8162e9e5>] _raw_spin_lock_irq+0x15/0x60
RSP <ffff88085403fdf0>
The request_queue locking was added because blkcg_gq->refcnt is an int
protected with the queue lock and __blkg_release_rcu() needs to put
the parent. Let's fix it by making blkcg_gq->refcnt an atomic_t and
dropping queue locking in the function.
Given the general heavy weight of the current request_queue and blkcg
operations, this is unlikely to cause any noticeable overhead.
Moreover, blkcg_gq->refcnt is likely to be converted to percpu_ref in
the near future, so whatever (most likely negligible) overhead it may
add is temporary.
Signed-off-by: Tejun Heo <tj@kernel.org>
Reported-by: Joe Lawrence <joe.lawrence@stratus.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Link: http://lkml.kernel.org/g/alpine.DEB.2.02.1406081816540.17948@jlaw-desktop.mno.stratus.com
Cc: stable@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2014-06-20 05:42:57 +08:00
|
|
|
WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
|
|
|
|
if (atomic_dec_and_test(&blkg->refcnt))
|
2013-05-15 04:52:31 +08:00
|
|
|
call_rcu(&blkg->rcu_head, __blkg_release_rcu);
|
2012-03-06 05:15:15 +08:00
|
|
|
}
|
|
|
|
|
2013-05-15 04:52:30 +08:00
|
|
|
struct blkcg_gq *__blkg_lookup(struct blkcg *blkcg, struct request_queue *q,
|
|
|
|
bool update_hint);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkg_for_each_descendant_pre - pre-order walk of a blkg's descendants
|
|
|
|
* @d_blkg: loop cursor pointing to the current descendant
|
2013-08-09 08:11:25 +08:00
|
|
|
* @pos_css: used for iteration
|
2013-05-15 04:52:30 +08:00
|
|
|
* @p_blkg: target blkg to walk descendants of
|
|
|
|
*
|
|
|
|
* Walk @c_blkg through the descendants of @p_blkg. Must be used with RCU
|
|
|
|
* read locked. If called under either blkcg or queue lock, the iteration
|
|
|
|
* is guaranteed to include all and only online blkgs. The caller may
|
2013-08-09 08:11:25 +08:00
|
|
|
* update @pos_css by calling css_rightmost_descendant() to skip subtree.
|
2013-08-09 08:11:27 +08:00
|
|
|
* @p_blkg is included in the iteration and the first node to be visited.
|
2013-05-15 04:52:30 +08:00
|
|
|
*/
|
2013-08-09 08:11:25 +08:00
|
|
|
#define blkg_for_each_descendant_pre(d_blkg, pos_css, p_blkg) \
|
|
|
|
css_for_each_descendant_pre((pos_css), &(p_blkg)->blkcg->css) \
|
|
|
|
if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css), \
|
2013-05-15 04:52:30 +08:00
|
|
|
(p_blkg)->q, false)))
|
|
|
|
|
2013-05-15 04:52:31 +08:00
|
|
|
/**
|
|
|
|
* blkg_for_each_descendant_post - post-order walk of a blkg's descendants
|
|
|
|
* @d_blkg: loop cursor pointing to the current descendant
|
2013-08-09 08:11:25 +08:00
|
|
|
* @pos_css: used for iteration
|
2013-05-15 04:52:31 +08:00
|
|
|
* @p_blkg: target blkg to walk descendants of
|
|
|
|
*
|
|
|
|
* Similar to blkg_for_each_descendant_pre() but performs post-order
|
2013-08-09 08:11:27 +08:00
|
|
|
* traversal instead. Synchronization rules are the same. @p_blkg is
|
|
|
|
* included in the iteration and the last node to be visited.
|
2013-05-15 04:52:31 +08:00
|
|
|
*/
|
2013-08-09 08:11:25 +08:00
|
|
|
#define blkg_for_each_descendant_post(d_blkg, pos_css, p_blkg) \
|
|
|
|
css_for_each_descendant_post((pos_css), &(p_blkg)->blkcg->css) \
|
|
|
|
if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css), \
|
2013-05-15 04:52:31 +08:00
|
|
|
(p_blkg)->q, false)))
|
|
|
|
|
blkcg: implement per-blkg request allocation
Currently, request_queue has one request_list to allocate requests
from regardless of blkcg of the IO being issued. When the unified
request pool is used up, cfq proportional IO limits become meaningless
- whoever grabs the next request being freed wins the race regardless
of the configured weights.
This can be easily demonstrated by creating a blkio cgroup w/ very low
weight, put a program which can issue a lot of random direct IOs there
and running a sequential IO from a different cgroup. As soon as the
request pool is used up, the sequential IO bandwidth crashes.
This patch implements per-blkg request_list. Each blkg has its own
request_list and any IO allocates its request from the matching blkg
making blkcgs completely isolated in terms of request allocation.
* Root blkcg uses the request_list embedded in each request_queue,
which was renamed to @q->root_rl from @q->rq. While making blkcg rl
handling a bit harier, this enables avoiding most overhead for root
blkcg.
* Queue fullness is properly per request_list but bdi isn't blkcg
aware yet, so congestion state currently just follows the root
blkcg. As writeback isn't aware of blkcg yet, this works okay for
async congestion but readahead may get the wrong signals. It's
better than blkcg completely collapsing with shared request_list but
needs to be improved with future changes.
* After this change, each block cgroup gets a full request pool making
resource consumption of each cgroup higher. This makes allowing
non-root users to create cgroups less desirable; however, note that
allowing non-root users to directly manage cgroups is already
severely broken regardless of this patch - each block cgroup
consumes kernel memory and skews IO weight (IO weights are not
hierarchical).
v2: queue-sysfs.txt updated and patch description udpated as suggested
by Vivek.
v3: blk_get_rl() wasn't checking error return from
blkg_lookup_create() and may cause oops on lookup failure. Fix it
by falling back to root_rl on blkg lookup failures. This problem
was spotted by Rakesh Iyer <rni@google.com>.
v4: Updated to accomodate 458f27a982 "block: Avoid missed wakeup in
request waitqueue". blk_drain_queue() now wakes up waiters on all
blkg->rl on the target queue.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-06-27 06:05:44 +08:00
|
|
|
/**
|
|
|
|
* blk_get_rl - get request_list to use
|
|
|
|
* @q: request_queue of interest
|
|
|
|
* @bio: bio which will be attached to the allocated request (may be %NULL)
|
|
|
|
*
|
|
|
|
* The caller wants to allocate a request from @q to use for @bio. Find
|
|
|
|
* the request_list to use and obtain a reference on it. Should be called
|
|
|
|
* under queue_lock. This function is guaranteed to return non-%NULL
|
|
|
|
* request_list.
|
|
|
|
*/
|
|
|
|
static inline struct request_list *blk_get_rl(struct request_queue *q,
|
|
|
|
struct bio *bio)
|
|
|
|
{
|
|
|
|
struct blkcg *blkcg;
|
|
|
|
struct blkcg_gq *blkg;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
blkcg = bio_blkcg(bio);
|
|
|
|
|
|
|
|
/* bypass blkg lookup and use @q->root_rl directly for root */
|
|
|
|
if (blkcg == &blkcg_root)
|
|
|
|
goto root_rl;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to use blkg->rl. blkg lookup may fail under memory pressure
|
|
|
|
* or if either the blkcg or queue is going away. Fall back to
|
|
|
|
* root_rl in such cases.
|
|
|
|
*/
|
|
|
|
blkg = blkg_lookup_create(blkcg, q);
|
|
|
|
if (unlikely(IS_ERR(blkg)))
|
|
|
|
goto root_rl;
|
|
|
|
|
|
|
|
blkg_get(blkg);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return &blkg->rl;
|
|
|
|
root_rl:
|
|
|
|
rcu_read_unlock();
|
|
|
|
return &q->root_rl;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blk_put_rl - put request_list
|
|
|
|
* @rl: request_list to put
|
|
|
|
*
|
|
|
|
* Put the reference acquired by blk_get_rl(). Should be called under
|
|
|
|
* queue_lock.
|
|
|
|
*/
|
|
|
|
static inline void blk_put_rl(struct request_list *rl)
|
|
|
|
{
|
|
|
|
/* root_rl may not have blkg set */
|
|
|
|
if (rl->blkg && rl->blkg->blkcg != &blkcg_root)
|
|
|
|
blkg_put(rl->blkg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blk_rq_set_rl - associate a request with a request_list
|
|
|
|
* @rq: request of interest
|
|
|
|
* @rl: target request_list
|
|
|
|
*
|
|
|
|
* Associate @rq with @rl so that accounting and freeing can know the
|
|
|
|
* request_list @rq came from.
|
|
|
|
*/
|
|
|
|
static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl)
|
|
|
|
{
|
|
|
|
rq->rl = rl;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blk_rq_rl - return the request_list a request came from
|
|
|
|
* @rq: request of interest
|
|
|
|
*
|
|
|
|
* Return the request_list @rq is allocated from.
|
|
|
|
*/
|
|
|
|
static inline struct request_list *blk_rq_rl(struct request *rq)
|
|
|
|
{
|
|
|
|
return rq->rl;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct request_list *__blk_queue_next_rl(struct request_list *rl,
|
|
|
|
struct request_queue *q);
|
|
|
|
/**
|
|
|
|
* blk_queue_for_each_rl - iterate through all request_lists of a request_queue
|
|
|
|
*
|
|
|
|
* Should be used under queue_lock.
|
|
|
|
*/
|
|
|
|
#define blk_queue_for_each_rl(rl, q) \
|
|
|
|
for ((rl) = &(q)->root_rl; (rl); (rl) = __blk_queue_next_rl((rl), (q)))
|
|
|
|
|
2013-11-13 11:42:14 +08:00
|
|
|
static inline void blkg_stat_init(struct blkg_stat *stat)
|
|
|
|
{
|
|
|
|
u64_stats_init(&stat->syncp);
|
|
|
|
}
|
|
|
|
|
2012-04-02 05:38:42 +08:00
|
|
|
/**
|
|
|
|
* blkg_stat_add - add a value to a blkg_stat
|
|
|
|
* @stat: target blkg_stat
|
|
|
|
* @val: value to add
|
|
|
|
*
|
|
|
|
* Add @val to @stat. The caller is responsible for synchronizing calls to
|
|
|
|
* this function.
|
|
|
|
*/
|
|
|
|
static inline void blkg_stat_add(struct blkg_stat *stat, uint64_t val)
|
|
|
|
{
|
|
|
|
u64_stats_update_begin(&stat->syncp);
|
|
|
|
stat->cnt += val;
|
|
|
|
u64_stats_update_end(&stat->syncp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkg_stat_read - read the current value of a blkg_stat
|
|
|
|
* @stat: blkg_stat to read
|
|
|
|
*
|
|
|
|
* Read the current value of @stat. This function can be called without
|
|
|
|
* synchroniztion and takes care of u64 atomicity.
|
|
|
|
*/
|
|
|
|
static inline uint64_t blkg_stat_read(struct blkg_stat *stat)
|
|
|
|
{
|
|
|
|
unsigned int start;
|
|
|
|
uint64_t v;
|
|
|
|
|
|
|
|
do {
|
2014-03-14 12:26:42 +08:00
|
|
|
start = u64_stats_fetch_begin_irq(&stat->syncp);
|
2012-04-02 05:38:42 +08:00
|
|
|
v = stat->cnt;
|
2014-03-14 12:26:42 +08:00
|
|
|
} while (u64_stats_fetch_retry_irq(&stat->syncp, start));
|
2012-04-02 05:38:42 +08:00
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkg_stat_reset - reset a blkg_stat
|
|
|
|
* @stat: blkg_stat to reset
|
|
|
|
*/
|
|
|
|
static inline void blkg_stat_reset(struct blkg_stat *stat)
|
|
|
|
{
|
|
|
|
stat->cnt = 0;
|
|
|
|
}
|
|
|
|
|
2013-01-10 00:05:12 +08:00
|
|
|
/**
|
|
|
|
* blkg_stat_merge - merge a blkg_stat into another
|
|
|
|
* @to: the destination blkg_stat
|
|
|
|
* @from: the source
|
|
|
|
*
|
|
|
|
* Add @from's count to @to.
|
|
|
|
*/
|
|
|
|
static inline void blkg_stat_merge(struct blkg_stat *to, struct blkg_stat *from)
|
|
|
|
{
|
|
|
|
blkg_stat_add(to, blkg_stat_read(from));
|
|
|
|
}
|
|
|
|
|
2013-11-13 11:42:14 +08:00
|
|
|
static inline void blkg_rwstat_init(struct blkg_rwstat *rwstat)
|
|
|
|
{
|
|
|
|
u64_stats_init(&rwstat->syncp);
|
|
|
|
}
|
|
|
|
|
2012-04-02 05:38:42 +08:00
|
|
|
/**
|
|
|
|
* blkg_rwstat_add - add a value to a blkg_rwstat
|
|
|
|
* @rwstat: target blkg_rwstat
|
|
|
|
* @rw: mask of REQ_{WRITE|SYNC}
|
|
|
|
* @val: value to add
|
|
|
|
*
|
|
|
|
* Add @val to @rwstat. The counters are chosen according to @rw. The
|
|
|
|
* caller is responsible for synchronizing calls to this function.
|
|
|
|
*/
|
|
|
|
static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
|
|
|
|
int rw, uint64_t val)
|
|
|
|
{
|
|
|
|
u64_stats_update_begin(&rwstat->syncp);
|
|
|
|
|
|
|
|
if (rw & REQ_WRITE)
|
|
|
|
rwstat->cnt[BLKG_RWSTAT_WRITE] += val;
|
|
|
|
else
|
|
|
|
rwstat->cnt[BLKG_RWSTAT_READ] += val;
|
|
|
|
if (rw & REQ_SYNC)
|
|
|
|
rwstat->cnt[BLKG_RWSTAT_SYNC] += val;
|
|
|
|
else
|
|
|
|
rwstat->cnt[BLKG_RWSTAT_ASYNC] += val;
|
|
|
|
|
|
|
|
u64_stats_update_end(&rwstat->syncp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkg_rwstat_read - read the current values of a blkg_rwstat
|
|
|
|
* @rwstat: blkg_rwstat to read
|
|
|
|
*
|
|
|
|
* Read the current snapshot of @rwstat and return it as the return value.
|
|
|
|
* This function can be called without synchronization and takes care of
|
|
|
|
* u64 atomicity.
|
|
|
|
*/
|
2012-04-17 04:57:22 +08:00
|
|
|
static inline struct blkg_rwstat blkg_rwstat_read(struct blkg_rwstat *rwstat)
|
2012-04-02 05:38:42 +08:00
|
|
|
{
|
|
|
|
unsigned int start;
|
|
|
|
struct blkg_rwstat tmp;
|
|
|
|
|
|
|
|
do {
|
2014-03-14 12:26:42 +08:00
|
|
|
start = u64_stats_fetch_begin_irq(&rwstat->syncp);
|
2012-04-02 05:38:42 +08:00
|
|
|
tmp = *rwstat;
|
2014-03-14 12:26:42 +08:00
|
|
|
} while (u64_stats_fetch_retry_irq(&rwstat->syncp, start));
|
2012-04-02 05:38:42 +08:00
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-10 00:05:12 +08:00
|
|
|
* blkg_rwstat_total - read the total count of a blkg_rwstat
|
2012-04-02 05:38:42 +08:00
|
|
|
* @rwstat: blkg_rwstat to read
|
|
|
|
*
|
|
|
|
* Return the total count of @rwstat regardless of the IO direction. This
|
|
|
|
* function can be called without synchronization and takes care of u64
|
|
|
|
* atomicity.
|
|
|
|
*/
|
2013-01-10 00:05:12 +08:00
|
|
|
static inline uint64_t blkg_rwstat_total(struct blkg_rwstat *rwstat)
|
2012-04-02 05:38:42 +08:00
|
|
|
{
|
|
|
|
struct blkg_rwstat tmp = blkg_rwstat_read(rwstat);
|
|
|
|
|
|
|
|
return tmp.cnt[BLKG_RWSTAT_READ] + tmp.cnt[BLKG_RWSTAT_WRITE];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkg_rwstat_reset - reset a blkg_rwstat
|
|
|
|
* @rwstat: blkg_rwstat to reset
|
|
|
|
*/
|
|
|
|
static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat)
|
|
|
|
{
|
|
|
|
memset(rwstat->cnt, 0, sizeof(rwstat->cnt));
|
|
|
|
}
|
|
|
|
|
2013-01-10 00:05:12 +08:00
|
|
|
/**
|
|
|
|
* blkg_rwstat_merge - merge a blkg_rwstat into another
|
|
|
|
* @to: the destination blkg_rwstat
|
|
|
|
* @from: the source
|
|
|
|
*
|
|
|
|
* Add @from's counts to @to.
|
|
|
|
*/
|
|
|
|
static inline void blkg_rwstat_merge(struct blkg_rwstat *to,
|
|
|
|
struct blkg_rwstat *from)
|
|
|
|
{
|
|
|
|
struct blkg_rwstat v = blkg_rwstat_read(from);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
u64_stats_update_begin(&to->syncp);
|
|
|
|
for (i = 0; i < BLKG_RWSTAT_NR; i++)
|
|
|
|
to->cnt[i] += v.cnt[i];
|
|
|
|
u64_stats_update_end(&to->syncp);
|
|
|
|
}
|
|
|
|
|
2012-04-17 04:57:24 +08:00
|
|
|
#else /* CONFIG_BLK_CGROUP */
|
|
|
|
|
2015-05-23 05:13:18 +08:00
|
|
|
struct blkcg {
|
|
|
|
};
|
2009-12-04 04:06:43 +08:00
|
|
|
|
2012-04-17 04:57:26 +08:00
|
|
|
struct blkg_policy_data {
|
|
|
|
};
|
|
|
|
|
block, cgroup: implement policy-specific per-blkcg data
The block IO (blkio) controller enables the block layer to provide service
guarantees in a hierarchical fashion. Specifically, service guarantees
are provided by registered request-accounting policies. As of now, a
proportional-share and a throttling policy are available. They are
implemented, respectively, by the CFQ I/O scheduler and the blk-throttle
subsystem. Unfortunately, as for adding new policies, the current
implementation of the block IO controller is only halfway ready to allow
new policies to be plugged in. This commit provides a solution to make
the block IO controller fully ready to handle new policies.
In what follows, we first describe briefly the current state, and then
list the changes made by this commit.
The throttling policy does not need any per-cgroup information to perform
its task. In contrast, the proportional share policy uses, for each cgroup,
both the weight assigned by the user to the cgroup, and a set of dynamically-
computed weights, one for each device.
The first, user-defined weight is stored in the blkcg data structure: the
block IO controller allocates a private blkcg data structure for each
cgroup in the blkio cgroups hierarchy (regardless of which policy is active).
In other words, the block IO controller internally mirrors the blkio cgroups
with private blkcg data structures.
On the other hand, for each cgroup and device, the corresponding dynamically-
computed weight is maintained in the following, different way. For each device,
the block IO controller keeps a private blkcg_gq structure for each cgroup in
blkio. In other words, block IO also keeps one private mirror copy of the blkio
cgroups hierarchy for each device, made of blkcg_gq structures.
Each blkcg_gq structure keeps per-policy information in a generic array of
dynamically-allocated 'dedicated' data structures, one for each registered
policy (so currently the array contains two elements). To be inserted into the
generic array, each dedicated data structure embeds a generic blkg_policy_data
structure. Consider now the array contained in the blkcg_gq structure
corresponding to a given pair of cgroup and device: one of the elements
of the array contains the dedicated data structure for the proportional-share
policy, and this dedicated data structure contains the dynamically-computed
weight for that pair of cgroup and device.
The generic strategy adopted for storing per-policy data in blkcg_gq structures
is already capable of handling new policies, whereas the one adopted with blkcg
structures is not, because per-policy data are hard-coded in the blkcg
structures themselves (currently only data related to the proportional-
share policy).
This commit addresses the above issues through the following changes:
. It generalizes blkcg structures so that per-policy data are stored in the same
way as in blkcg_gq structures.
Specifically, it lets also the blkcg structure store per-policy data in a
generic array of dynamically-allocated dedicated data structures. We will
refer to these data structures as blkcg dedicated data structures, to
distinguish them from the dedicated data structures inserted in the generic
arrays kept by blkcg_gq structures.
To allow blkcg dedicated data structures to be inserted in the generic array
inside a blkcg structure, this commit also introduces a new blkcg_policy_data
structure, which is the equivalent of blkg_policy_data for blkcg dedicated
data structures.
. It adds to the blkcg_policy structure, i.e., to the descriptor of a policy, a
cpd_size field and a cpd_init field, to be initialized by the policy with,
respectively, the size of the blkcg dedicated data structures, and the
address of a constructor function for blkcg dedicated data structures.
. It moves the CFQ-specific fields embedded in the blkcg data structure (i.e.,
the fields related to the proportional-share policy), into a new blkcg
dedicated data structure called cfq_group_data.
Signed-off-by: Paolo Valente <paolo.valente@unimore.it>
Signed-off-by: Arianna Avanzini <avanzini.arianna@gmail.com>
Acked-by: Tejun Heo <tj@kernel.org>
Cc: Jens Axboe <axboe@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-06-06 05:38:42 +08:00
|
|
|
struct blkcg_policy_data {
|
|
|
|
};
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg_gq {
|
2009-12-04 04:06:43 +08:00
|
|
|
};
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg_policy {
|
2009-12-04 23:36:42 +08:00
|
|
|
};
|
|
|
|
|
2015-05-23 05:13:21 +08:00
|
|
|
#define blkcg_root_css ((struct cgroup_subsys_state *)ERR_PTR(-EINVAL))
|
|
|
|
|
2015-05-23 05:13:23 +08:00
|
|
|
static inline struct cgroup_subsys_state *
|
|
|
|
task_get_blkcg_css(struct task_struct *task)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-05-23 05:13:18 +08:00
|
|
|
#ifdef CONFIG_BLOCK
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, void *key) { return NULL; }
|
2012-03-06 05:15:12 +08:00
|
|
|
static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
|
|
|
|
static inline void blkcg_drain_queue(struct request_queue *q) { }
|
|
|
|
static inline void blkcg_exit_queue(struct request_queue *q) { }
|
2014-06-23 06:31:56 +08:00
|
|
|
static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }
|
2012-04-17 04:57:25 +08:00
|
|
|
static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }
|
2012-04-14 04:11:33 +08:00
|
|
|
static inline int blkcg_activate_policy(struct request_queue *q,
|
2012-04-17 04:57:25 +08:00
|
|
|
const struct blkcg_policy *pol) { return 0; }
|
2012-04-14 04:11:33 +08:00
|
|
|
static inline void blkcg_deactivate_policy(struct request_queue *q,
|
2012-04-17 04:57:25 +08:00
|
|
|
const struct blkcg_policy *pol) { }
|
|
|
|
|
2012-06-05 11:40:57 +08:00
|
|
|
static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }
|
blkcg: implement per-blkg request allocation
Currently, request_queue has one request_list to allocate requests
from regardless of blkcg of the IO being issued. When the unified
request pool is used up, cfq proportional IO limits become meaningless
- whoever grabs the next request being freed wins the race regardless
of the configured weights.
This can be easily demonstrated by creating a blkio cgroup w/ very low
weight, put a program which can issue a lot of random direct IOs there
and running a sequential IO from a different cgroup. As soon as the
request pool is used up, the sequential IO bandwidth crashes.
This patch implements per-blkg request_list. Each blkg has its own
request_list and any IO allocates its request from the matching blkg
making blkcgs completely isolated in terms of request allocation.
* Root blkcg uses the request_list embedded in each request_queue,
which was renamed to @q->root_rl from @q->rq. While making blkcg rl
handling a bit harier, this enables avoiding most overhead for root
blkcg.
* Queue fullness is properly per request_list but bdi isn't blkcg
aware yet, so congestion state currently just follows the root
blkcg. As writeback isn't aware of blkcg yet, this works okay for
async congestion but readahead may get the wrong signals. It's
better than blkcg completely collapsing with shared request_list but
needs to be improved with future changes.
* After this change, each block cgroup gets a full request pool making
resource consumption of each cgroup higher. This makes allowing
non-root users to create cgroups less desirable; however, note that
allowing non-root users to directly manage cgroups is already
severely broken regardless of this patch - each block cgroup
consumes kernel memory and skews IO weight (IO weights are not
hierarchical).
v2: queue-sysfs.txt updated and patch description udpated as suggested
by Vivek.
v3: blk_get_rl() wasn't checking error return from
blkg_lookup_create() and may cause oops on lookup failure. Fix it
by falling back to root_rl on blkg lookup failures. This problem
was spotted by Rakesh Iyer <rni@google.com>.
v4: Updated to accomodate 458f27a982 "block: Avoid missed wakeup in
request waitqueue". blk_drain_queue() now wakes up waiters on all
blkg->rl on the target queue.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-06-27 06:05:44 +08:00
|
|
|
|
2012-04-17 04:57:26 +08:00
|
|
|
static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
|
|
|
|
struct blkcg_policy *pol) { return NULL; }
|
|
|
|
static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd) { return NULL; }
|
2012-04-17 04:57:25 +08:00
|
|
|
static inline char *blkg_path(struct blkcg_gq *blkg) { return NULL; }
|
|
|
|
static inline void blkg_get(struct blkcg_gq *blkg) { }
|
|
|
|
static inline void blkg_put(struct blkcg_gq *blkg) { }
|
2010-04-27 01:27:56 +08:00
|
|
|
|
blkcg: implement per-blkg request allocation
Currently, request_queue has one request_list to allocate requests
from regardless of blkcg of the IO being issued. When the unified
request pool is used up, cfq proportional IO limits become meaningless
- whoever grabs the next request being freed wins the race regardless
of the configured weights.
This can be easily demonstrated by creating a blkio cgroup w/ very low
weight, put a program which can issue a lot of random direct IOs there
and running a sequential IO from a different cgroup. As soon as the
request pool is used up, the sequential IO bandwidth crashes.
This patch implements per-blkg request_list. Each blkg has its own
request_list and any IO allocates its request from the matching blkg
making blkcgs completely isolated in terms of request allocation.
* Root blkcg uses the request_list embedded in each request_queue,
which was renamed to @q->root_rl from @q->rq. While making blkcg rl
handling a bit harier, this enables avoiding most overhead for root
blkcg.
* Queue fullness is properly per request_list but bdi isn't blkcg
aware yet, so congestion state currently just follows the root
blkcg. As writeback isn't aware of blkcg yet, this works okay for
async congestion but readahead may get the wrong signals. It's
better than blkcg completely collapsing with shared request_list but
needs to be improved with future changes.
* After this change, each block cgroup gets a full request pool making
resource consumption of each cgroup higher. This makes allowing
non-root users to create cgroups less desirable; however, note that
allowing non-root users to directly manage cgroups is already
severely broken regardless of this patch - each block cgroup
consumes kernel memory and skews IO weight (IO weights are not
hierarchical).
v2: queue-sysfs.txt updated and patch description udpated as suggested
by Vivek.
v3: blk_get_rl() wasn't checking error return from
blkg_lookup_create() and may cause oops on lookup failure. Fix it
by falling back to root_rl on blkg lookup failures. This problem
was spotted by Rakesh Iyer <rni@google.com>.
v4: Updated to accomodate 458f27a982 "block: Avoid missed wakeup in
request waitqueue". blk_drain_queue() now wakes up waiters on all
blkg->rl on the target queue.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-06-27 06:05:44 +08:00
|
|
|
static inline struct request_list *blk_get_rl(struct request_queue *q,
|
|
|
|
struct bio *bio) { return &q->root_rl; }
|
|
|
|
static inline void blk_put_rl(struct request_list *rl) { }
|
|
|
|
static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl) { }
|
|
|
|
static inline struct request_list *blk_rq_rl(struct request *rq) { return &rq->q->root_rl; }
|
|
|
|
|
|
|
|
#define blk_queue_for_each_rl(rl, q) \
|
|
|
|
for ((rl) = &(q)->root_rl; (rl); (rl) = NULL)
|
|
|
|
|
2015-05-23 05:13:18 +08:00
|
|
|
#endif /* CONFIG_BLOCK */
|
2012-04-17 04:57:24 +08:00
|
|
|
#endif /* CONFIG_BLK_CGROUP */
|
|
|
|
#endif /* _BLK_CGROUP_H */
|