2019-04-30 12:42:43 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2009-12-03 10:59:42 -07:00
|
|
|
/*
|
|
|
|
* 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>
|
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-05 15:38:42 -06:00
|
|
|
*
|
|
|
|
* For policy-specific per-blkcg data:
|
|
|
|
* Copyright (C) 2015 Paolo Valente <paolo.valente@unimore.it>
|
|
|
|
* Arianna Avanzini <avanzini.arianna@gmail.com>
|
2009-12-03 10:59:42 -07:00
|
|
|
*/
|
|
|
|
#include <linux/ioprio.h>
|
2009-12-03 10:59:49 -07:00
|
|
|
#include <linux/kdev_t.h>
|
2009-12-04 08:36:41 -07:00
|
|
|
#include <linux/module.h>
|
2017-02-02 11:15:33 -07:00
|
|
|
#include <linux/sched/signal.h>
|
2009-12-07 01:29:39 -07:00
|
|
|
#include <linux/err.h>
|
2010-04-01 16:01:41 -06:00
|
|
|
#include <linux/blkdev.h>
|
2015-05-22 15:13:37 -06:00
|
|
|
#include <linux/backing-dev.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2010-04-13 02:05:49 -06:00
|
|
|
#include <linux/genhd.h>
|
2012-03-05 14:15:00 -07:00
|
|
|
#include <linux/delay.h>
|
2012-03-19 16:10:56 -06:00
|
|
|
#include <linux/atomic.h>
|
2015-08-18 15:55:31 -06:00
|
|
|
#include <linux/ctype.h>
|
2015-05-22 15:13:17 -06:00
|
|
|
#include <linux/blk-cgroup.h>
|
2018-07-03 09:14:55 -06:00
|
|
|
#include <linux/tracehook.h>
|
2019-07-09 15:41:29 -06:00
|
|
|
#include <linux/psi.h>
|
2012-03-05 14:15:12 -07:00
|
|
|
#include "blk.h"
|
2009-12-04 08:36:42 -07:00
|
|
|
|
2010-04-09 00:31:19 -06:00
|
|
|
#define MAX_KEY_LEN 100
|
|
|
|
|
2015-07-09 14:39:47 -06:00
|
|
|
/*
|
|
|
|
* blkcg_pol_mutex protects blkcg_policy[] and policy [de]activation.
|
|
|
|
* blkcg_pol_register_mutex nests outside of it and synchronizes entire
|
|
|
|
* policy [un]register operations including cgroup file additions /
|
|
|
|
* removals. Putting cgroup file registration outside blkcg_pol_mutex
|
|
|
|
* allows grabbing it from cgroup callbacks.
|
|
|
|
*/
|
|
|
|
static DEFINE_MUTEX(blkcg_pol_register_mutex);
|
2012-04-13 14:11:26 -06:00
|
|
|
static DEFINE_MUTEX(blkcg_pol_mutex);
|
2012-03-05 14:15:13 -07: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-05 15:38:42 -06:00
|
|
|
struct blkcg blkcg_root;
|
2012-04-16 14:57:25 -06:00
|
|
|
EXPORT_SYMBOL_GPL(blkcg_root);
|
2009-12-04 08:36:41 -07:00
|
|
|
|
2015-05-22 15:13:21 -06:00
|
|
|
struct cgroup_subsys_state * const blkcg_root_css = &blkcg_root.css;
|
2019-06-27 14:39:48 -06:00
|
|
|
EXPORT_SYMBOL_GPL(blkcg_root_css);
|
2015-05-22 15:13:21 -06:00
|
|
|
|
2012-04-16 14:57:25 -06:00
|
|
|
static struct blkcg_policy *blkcg_policy[BLKCG_MAX_POLS];
|
2012-03-05 14:15:04 -07:00
|
|
|
|
2015-07-09 14:39:49 -06:00
|
|
|
static LIST_HEAD(all_blkcgs); /* protected by blkcg_pol_mutex */
|
|
|
|
|
2019-07-16 08:58:31 -06:00
|
|
|
bool blkcg_debug_stats = false;
|
2019-06-27 14:39:52 -06:00
|
|
|
static struct workqueue_struct *blkcg_punt_bio_wq;
|
2018-07-03 09:14:52 -06:00
|
|
|
|
2012-04-13 14:11:33 -06:00
|
|
|
static bool blkcg_policy_enabled(struct request_queue *q,
|
2012-04-16 14:57:25 -06:00
|
|
|
const struct blkcg_policy *pol)
|
2012-04-13 14:11:33 -06:00
|
|
|
{
|
|
|
|
return pol && test_bit(pol->plid, q->blkcg_pols);
|
|
|
|
}
|
|
|
|
|
2012-03-05 14:15:14 -07:00
|
|
|
/**
|
|
|
|
* blkg_free - free a blkg
|
|
|
|
* @blkg: blkg to free
|
|
|
|
*
|
|
|
|
* Free @blkg which may be partially allocated.
|
|
|
|
*/
|
2012-04-16 14:57:25 -06:00
|
|
|
static void blkg_free(struct blkcg_gq *blkg)
|
2012-03-05 14:15:14 -07:00
|
|
|
{
|
2012-03-05 14:15:20 -07:00
|
|
|
int i;
|
2012-03-05 14:15:16 -07:00
|
|
|
|
|
|
|
if (!blkg)
|
|
|
|
return;
|
|
|
|
|
2013-05-14 14:52:31 -06:00
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++)
|
2015-08-18 15:55:11 -06:00
|
|
|
if (blkg->pd[i])
|
|
|
|
blkcg_policy[i]->pd_free_fn(blkg->pd[i]);
|
2012-03-05 14:15:20 -07:00
|
|
|
|
2019-11-07 12:18:03 -07:00
|
|
|
free_percpu(blkg->iostat_cpu);
|
2019-06-13 16:30:39 -06:00
|
|
|
percpu_ref_exit(&blkg->refcnt);
|
2012-03-05 14:15:16 -07:00
|
|
|
kfree(blkg);
|
2012-03-05 14:15:14 -07:00
|
|
|
}
|
|
|
|
|
2018-12-05 10:10:38 -07:00
|
|
|
static void __blkg_release(struct rcu_head *rcu)
|
|
|
|
{
|
|
|
|
struct blkcg_gq *blkg = container_of(rcu, struct blkcg_gq, rcu_head);
|
|
|
|
|
2019-06-27 14:39:52 -06:00
|
|
|
WARN_ON(!bio_list_empty(&blkg->async_bios));
|
|
|
|
|
2018-12-05 10:10:38 -07:00
|
|
|
/* release the blkcg and parent blkg refs this blkg has been holding */
|
|
|
|
css_put(&blkg->blkcg->css);
|
|
|
|
if (blkg->parent)
|
|
|
|
blkg_put(blkg->parent);
|
|
|
|
|
|
|
|
wb_congested_put(blkg->wb_congested);
|
|
|
|
|
|
|
|
blkg_free(blkg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A group is RCU protected, but having an rcu lock does not mean that one
|
|
|
|
* can access all the fields of blkg and assume these are valid. For
|
|
|
|
* example, don't try to follow throtl_data and request queue links.
|
|
|
|
*
|
|
|
|
* Having a reference to blkg under an rcu allows accesses to only values
|
|
|
|
* local to groups like group stats and group rate limits.
|
|
|
|
*/
|
|
|
|
static void blkg_release(struct percpu_ref *ref)
|
|
|
|
{
|
|
|
|
struct blkcg_gq *blkg = container_of(ref, struct blkcg_gq, refcnt);
|
|
|
|
|
|
|
|
call_rcu(&blkg->rcu_head, __blkg_release);
|
|
|
|
}
|
|
|
|
|
2019-06-27 14:39:52 -06:00
|
|
|
static void blkg_async_bio_workfn(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct blkcg_gq *blkg = container_of(work, struct blkcg_gq,
|
|
|
|
async_bio_work);
|
|
|
|
struct bio_list bios = BIO_EMPTY_LIST;
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
/* as long as there are pending bios, @blkg can't go away */
|
|
|
|
spin_lock_bh(&blkg->async_bio_lock);
|
|
|
|
bio_list_merge(&bios, &blkg->async_bios);
|
|
|
|
bio_list_init(&blkg->async_bios);
|
|
|
|
spin_unlock_bh(&blkg->async_bio_lock);
|
|
|
|
|
|
|
|
while ((bio = bio_list_pop(&bios)))
|
|
|
|
submit_bio(bio);
|
|
|
|
}
|
|
|
|
|
2012-03-05 14:15:14 -07:00
|
|
|
/**
|
|
|
|
* blkg_alloc - allocate a blkg
|
|
|
|
* @blkcg: block cgroup the new blkg is associated with
|
|
|
|
* @q: request_queue the new blkg is associated with
|
2012-06-04 21:40:52 -06:00
|
|
|
* @gfp_mask: allocation mask to use
|
2012-03-05 14:15:14 -07:00
|
|
|
*
|
2012-03-05 14:15:20 -07:00
|
|
|
* Allocate a new blkg assocating @blkcg and @q.
|
2012-03-05 14:15:14 -07:00
|
|
|
*/
|
2012-06-04 21:40:52 -06:00
|
|
|
static struct blkcg_gq *blkg_alloc(struct blkcg *blkcg, struct request_queue *q,
|
|
|
|
gfp_t gfp_mask)
|
2012-03-05 14:15:14 -07:00
|
|
|
{
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_gq *blkg;
|
2019-11-07 12:18:03 -07:00
|
|
|
int i, cpu;
|
2012-03-05 14:15:14 -07:00
|
|
|
|
|
|
|
/* alloc and init base part */
|
2012-06-04 21:40:52 -06:00
|
|
|
blkg = kzalloc_node(sizeof(*blkg), gfp_mask, q->node);
|
2012-03-05 14:15:14 -07:00
|
|
|
if (!blkg)
|
|
|
|
return NULL;
|
|
|
|
|
2019-06-13 16:30:39 -06:00
|
|
|
if (percpu_ref_init(&blkg->refcnt, blkg_release, 0, gfp_mask))
|
|
|
|
goto err_free;
|
|
|
|
|
2019-11-07 12:18:03 -07:00
|
|
|
blkg->iostat_cpu = alloc_percpu_gfp(struct blkg_iostat_set, gfp_mask);
|
|
|
|
if (!blkg->iostat_cpu)
|
2015-08-18 15:55:24 -06:00
|
|
|
goto err_free;
|
|
|
|
|
2012-03-05 14:15:22 -07:00
|
|
|
blkg->q = q;
|
2012-03-05 14:15:20 -07:00
|
|
|
INIT_LIST_HEAD(&blkg->q_node);
|
2019-06-27 14:39:52 -06:00
|
|
|
spin_lock_init(&blkg->async_bio_lock);
|
|
|
|
bio_list_init(&blkg->async_bios);
|
|
|
|
INIT_WORK(&blkg->async_bio_work, blkg_async_bio_workfn);
|
2012-03-05 14:15:14 -07:00
|
|
|
blkg->blkcg = blkcg;
|
|
|
|
|
2019-11-07 12:18:03 -07:00
|
|
|
u64_stats_init(&blkg->iostat.sync);
|
|
|
|
for_each_possible_cpu(cpu)
|
|
|
|
u64_stats_init(&per_cpu_ptr(blkg->iostat_cpu, cpu)->sync);
|
|
|
|
|
2012-04-13 14:11:28 -06:00
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++) {
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_policy *pol = blkcg_policy[i];
|
2012-03-05 14:15:20 -07:00
|
|
|
struct blkg_policy_data *pd;
|
2012-03-05 14:15:14 -07:00
|
|
|
|
2012-04-13 14:11:33 -06:00
|
|
|
if (!blkcg_policy_enabled(q, pol))
|
2012-03-05 14:15:20 -07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* alloc per-policy data and attach it to blkg */
|
2019-08-28 16:05:51 -06:00
|
|
|
pd = pol->pd_alloc_fn(gfp_mask, q, blkcg);
|
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-26 16:05:44 -06:00
|
|
|
if (!pd)
|
|
|
|
goto err_free;
|
2012-03-05 14:15:16 -07:00
|
|
|
|
2012-03-05 14:15:20 -07:00
|
|
|
blkg->pd[i] = pd;
|
|
|
|
pd->blkg = blkg;
|
2013-01-09 09:05:12 -07:00
|
|
|
pd->plid = i;
|
2012-03-05 14:15:20 -07:00
|
|
|
}
|
|
|
|
|
2012-03-05 14:15:14 -07:00
|
|
|
return blkg;
|
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-26 16:05:44 -06:00
|
|
|
|
|
|
|
err_free:
|
|
|
|
blkg_free(blkg);
|
|
|
|
return NULL;
|
2012-03-05 14:15:14 -07:00
|
|
|
}
|
|
|
|
|
2015-08-18 15:55:17 -06:00
|
|
|
struct blkcg_gq *blkg_lookup_slowpath(struct blkcg *blkcg,
|
|
|
|
struct request_queue *q, bool update_hint)
|
2012-04-13 15:50:53 -06:00
|
|
|
{
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_gq *blkg;
|
2012-04-13 15:50:53 -06:00
|
|
|
|
2012-04-19 17:29:24 -06:00
|
|
|
/*
|
2013-01-09 09:05:10 -07:00
|
|
|
* Hint didn't match. Look up from the radix tree. Note that the
|
|
|
|
* hint can only be updated under queue_lock as otherwise @blkg
|
|
|
|
* could have already been removed from blkg_tree. The caller is
|
|
|
|
* responsible for grabbing queue_lock if @update_hint.
|
2012-04-19 17:29:24 -06:00
|
|
|
*/
|
|
|
|
blkg = radix_tree_lookup(&blkcg->blkg_tree, q->id);
|
2013-01-09 09:05:10 -07:00
|
|
|
if (blkg && blkg->q == q) {
|
|
|
|
if (update_hint) {
|
2018-11-15 12:17:28 -07:00
|
|
|
lockdep_assert_held(&q->queue_lock);
|
2013-01-09 09:05:10 -07:00
|
|
|
rcu_assign_pointer(blkcg->blkg_hint, blkg);
|
|
|
|
}
|
2012-04-19 17:29:24 -06:00
|
|
|
return blkg;
|
2013-01-09 09:05:10 -07:00
|
|
|
}
|
2012-04-19 17:29:24 -06:00
|
|
|
|
2012-04-13 15:50:53 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
2015-08-18 15:55:20 -06:00
|
|
|
EXPORT_SYMBOL_GPL(blkg_lookup_slowpath);
|
2012-04-13 15:50:53 -06:00
|
|
|
|
2012-06-04 21:40:52 -06:00
|
|
|
/*
|
2017-03-29 11:25:48 -06:00
|
|
|
* If @new_blkg is %NULL, this function tries to allocate a new one as
|
|
|
|
* necessary using %GFP_NOWAIT. @new_blkg is always consumed on return.
|
2012-06-04 21:40:52 -06:00
|
|
|
*/
|
2013-01-09 09:05:10 -07:00
|
|
|
static struct blkcg_gq *blkg_create(struct blkcg *blkcg,
|
2017-03-29 11:25:48 -06:00
|
|
|
struct request_queue *q,
|
|
|
|
struct blkcg_gq *new_blkg)
|
2011-05-19 13:38:28 -06:00
|
|
|
{
|
2017-03-29 11:25:48 -06:00
|
|
|
struct blkcg_gq *blkg;
|
2015-05-22 15:13:38 -06:00
|
|
|
struct bdi_writeback_congested *wb_congested;
|
2013-01-09 09:05:12 -07:00
|
|
|
int i, ret;
|
2011-05-19 13:38:28 -06:00
|
|
|
|
2012-03-05 14:15:06 -07:00
|
|
|
WARN_ON_ONCE(!rcu_read_lock_held());
|
2018-11-15 12:17:28 -07:00
|
|
|
lockdep_assert_held(&q->queue_lock);
|
2012-03-05 14:15:06 -07:00
|
|
|
|
2018-12-11 16:03:08 -07:00
|
|
|
/* request_queue is dying, do not create/recreate a blkg */
|
|
|
|
if (blk_queue_dying(q)) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto err_free_blkg;
|
|
|
|
}
|
|
|
|
|
2012-03-05 14:15:11 -07:00
|
|
|
/* blkg holds a reference to blkcg */
|
2014-05-13 10:11:01 -06:00
|
|
|
if (!css_tryget_online(&blkcg->css)) {
|
2015-08-18 15:55:28 -06:00
|
|
|
ret = -ENODEV;
|
2013-01-09 09:05:10 -07:00
|
|
|
goto err_free_blkg;
|
2012-06-04 21:40:52 -06:00
|
|
|
}
|
2012-03-05 14:15:06 -07:00
|
|
|
|
2017-02-02 07:56:50 -07:00
|
|
|
wb_congested = wb_congested_get_create(q->backing_dev_info,
|
2017-03-29 11:25:48 -06:00
|
|
|
blkcg->css.id,
|
|
|
|
GFP_NOWAIT | __GFP_NOWARN);
|
|
|
|
if (!wb_congested) {
|
2015-05-22 15:13:38 -06:00
|
|
|
ret = -ENOMEM;
|
2017-03-29 11:25:48 -06:00
|
|
|
goto err_put_css;
|
2015-05-22 15:13:38 -06:00
|
|
|
}
|
|
|
|
|
2017-03-29 11:25:48 -06:00
|
|
|
/* allocate */
|
|
|
|
if (!new_blkg) {
|
|
|
|
new_blkg = blkg_alloc(blkcg, q, GFP_NOWAIT | __GFP_NOWARN);
|
|
|
|
if (unlikely(!new_blkg)) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_put_congested;
|
2012-06-04 21:40:52 -06:00
|
|
|
}
|
|
|
|
}
|
2017-03-29 11:25:48 -06:00
|
|
|
blkg = new_blkg;
|
|
|
|
blkg->wb_congested = wb_congested;
|
2012-03-05 14:15:06 -07:00
|
|
|
|
2013-05-14 14:52:31 -06:00
|
|
|
/* link parent */
|
2013-01-09 09:05:10 -07:00
|
|
|
if (blkcg_parent(blkcg)) {
|
|
|
|
blkg->parent = __blkg_lookup(blkcg_parent(blkcg), q, false);
|
|
|
|
if (WARN_ON_ONCE(!blkg->parent)) {
|
2015-08-18 15:55:28 -06:00
|
|
|
ret = -ENODEV;
|
2017-03-29 11:25:48 -06:00
|
|
|
goto err_put_congested;
|
2013-01-09 09:05:10 -07:00
|
|
|
}
|
|
|
|
blkg_get(blkg->parent);
|
|
|
|
}
|
|
|
|
|
2013-05-14 14:52:31 -06:00
|
|
|
/* invoke per-policy init */
|
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++) {
|
|
|
|
struct blkcg_policy *pol = blkcg_policy[i];
|
|
|
|
|
|
|
|
if (blkg->pd[i] && pol->pd_init_fn)
|
2015-08-18 15:55:14 -06:00
|
|
|
pol->pd_init_fn(blkg->pd[i]);
|
2013-05-14 14:52:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* insert */
|
2012-03-05 14:15:06 -07:00
|
|
|
spin_lock(&blkcg->lock);
|
2012-04-19 17:29:24 -06:00
|
|
|
ret = radix_tree_insert(&blkcg->blkg_tree, q->id, blkg);
|
|
|
|
if (likely(!ret)) {
|
|
|
|
hlist_add_head_rcu(&blkg->blkcg_node, &blkcg->blkg_list);
|
|
|
|
list_add(&blkg->q_node, &q->blkg_list);
|
2013-01-09 09:05:12 -07:00
|
|
|
|
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++) {
|
|
|
|
struct blkcg_policy *pol = blkcg_policy[i];
|
|
|
|
|
|
|
|
if (blkg->pd[i] && pol->pd_online_fn)
|
2015-08-18 15:55:14 -06:00
|
|
|
pol->pd_online_fn(blkg->pd[i]);
|
2013-01-09 09:05:12 -07:00
|
|
|
}
|
2012-04-19 17:29:24 -06:00
|
|
|
}
|
2013-01-09 09:05:12 -07:00
|
|
|
blkg->online = true;
|
2012-03-05 14:15:06 -07:00
|
|
|
spin_unlock(&blkcg->lock);
|
2012-04-19 17:29:23 -06:00
|
|
|
|
2015-05-22 15:13:19 -06:00
|
|
|
if (!ret)
|
2012-04-19 17:29:24 -06:00
|
|
|
return blkg;
|
2012-06-04 21:40:52 -06:00
|
|
|
|
2013-01-09 09:05:10 -07:00
|
|
|
/* @blkg failed fully initialized, use the usual release path */
|
|
|
|
blkg_put(blkg);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
|
2017-03-29 11:25:48 -06:00
|
|
|
err_put_congested:
|
|
|
|
wb_congested_put(wb_congested);
|
|
|
|
err_put_css:
|
2012-04-19 17:29:23 -06:00
|
|
|
css_put(&blkcg->css);
|
2013-01-09 09:05:10 -07:00
|
|
|
err_free_blkg:
|
2017-03-29 11:25:48 -06:00
|
|
|
blkg_free(new_blkg);
|
2013-01-09 09:05:10 -07:00
|
|
|
return ERR_PTR(ret);
|
2009-12-03 10:59:42 -07:00
|
|
|
}
|
2012-04-13 14:11:34 -06:00
|
|
|
|
2013-01-09 09:05:10 -07:00
|
|
|
/**
|
2018-12-05 10:10:27 -07:00
|
|
|
* __blkg_lookup_create - lookup blkg, try to create one if not there
|
2013-01-09 09:05:10 -07:00
|
|
|
* @blkcg: blkcg of interest
|
|
|
|
* @q: request_queue of interest
|
|
|
|
*
|
|
|
|
* Lookup blkg for the @blkcg - @q pair. If it doesn't exist, try to
|
2013-01-09 09:05:10 -07:00
|
|
|
* create one. blkg creation is performed recursively from blkcg_root such
|
|
|
|
* that all non-root blkg's have access to the parent blkg. This function
|
|
|
|
* should be called under RCU read lock and @q->queue_lock.
|
2013-01-09 09:05:10 -07:00
|
|
|
*
|
2018-12-05 10:10:28 -07:00
|
|
|
* Returns the blkg or the closest blkg if blkg_create() fails as it walks
|
|
|
|
* down from root.
|
2013-01-09 09:05:10 -07:00
|
|
|
*/
|
2018-12-05 10:10:27 -07:00
|
|
|
struct blkcg_gq *__blkg_lookup_create(struct blkcg *blkcg,
|
|
|
|
struct request_queue *q)
|
2012-04-13 14:11:34 -06:00
|
|
|
{
|
2013-01-09 09:05:10 -07:00
|
|
|
struct blkcg_gq *blkg;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(!rcu_read_lock_held());
|
2018-11-15 12:17:28 -07:00
|
|
|
lockdep_assert_held(&q->queue_lock);
|
2013-01-09 09:05:10 -07:00
|
|
|
|
|
|
|
blkg = __blkg_lookup(blkcg, q, true);
|
|
|
|
if (blkg)
|
|
|
|
return blkg;
|
|
|
|
|
2013-01-09 09:05:10 -07:00
|
|
|
/*
|
|
|
|
* Create blkgs walking down from blkcg_root to @blkcg, so that all
|
2018-12-05 10:10:28 -07:00
|
|
|
* non-root blkgs have access to their parents. Returns the closest
|
|
|
|
* blkg to the intended blkg should blkg_create() fail.
|
2013-01-09 09:05:10 -07:00
|
|
|
*/
|
|
|
|
while (true) {
|
|
|
|
struct blkcg *pos = blkcg;
|
|
|
|
struct blkcg *parent = blkcg_parent(blkcg);
|
2018-12-05 10:10:28 -07:00
|
|
|
struct blkcg_gq *ret_blkg = q->root_blkg;
|
|
|
|
|
|
|
|
while (parent) {
|
|
|
|
blkg = __blkg_lookup(parent, q, false);
|
|
|
|
if (blkg) {
|
|
|
|
/* remember closest blkg */
|
|
|
|
ret_blkg = blkg;
|
|
|
|
break;
|
|
|
|
}
|
2013-01-09 09:05:10 -07:00
|
|
|
pos = parent;
|
|
|
|
parent = blkcg_parent(parent);
|
|
|
|
}
|
|
|
|
|
2017-03-29 11:25:48 -06:00
|
|
|
blkg = blkg_create(pos, q, NULL);
|
2018-12-05 10:10:28 -07:00
|
|
|
if (IS_ERR(blkg))
|
|
|
|
return ret_blkg;
|
|
|
|
if (pos == blkcg)
|
2013-01-09 09:05:10 -07:00
|
|
|
return blkg;
|
|
|
|
}
|
2012-04-13 14:11:34 -06:00
|
|
|
}
|
2009-12-03 10:59:42 -07:00
|
|
|
|
2018-12-05 10:10:27 -07:00
|
|
|
/**
|
|
|
|
* blkg_lookup_create - find or create a blkg
|
|
|
|
* @blkcg: target block cgroup
|
|
|
|
* @q: target request_queue
|
|
|
|
*
|
|
|
|
* This looks up or creates the blkg representing the unique pair
|
|
|
|
* of the blkcg and the request_queue.
|
|
|
|
*/
|
|
|
|
struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
|
|
|
|
struct request_queue *q)
|
|
|
|
{
|
|
|
|
struct blkcg_gq *blkg = blkg_lookup(blkcg, q);
|
|
|
|
|
|
|
|
if (unlikely(!blkg)) {
|
2018-12-19 09:29:15 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&q->queue_lock, flags);
|
2018-12-05 10:10:27 -07:00
|
|
|
blkg = __blkg_lookup_create(blkcg, q);
|
2018-12-19 09:29:15 -07:00
|
|
|
spin_unlock_irqrestore(&q->queue_lock, flags);
|
2018-12-05 10:10:27 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return blkg;
|
|
|
|
}
|
|
|
|
|
2012-04-16 14:57:25 -06:00
|
|
|
static void blkg_destroy(struct blkcg_gq *blkg)
|
2012-03-05 14:15:19 -07:00
|
|
|
{
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg *blkcg = blkg->blkcg;
|
2018-08-31 14:22:42 -06:00
|
|
|
int i;
|
2012-03-05 14:15:19 -07:00
|
|
|
|
2018-11-15 12:17:28 -07:00
|
|
|
lockdep_assert_held(&blkg->q->queue_lock);
|
2012-03-05 14:15:21 -07:00
|
|
|
lockdep_assert_held(&blkcg->lock);
|
2012-03-05 14:15:19 -07:00
|
|
|
|
|
|
|
/* Something wrong if we are trying to remove same group twice */
|
2012-03-05 14:15:20 -07:00
|
|
|
WARN_ON_ONCE(list_empty(&blkg->q_node));
|
2012-03-05 14:15:21 -07:00
|
|
|
WARN_ON_ONCE(hlist_unhashed(&blkg->blkcg_node));
|
2012-04-19 17:29:24 -06:00
|
|
|
|
2018-08-31 14:22:42 -06:00
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++) {
|
|
|
|
struct blkcg_policy *pol = blkcg_policy[i];
|
|
|
|
|
|
|
|
if (blkg->pd[i] && pol->pd_offline_fn)
|
|
|
|
pol->pd_offline_fn(blkg->pd[i]);
|
|
|
|
}
|
|
|
|
|
2013-01-09 09:05:12 -07:00
|
|
|
blkg->online = false;
|
|
|
|
|
2012-04-19 17:29:24 -06:00
|
|
|
radix_tree_delete(&blkcg->blkg_tree, blkg->q->id);
|
2012-03-05 14:15:20 -07:00
|
|
|
list_del_init(&blkg->q_node);
|
2012-03-05 14:15:21 -07:00
|
|
|
hlist_del_init_rcu(&blkg->blkcg_node);
|
2012-03-05 14:15:19 -07:00
|
|
|
|
2012-04-19 17:29:24 -06:00
|
|
|
/*
|
|
|
|
* Both setting lookup hint to and clearing it from @blkg are done
|
|
|
|
* under queue_lock. If it's not pointing to @blkg now, it never
|
|
|
|
* will. Hint assignment itself can race safely.
|
|
|
|
*/
|
2014-02-17 14:35:57 -07:00
|
|
|
if (rcu_access_pointer(blkcg->blkg_hint) == blkg)
|
2012-04-19 17:29:24 -06:00
|
|
|
rcu_assign_pointer(blkcg->blkg_hint, NULL);
|
|
|
|
|
2012-03-05 14:15:19 -07:00
|
|
|
/*
|
|
|
|
* Put the reference taken at the time of creation so that when all
|
|
|
|
* queues are gone, group can be destroyed.
|
|
|
|
*/
|
2018-12-05 10:10:38 -07:00
|
|
|
percpu_ref_kill(&blkg->refcnt);
|
2012-03-05 14:15:19 -07:00
|
|
|
}
|
|
|
|
|
2012-03-05 14:15:21 -07:00
|
|
|
/**
|
|
|
|
* blkg_destroy_all - destroy all blkgs associated with a request_queue
|
|
|
|
* @q: request_queue of interest
|
|
|
|
*
|
2012-04-13 14:11:34 -06:00
|
|
|
* Destroy all blkgs associated with @q.
|
2012-03-05 14:15:21 -07:00
|
|
|
*/
|
2012-04-13 14:11:34 -06:00
|
|
|
static void blkg_destroy_all(struct request_queue *q)
|
2012-03-05 14:15:00 -07:00
|
|
|
{
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_gq *blkg, *n;
|
2012-03-05 14:15:00 -07:00
|
|
|
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_lock_irq(&q->queue_lock);
|
2012-03-05 14:15:21 -07:00
|
|
|
list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg *blkcg = blkg->blkcg;
|
2012-03-05 14:15:00 -07:00
|
|
|
|
2012-03-05 14:15:21 -07:00
|
|
|
spin_lock(&blkcg->lock);
|
|
|
|
blkg_destroy(blkg);
|
|
|
|
spin_unlock(&blkcg->lock);
|
2012-03-05 14:15:00 -07:00
|
|
|
}
|
2015-09-05 13:47:36 -06:00
|
|
|
|
|
|
|
q->root_blkg = NULL;
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&q->queue_lock);
|
2012-03-05 14:15:00 -07:00
|
|
|
}
|
|
|
|
|
2013-08-08 18:11:24 -06:00
|
|
|
static int blkcg_reset_stats(struct cgroup_subsys_state *css,
|
|
|
|
struct cftype *cftype, u64 val)
|
2010-04-01 16:01:24 -06:00
|
|
|
{
|
2013-08-08 18:11:24 -06:00
|
|
|
struct blkcg *blkcg = css_to_blkcg(css);
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_gq *blkg;
|
2019-11-07 12:18:03 -07:00
|
|
|
int i, cpu;
|
2010-04-01 16:01:24 -06:00
|
|
|
|
2015-07-09 14:39:47 -06:00
|
|
|
mutex_lock(&blkcg_pol_mutex);
|
2010-04-01 16:01:24 -06:00
|
|
|
spin_lock_irq(&blkcg->lock);
|
2012-03-08 11:53:58 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that stat reset is racy - it doesn't synchronize against
|
|
|
|
* stat updates. This is a debug feature which shouldn't exist
|
|
|
|
* anyway. If you get hit by a race, retry.
|
|
|
|
*/
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry(blkg, &blkcg->blkg_list, blkcg_node) {
|
2019-11-07 12:18:03 -07:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
struct blkg_iostat_set *bis =
|
|
|
|
per_cpu_ptr(blkg->iostat_cpu, cpu);
|
|
|
|
memset(bis, 0, sizeof(*bis));
|
|
|
|
}
|
|
|
|
memset(&blkg->iostat, 0, sizeof(blkg->iostat));
|
2015-08-18 15:55:24 -06:00
|
|
|
|
2012-04-13 14:11:28 -06:00
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++) {
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_policy *pol = blkcg_policy[i];
|
2012-03-05 14:15:16 -07:00
|
|
|
|
2015-08-18 15:55:14 -06:00
|
|
|
if (blkg->pd[i] && pol->pd_reset_stats_fn)
|
|
|
|
pol->pd_reset_stats_fn(blkg->pd[i]);
|
2012-04-13 14:11:26 -06:00
|
|
|
}
|
2010-04-01 16:01:24 -06:00
|
|
|
}
|
2011-05-19 13:38:30 -06:00
|
|
|
|
2010-04-01 16:01:24 -06:00
|
|
|
spin_unlock_irq(&blkcg->lock);
|
2012-04-13 14:11:26 -06:00
|
|
|
mutex_unlock(&blkcg_pol_mutex);
|
2010-04-01 16:01:24 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-18 15:55:33 -06:00
|
|
|
const char *blkg_dev_name(struct blkcg_gq *blkg)
|
2010-04-01 16:01:24 -06:00
|
|
|
{
|
2012-04-01 15:38:42 -06:00
|
|
|
/* some drivers (floppy) instantiate a queue w/o disk registered */
|
2017-02-02 07:56:50 -07:00
|
|
|
if (blkg->q->backing_dev_info->dev)
|
|
|
|
return dev_name(blkg->q->backing_dev_info->dev);
|
2012-04-01 15:38:42 -06:00
|
|
|
return NULL;
|
2010-04-01 16:01:24 -06:00
|
|
|
}
|
|
|
|
|
2012-04-01 15:38:42 -06:00
|
|
|
/**
|
|
|
|
* blkcg_print_blkgs - helper for printing per-blkg data
|
|
|
|
* @sf: seq_file to print to
|
|
|
|
* @blkcg: blkcg of interest
|
|
|
|
* @prfill: fill function to print out a blkg
|
|
|
|
* @pol: policy in question
|
|
|
|
* @data: data to be passed to @prfill
|
|
|
|
* @show_total: to print out sum of prfill return values or not
|
|
|
|
*
|
|
|
|
* This function invokes @prfill on each blkg of @blkcg if pd for the
|
|
|
|
* policy specified by @pol exists. @prfill is invoked with @sf, the
|
2013-01-09 09:05:13 -07:00
|
|
|
* policy data and @data and the matching queue lock held. If @show_total
|
|
|
|
* is %true, the sum of the return values from @prfill is printed with
|
|
|
|
* "Total" label at the end.
|
2012-04-01 15:38:42 -06:00
|
|
|
*
|
|
|
|
* This is to be used to construct print functions for
|
|
|
|
* cftype->read_seq_string method.
|
|
|
|
*/
|
2012-04-16 14:57:25 -06:00
|
|
|
void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
|
2012-04-16 14:57:26 -06:00
|
|
|
u64 (*prfill)(struct seq_file *,
|
|
|
|
struct blkg_policy_data *, int),
|
2012-04-16 14:57:25 -06:00
|
|
|
const struct blkcg_policy *pol, int data,
|
2012-04-13 14:11:27 -06:00
|
|
|
bool show_total)
|
2011-05-19 13:38:28 -06:00
|
|
|
{
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_gq *blkg;
|
2012-04-01 15:38:42 -06:00
|
|
|
u64 total = 0;
|
2011-05-19 13:38:28 -06:00
|
|
|
|
2013-01-09 09:05:13 -07:00
|
|
|
rcu_read_lock();
|
2013-02-28 13:52:24 -07:00
|
|
|
hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_lock_irq(&blkg->q->queue_lock);
|
2012-04-13 14:11:33 -06:00
|
|
|
if (blkcg_policy_enabled(blkg->q, pol))
|
2012-04-16 14:57:26 -06:00
|
|
|
total += prfill(sf, blkg->pd[pol->plid], data);
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&blkg->q->queue_lock);
|
2013-01-09 09:05:13 -07:00
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2012-04-01 15:38:42 -06:00
|
|
|
|
|
|
|
if (show_total)
|
|
|
|
seq_printf(sf, "Total %llu\n", (unsigned long long)total);
|
|
|
|
}
|
2012-04-01 15:38:43 -06:00
|
|
|
EXPORT_SYMBOL_GPL(blkcg_print_blkgs);
|
2012-04-01 15:38:42 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* __blkg_prfill_u64 - prfill helper for a single u64 value
|
|
|
|
* @sf: seq_file to print to
|
2012-04-16 14:57:26 -06:00
|
|
|
* @pd: policy private data of interest
|
2012-04-01 15:38:42 -06:00
|
|
|
* @v: value to print
|
|
|
|
*
|
2012-04-16 14:57:26 -06:00
|
|
|
* Print @v to @sf for the device assocaited with @pd.
|
2012-04-01 15:38:42 -06:00
|
|
|
*/
|
2012-04-16 14:57:26 -06:00
|
|
|
u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v)
|
2012-04-01 15:38:42 -06:00
|
|
|
{
|
2012-04-16 14:57:26 -06:00
|
|
|
const char *dname = blkg_dev_name(pd->blkg);
|
2012-04-01 15:38:42 -06:00
|
|
|
|
|
|
|
if (!dname)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
seq_printf(sf, "%s %llu\n", dname, (unsigned long long)v);
|
|
|
|
return v;
|
|
|
|
}
|
2012-04-01 15:38:43 -06:00
|
|
|
EXPORT_SYMBOL_GPL(__blkg_prfill_u64);
|
2012-04-01 15:38:42 -06:00
|
|
|
|
2017-03-29 11:27:19 -06:00
|
|
|
/* Performs queue bypass and policy enabled checks then looks up blkg. */
|
|
|
|
static struct blkcg_gq *blkg_lookup_check(struct blkcg *blkcg,
|
|
|
|
const struct blkcg_policy *pol,
|
|
|
|
struct request_queue *q)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(!rcu_read_lock_held());
|
2018-11-15 12:17:28 -07:00
|
|
|
lockdep_assert_held(&q->queue_lock);
|
2017-03-29 11:27:19 -06:00
|
|
|
|
|
|
|
if (!blkcg_policy_enabled(q, pol))
|
|
|
|
return ERR_PTR(-EOPNOTSUPP);
|
|
|
|
return __blkg_lookup(blkcg, q, true /* update_hint */);
|
|
|
|
}
|
|
|
|
|
2019-08-28 16:05:53 -06:00
|
|
|
/**
|
|
|
|
* blkg_conf_prep - parse and prepare for per-blkg config update
|
|
|
|
* @inputp: input string pointer
|
|
|
|
*
|
|
|
|
* Parse the device node prefix part, MAJ:MIN, of per-blkg config update
|
|
|
|
* from @input and get and return the matching gendisk. *@inputp is
|
|
|
|
* updated to point past the device node prefix. Returns an ERR_PTR()
|
|
|
|
* value on error.
|
|
|
|
*
|
|
|
|
* Use this function iff blkg_conf_prep() can't be used for some reason.
|
|
|
|
*/
|
|
|
|
struct gendisk *blkcg_conf_get_disk(char **inputp)
|
|
|
|
{
|
|
|
|
char *input = *inputp;
|
|
|
|
unsigned int major, minor;
|
|
|
|
struct gendisk *disk;
|
|
|
|
int key_len, part;
|
|
|
|
|
|
|
|
if (sscanf(input, "%u:%u%n", &major, &minor, &key_len) != 2)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
input += key_len;
|
|
|
|
if (!isspace(*input))
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
input = skip_spaces(input);
|
|
|
|
|
|
|
|
disk = get_gendisk(MKDEV(major, minor), &part);
|
|
|
|
if (!disk)
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
if (part) {
|
|
|
|
put_disk_and_module(disk);
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
*inputp = input;
|
|
|
|
return disk;
|
|
|
|
}
|
|
|
|
|
2012-04-01 15:38:43 -06:00
|
|
|
/**
|
|
|
|
* blkg_conf_prep - parse and prepare for per-blkg config update
|
|
|
|
* @blkcg: target block cgroup
|
2012-04-13 14:11:29 -06:00
|
|
|
* @pol: target policy
|
2012-04-01 15:38:43 -06:00
|
|
|
* @input: input string
|
|
|
|
* @ctx: blkg_conf_ctx to be filled
|
|
|
|
*
|
|
|
|
* Parse per-blkg config update from @input and initialize @ctx with the
|
2015-08-18 15:55:31 -06:00
|
|
|
* result. @ctx->blkg points to the blkg to be updated and @ctx->body the
|
|
|
|
* part of @input following MAJ:MIN. This function returns with RCU read
|
|
|
|
* lock and queue lock held and must be paired with blkg_conf_finish().
|
2012-04-01 15:38:43 -06:00
|
|
|
*/
|
2012-04-16 14:57:25 -06:00
|
|
|
int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
|
2015-08-18 15:55:31 -06:00
|
|
|
char *input, struct blkg_conf_ctx *ctx)
|
2018-11-15 12:17:28 -07:00
|
|
|
__acquires(rcu) __acquires(&disk->queue->queue_lock)
|
2010-04-13 02:05:49 -06:00
|
|
|
{
|
2012-04-01 15:38:43 -06:00
|
|
|
struct gendisk *disk;
|
2017-03-29 11:27:19 -06:00
|
|
|
struct request_queue *q;
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_gq *blkg;
|
2019-08-28 16:05:53 -06:00
|
|
|
int ret;
|
2015-08-18 15:55:31 -06:00
|
|
|
|
2019-08-28 16:05:53 -06:00
|
|
|
disk = blkcg_conf_get_disk(&input);
|
|
|
|
if (IS_ERR(disk))
|
|
|
|
return PTR_ERR(disk);
|
2012-03-05 14:15:07 -07:00
|
|
|
|
2017-03-29 11:27:19 -06:00
|
|
|
q = disk->queue;
|
2012-04-13 14:11:29 -06:00
|
|
|
|
2017-03-29 11:27:19 -06:00
|
|
|
rcu_read_lock();
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_lock_irq(&q->queue_lock);
|
2012-03-05 14:15:07 -07:00
|
|
|
|
2017-03-29 11:27:19 -06:00
|
|
|
blkg = blkg_lookup_check(blkcg, pol, q);
|
2012-03-05 14:15:08 -07:00
|
|
|
if (IS_ERR(blkg)) {
|
|
|
|
ret = PTR_ERR(blkg);
|
2017-03-29 11:27:19 -06:00
|
|
|
goto fail_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (blkg)
|
|
|
|
goto success;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create blkgs walking down from blkcg_root to @blkcg, so that all
|
|
|
|
* non-root blkgs have access to their parents.
|
|
|
|
*/
|
|
|
|
while (true) {
|
|
|
|
struct blkcg *pos = blkcg;
|
|
|
|
struct blkcg *parent;
|
|
|
|
struct blkcg_gq *new_blkg;
|
|
|
|
|
|
|
|
parent = blkcg_parent(blkcg);
|
|
|
|
while (parent && !__blkg_lookup(parent, q, false)) {
|
|
|
|
pos = parent;
|
|
|
|
parent = blkcg_parent(parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Drop locks to do new blkg allocation with GFP_KERNEL. */
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&q->queue_lock);
|
2012-04-01 15:38:43 -06:00
|
|
|
rcu_read_unlock();
|
2017-03-29 11:27:19 -06:00
|
|
|
|
|
|
|
new_blkg = blkg_alloc(pos, q, GFP_KERNEL);
|
|
|
|
if (unlikely(!new_blkg)) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
2010-09-15 15:06:36 -06:00
|
|
|
}
|
2012-04-01 15:38:43 -06:00
|
|
|
|
2017-03-29 11:27:19 -06:00
|
|
|
rcu_read_lock();
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_lock_irq(&q->queue_lock);
|
2017-03-29 11:27:19 -06:00
|
|
|
|
|
|
|
blkg = blkg_lookup_check(pos, pol, q);
|
|
|
|
if (IS_ERR(blkg)) {
|
|
|
|
ret = PTR_ERR(blkg);
|
|
|
|
goto fail_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (blkg) {
|
|
|
|
blkg_free(new_blkg);
|
|
|
|
} else {
|
|
|
|
blkg = blkg_create(pos, q, new_blkg);
|
2019-06-05 08:24:27 -06:00
|
|
|
if (IS_ERR(blkg)) {
|
2017-03-29 11:27:19 -06:00
|
|
|
ret = PTR_ERR(blkg);
|
|
|
|
goto fail_unlock;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pos == blkcg)
|
|
|
|
goto success;
|
|
|
|
}
|
|
|
|
success:
|
2012-04-01 15:38:43 -06:00
|
|
|
ctx->disk = disk;
|
|
|
|
ctx->blkg = blkg;
|
2019-08-28 16:05:53 -06:00
|
|
|
ctx->body = input;
|
2012-04-01 15:38:43 -06:00
|
|
|
return 0;
|
2017-03-29 11:27:19 -06:00
|
|
|
|
|
|
|
fail_unlock:
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&q->queue_lock);
|
2017-03-29 11:27:19 -06:00
|
|
|
rcu_read_unlock();
|
|
|
|
fail:
|
2018-02-26 05:01:39 -07:00
|
|
|
put_disk_and_module(disk);
|
2017-03-29 11:27:19 -06:00
|
|
|
/*
|
|
|
|
* If queue was bypassing, we should retry. Do so after a
|
|
|
|
* short msleep(). It isn't strictly necessary but queue
|
|
|
|
* can be bypassing for some time and it's always nice to
|
|
|
|
* avoid busy looping.
|
|
|
|
*/
|
|
|
|
if (ret == -EBUSY) {
|
|
|
|
msleep(10);
|
|
|
|
ret = restart_syscall();
|
|
|
|
}
|
|
|
|
return ret;
|
2010-04-13 02:05:49 -06:00
|
|
|
}
|
2019-09-14 11:31:50 -06:00
|
|
|
EXPORT_SYMBOL_GPL(blkg_conf_prep);
|
2010-04-13 02:05:49 -06:00
|
|
|
|
2012-04-01 15:38:43 -06:00
|
|
|
/**
|
|
|
|
* blkg_conf_finish - finish up per-blkg config update
|
|
|
|
* @ctx: blkg_conf_ctx intiailized by blkg_conf_prep()
|
|
|
|
*
|
|
|
|
* Finish up after per-blkg config update. This function must be paired
|
|
|
|
* with blkg_conf_prep().
|
|
|
|
*/
|
2012-04-01 15:38:43 -06:00
|
|
|
void blkg_conf_finish(struct blkg_conf_ctx *ctx)
|
2018-11-15 12:17:28 -07:00
|
|
|
__releases(&ctx->disk->queue->queue_lock) __releases(rcu)
|
2010-04-13 02:05:49 -06:00
|
|
|
{
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&ctx->disk->queue->queue_lock);
|
2012-04-01 15:38:43 -06:00
|
|
|
rcu_read_unlock();
|
2018-02-26 05:01:39 -07:00
|
|
|
put_disk_and_module(ctx->disk);
|
2010-04-13 02:05:49 -06:00
|
|
|
}
|
2019-09-14 11:31:50 -06:00
|
|
|
EXPORT_SYMBOL_GPL(blkg_conf_finish);
|
2010-04-13 02:05:49 -06:00
|
|
|
|
2015-08-18 15:55:34 -06:00
|
|
|
static int blkcg_print_stat(struct seq_file *sf, void *v)
|
|
|
|
{
|
|
|
|
struct blkcg *blkcg = css_to_blkcg(seq_css(sf));
|
|
|
|
struct blkcg_gq *blkg;
|
|
|
|
|
2019-11-07 12:18:03 -07:00
|
|
|
cgroup_rstat_flush(blkcg->css.cgroup);
|
2015-08-18 15:55:34 -06:00
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
|
2019-11-07 12:18:03 -07:00
|
|
|
struct blkg_iostat_set *bis = &blkg->iostat;
|
2015-08-18 15:55:34 -06:00
|
|
|
const char *dname;
|
2018-07-03 09:14:52 -06:00
|
|
|
char *buf;
|
2018-07-18 05:47:41 -06:00
|
|
|
u64 rbytes, wbytes, rios, wios, dbytes, dios;
|
2018-07-03 09:14:52 -06:00
|
|
|
size_t size = seq_get_buf(sf, &buf), off = 0;
|
|
|
|
int i;
|
|
|
|
bool has_stats = false;
|
2019-11-07 12:18:03 -07:00
|
|
|
unsigned seq;
|
2015-08-18 15:55:34 -06:00
|
|
|
|
2019-11-05 09:09:51 -07:00
|
|
|
spin_lock_irq(&blkg->q->queue_lock);
|
|
|
|
|
|
|
|
if (!blkg->online)
|
|
|
|
goto skip;
|
|
|
|
|
2015-08-18 15:55:34 -06:00
|
|
|
dname = blkg_dev_name(blkg);
|
|
|
|
if (!dname)
|
2019-11-05 09:09:51 -07:00
|
|
|
goto skip;
|
2015-08-18 15:55:34 -06:00
|
|
|
|
2018-07-03 09:14:52 -06:00
|
|
|
/*
|
|
|
|
* Hooray string manipulation, count is the size written NOT
|
|
|
|
* INCLUDING THE \0, so size is now count+1 less than what we
|
|
|
|
* had before, but we want to start writing the next bit from
|
|
|
|
* the \0 so we only add count to buf.
|
|
|
|
*/
|
|
|
|
off += scnprintf(buf+off, size-off, "%s ", dname);
|
|
|
|
|
2019-11-07 12:18:03 -07:00
|
|
|
do {
|
|
|
|
seq = u64_stats_fetch_begin(&bis->sync);
|
2015-08-18 15:55:34 -06:00
|
|
|
|
2019-11-07 12:18:03 -07:00
|
|
|
rbytes = bis->cur.bytes[BLKG_IOSTAT_READ];
|
|
|
|
wbytes = bis->cur.bytes[BLKG_IOSTAT_WRITE];
|
|
|
|
dbytes = bis->cur.bytes[BLKG_IOSTAT_DISCARD];
|
|
|
|
rios = bis->cur.ios[BLKG_IOSTAT_READ];
|
|
|
|
wios = bis->cur.ios[BLKG_IOSTAT_WRITE];
|
|
|
|
dios = bis->cur.ios[BLKG_IOSTAT_DISCARD];
|
|
|
|
} while (u64_stats_fetch_retry(&bis->sync, seq));
|
2015-08-18 15:55:34 -06:00
|
|
|
|
2018-07-03 09:14:52 -06:00
|
|
|
if (rbytes || wbytes || rios || wios) {
|
|
|
|
has_stats = true;
|
|
|
|
off += scnprintf(buf+off, size-off,
|
2018-07-18 05:47:41 -06:00
|
|
|
"rbytes=%llu wbytes=%llu rios=%llu wios=%llu dbytes=%llu dios=%llu",
|
|
|
|
rbytes, wbytes, rios, wios,
|
|
|
|
dbytes, dios);
|
2018-07-03 09:14:52 -06:00
|
|
|
}
|
|
|
|
|
2019-07-16 08:58:31 -06:00
|
|
|
if (blkcg_debug_stats && atomic_read(&blkg->use_delay)) {
|
2018-07-03 09:14:55 -06:00
|
|
|
has_stats = true;
|
|
|
|
off += scnprintf(buf+off, size-off,
|
|
|
|
" use_delay=%d delay_nsec=%llu",
|
|
|
|
atomic_read(&blkg->use_delay),
|
|
|
|
(unsigned long long)atomic64_read(&blkg->delay_nsec));
|
|
|
|
}
|
|
|
|
|
2018-07-03 09:14:52 -06:00
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++) {
|
|
|
|
struct blkcg_policy *pol = blkcg_policy[i];
|
|
|
|
size_t written;
|
|
|
|
|
|
|
|
if (!blkg->pd[i] || !pol->pd_stat_fn)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
written = pol->pd_stat_fn(blkg->pd[i], buf+off, size-off);
|
|
|
|
if (written)
|
|
|
|
has_stats = true;
|
|
|
|
off += written;
|
|
|
|
}
|
2019-07-16 08:58:31 -06:00
|
|
|
|
2018-07-03 09:14:52 -06:00
|
|
|
if (has_stats) {
|
2019-06-13 16:30:38 -06:00
|
|
|
if (off < size - 1) {
|
|
|
|
off += scnprintf(buf+off, size-off, "\n");
|
|
|
|
seq_commit(sf, off);
|
|
|
|
} else {
|
|
|
|
seq_commit(sf, -1);
|
|
|
|
}
|
2018-07-03 09:14:52 -06:00
|
|
|
}
|
2019-11-05 09:09:51 -07:00
|
|
|
skip:
|
|
|
|
spin_unlock_irq(&blkg->q->queue_lock);
|
2015-08-18 15:55:34 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-14 09:04:32 -06:00
|
|
|
static struct cftype blkcg_files[] = {
|
2015-08-18 15:55:34 -06:00
|
|
|
{
|
|
|
|
.name = "stat",
|
2015-10-21 18:48:37 -06:00
|
|
|
.flags = CFTYPE_NOT_ON_ROOT,
|
2015-08-18 15:55:34 -06:00
|
|
|
.seq_show = blkcg_print_stat,
|
|
|
|
},
|
|
|
|
{ } /* terminate */
|
|
|
|
};
|
|
|
|
|
2016-06-14 09:04:32 -06:00
|
|
|
static struct cftype blkcg_legacy_files[] = {
|
2010-04-09 00:31:19 -06:00
|
|
|
{
|
|
|
|
.name = "reset_stats",
|
2012-04-16 14:57:25 -06:00
|
|
|
.write_u64 = blkcg_reset_stats,
|
2009-12-03 10:59:49 -07:00
|
|
|
},
|
2012-04-01 13:09:55 -06:00
|
|
|
{ } /* terminate */
|
2009-12-03 10:59:42 -07:00
|
|
|
};
|
|
|
|
|
2018-08-31 14:22:43 -06:00
|
|
|
/*
|
|
|
|
* blkcg destruction is a three-stage process.
|
|
|
|
*
|
|
|
|
* 1. Destruction starts. The blkcg_css_offline() callback is invoked
|
|
|
|
* which offlines writeback. Here we tie the next stage of blkg destruction
|
|
|
|
* to the completion of writeback associated with the blkcg. This lets us
|
|
|
|
* avoid punting potentially large amounts of outstanding writeback to root
|
|
|
|
* while maintaining any ongoing policies. The next stage is triggered when
|
|
|
|
* the nr_cgwbs count goes to zero.
|
|
|
|
*
|
|
|
|
* 2. When the nr_cgwbs count goes to zero, blkcg_destroy_blkgs() is called
|
|
|
|
* and handles the destruction of blkgs. Here the css reference held by
|
|
|
|
* the blkg is put back eventually allowing blkcg_css_free() to be called.
|
|
|
|
* This work may occur in cgwb_release_workfn() on the cgwb_release
|
|
|
|
* workqueue. Any submitted ios that fail to get the blkg ref will be
|
|
|
|
* punted to the root_blkg.
|
|
|
|
*
|
|
|
|
* 3. Once the blkcg ref count goes to zero, blkcg_css_free() is called.
|
|
|
|
* This finally frees the blkcg.
|
|
|
|
*/
|
|
|
|
|
2012-03-05 14:15:21 -07:00
|
|
|
/**
|
2012-11-19 09:13:38 -07:00
|
|
|
* blkcg_css_offline - cgroup css_offline callback
|
2013-08-08 18:11:23 -06:00
|
|
|
* @css: css of interest
|
2012-03-05 14:15:21 -07:00
|
|
|
*
|
2018-08-31 14:22:43 -06:00
|
|
|
* This function is called when @css is about to go away. Here the cgwbs are
|
|
|
|
* offlined first and only once writeback associated with the blkcg has
|
|
|
|
* finished do we start step 2 (see above).
|
2012-03-05 14:15:21 -07:00
|
|
|
*/
|
2013-08-08 18:11:23 -06:00
|
|
|
static void blkcg_css_offline(struct cgroup_subsys_state *css)
|
2009-12-03 10:59:42 -07:00
|
|
|
{
|
2013-08-08 18:11:23 -06:00
|
|
|
struct blkcg *blkcg = css_to_blkcg(css);
|
2009-12-03 10:59:47 -07:00
|
|
|
|
2018-08-31 14:22:43 -06:00
|
|
|
/* this prevents anyone from attaching or migrating to this blkcg */
|
|
|
|
wb_blkcg_offline(blkcg);
|
|
|
|
|
|
|
|
/* put the base cgwb reference allowing step 2 to be triggered */
|
|
|
|
blkcg_cgwb_put(blkcg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkcg_destroy_blkgs - responsible for shooting down blkgs
|
|
|
|
* @blkcg: blkcg of interest
|
|
|
|
*
|
|
|
|
* blkgs should be removed while holding both q and blkcg locks. As blkcg lock
|
|
|
|
* is nested inside q lock, this function performs reverse double lock dancing.
|
|
|
|
* Destroying the blkgs releases the reference held on the blkcg's css allowing
|
|
|
|
* blkcg_css_free to eventually be called.
|
|
|
|
*
|
|
|
|
* This is the blkcg counterpart of ioc_release_fn().
|
|
|
|
*/
|
|
|
|
void blkcg_destroy_blkgs(struct blkcg *blkcg)
|
|
|
|
{
|
2012-03-05 14:15:21 -07:00
|
|
|
spin_lock_irq(&blkcg->lock);
|
2012-03-05 14:15:11 -07:00
|
|
|
|
blk-throttle: fix race between blkcg_bio_issue_check() and cgroup_rmdir()
We've triggered a WARNING in blk_throtl_bio() when throttling writeback
io, which complains blkg->refcnt is already 0 when calling blkg_get(),
and then kernel crashes with invalid page request.
After investigating this issue, we've found it is caused by a race
between blkcg_bio_issue_check() and cgroup_rmdir(), which is described
below:
writeback kworker cgroup_rmdir
cgroup_destroy_locked
kill_css
css_killed_ref_fn
css_killed_work_fn
offline_css
blkcg_css_offline
blkcg_bio_issue_check
rcu_read_lock
blkg_lookup
spin_trylock(q->queue_lock)
blkg_destroy
spin_unlock(q->queue_lock)
blk_throtl_bio
spin_lock_irq(q->queue_lock)
...
spin_unlock_irq(q->queue_lock)
rcu_read_unlock
Since rcu can only prevent blkg from releasing when it is being used,
the blkg->refcnt can be decreased to 0 during blkg_destroy() and schedule
blkg release.
Then trying to blkg_get() in blk_throtl_bio() will complains the WARNING.
And then the corresponding blkg_put() will schedule blkg release again,
which result in double free.
This race is introduced by commit ae1188963611 ("blkcg: consolidate blkg
creation in blkcg_bio_issue_check()"). Before this commit, it will
lookup first and then try to lookup/create again with queue_lock. Since
revive this logic is a bit drastic, so fix it by only offlining pd during
blkcg_css_offline(), and move the rest destruction (especially
blkg_put()) into blkcg_css_free(), which should be the right way as
discussed.
Fixes: ae1188963611 ("blkcg: consolidate blkg creation in blkcg_bio_issue_check()")
Reported-by: Jiufei Xue <jiufei.xue@linux.alibaba.com>
Signed-off-by: Joseph Qi <joseph.qi@linux.alibaba.com>
Acked-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2018-03-16 00:51:27 -06:00
|
|
|
while (!hlist_empty(&blkcg->blkg_list)) {
|
|
|
|
struct blkcg_gq *blkg = hlist_entry(blkcg->blkg_list.first,
|
2018-08-31 14:22:42 -06:00
|
|
|
struct blkcg_gq, blkcg_node);
|
blk-throttle: fix race between blkcg_bio_issue_check() and cgroup_rmdir()
We've triggered a WARNING in blk_throtl_bio() when throttling writeback
io, which complains blkg->refcnt is already 0 when calling blkg_get(),
and then kernel crashes with invalid page request.
After investigating this issue, we've found it is caused by a race
between blkcg_bio_issue_check() and cgroup_rmdir(), which is described
below:
writeback kworker cgroup_rmdir
cgroup_destroy_locked
kill_css
css_killed_ref_fn
css_killed_work_fn
offline_css
blkcg_css_offline
blkcg_bio_issue_check
rcu_read_lock
blkg_lookup
spin_trylock(q->queue_lock)
blkg_destroy
spin_unlock(q->queue_lock)
blk_throtl_bio
spin_lock_irq(q->queue_lock)
...
spin_unlock_irq(q->queue_lock)
rcu_read_unlock
Since rcu can only prevent blkg from releasing when it is being used,
the blkg->refcnt can be decreased to 0 during blkg_destroy() and schedule
blkg release.
Then trying to blkg_get() in blk_throtl_bio() will complains the WARNING.
And then the corresponding blkg_put() will schedule blkg release again,
which result in double free.
This race is introduced by commit ae1188963611 ("blkcg: consolidate blkg
creation in blkcg_bio_issue_check()"). Before this commit, it will
lookup first and then try to lookup/create again with queue_lock. Since
revive this logic is a bit drastic, so fix it by only offlining pd during
blkcg_css_offline(), and move the rest destruction (especially
blkg_put()) into blkcg_css_free(), which should be the right way as
discussed.
Fixes: ae1188963611 ("blkcg: consolidate blkg creation in blkcg_bio_issue_check()")
Reported-by: Jiufei Xue <jiufei.xue@linux.alibaba.com>
Signed-off-by: Joseph Qi <joseph.qi@linux.alibaba.com>
Acked-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2018-03-16 00:51:27 -06:00
|
|
|
struct request_queue *q = blkg->q;
|
|
|
|
|
2018-11-15 12:17:28 -07:00
|
|
|
if (spin_trylock(&q->queue_lock)) {
|
blk-throttle: fix race between blkcg_bio_issue_check() and cgroup_rmdir()
We've triggered a WARNING in blk_throtl_bio() when throttling writeback
io, which complains blkg->refcnt is already 0 when calling blkg_get(),
and then kernel crashes with invalid page request.
After investigating this issue, we've found it is caused by a race
between blkcg_bio_issue_check() and cgroup_rmdir(), which is described
below:
writeback kworker cgroup_rmdir
cgroup_destroy_locked
kill_css
css_killed_ref_fn
css_killed_work_fn
offline_css
blkcg_css_offline
blkcg_bio_issue_check
rcu_read_lock
blkg_lookup
spin_trylock(q->queue_lock)
blkg_destroy
spin_unlock(q->queue_lock)
blk_throtl_bio
spin_lock_irq(q->queue_lock)
...
spin_unlock_irq(q->queue_lock)
rcu_read_unlock
Since rcu can only prevent blkg from releasing when it is being used,
the blkg->refcnt can be decreased to 0 during blkg_destroy() and schedule
blkg release.
Then trying to blkg_get() in blk_throtl_bio() will complains the WARNING.
And then the corresponding blkg_put() will schedule blkg release again,
which result in double free.
This race is introduced by commit ae1188963611 ("blkcg: consolidate blkg
creation in blkcg_bio_issue_check()"). Before this commit, it will
lookup first and then try to lookup/create again with queue_lock. Since
revive this logic is a bit drastic, so fix it by only offlining pd during
blkcg_css_offline(), and move the rest destruction (especially
blkg_put()) into blkcg_css_free(), which should be the right way as
discussed.
Fixes: ae1188963611 ("blkcg: consolidate blkg creation in blkcg_bio_issue_check()")
Reported-by: Jiufei Xue <jiufei.xue@linux.alibaba.com>
Signed-off-by: Joseph Qi <joseph.qi@linux.alibaba.com>
Acked-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2018-03-16 00:51:27 -06:00
|
|
|
blkg_destroy(blkg);
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock(&q->queue_lock);
|
blk-throttle: fix race between blkcg_bio_issue_check() and cgroup_rmdir()
We've triggered a WARNING in blk_throtl_bio() when throttling writeback
io, which complains blkg->refcnt is already 0 when calling blkg_get(),
and then kernel crashes with invalid page request.
After investigating this issue, we've found it is caused by a race
between blkcg_bio_issue_check() and cgroup_rmdir(), which is described
below:
writeback kworker cgroup_rmdir
cgroup_destroy_locked
kill_css
css_killed_ref_fn
css_killed_work_fn
offline_css
blkcg_css_offline
blkcg_bio_issue_check
rcu_read_lock
blkg_lookup
spin_trylock(q->queue_lock)
blkg_destroy
spin_unlock(q->queue_lock)
blk_throtl_bio
spin_lock_irq(q->queue_lock)
...
spin_unlock_irq(q->queue_lock)
rcu_read_unlock
Since rcu can only prevent blkg from releasing when it is being used,
the blkg->refcnt can be decreased to 0 during blkg_destroy() and schedule
blkg release.
Then trying to blkg_get() in blk_throtl_bio() will complains the WARNING.
And then the corresponding blkg_put() will schedule blkg release again,
which result in double free.
This race is introduced by commit ae1188963611 ("blkcg: consolidate blkg
creation in blkcg_bio_issue_check()"). Before this commit, it will
lookup first and then try to lookup/create again with queue_lock. Since
revive this logic is a bit drastic, so fix it by only offlining pd during
blkcg_css_offline(), and move the rest destruction (especially
blkg_put()) into blkcg_css_free(), which should be the right way as
discussed.
Fixes: ae1188963611 ("blkcg: consolidate blkg creation in blkcg_bio_issue_check()")
Reported-by: Jiufei Xue <jiufei.xue@linux.alibaba.com>
Signed-off-by: Joseph Qi <joseph.qi@linux.alibaba.com>
Acked-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2018-03-16 00:51:27 -06:00
|
|
|
} else {
|
|
|
|
spin_unlock_irq(&blkcg->lock);
|
|
|
|
cpu_relax();
|
|
|
|
spin_lock_irq(&blkcg->lock);
|
|
|
|
}
|
|
|
|
}
|
2018-08-31 14:22:42 -06:00
|
|
|
|
blk-throttle: fix race between blkcg_bio_issue_check() and cgroup_rmdir()
We've triggered a WARNING in blk_throtl_bio() when throttling writeback
io, which complains blkg->refcnt is already 0 when calling blkg_get(),
and then kernel crashes with invalid page request.
After investigating this issue, we've found it is caused by a race
between blkcg_bio_issue_check() and cgroup_rmdir(), which is described
below:
writeback kworker cgroup_rmdir
cgroup_destroy_locked
kill_css
css_killed_ref_fn
css_killed_work_fn
offline_css
blkcg_css_offline
blkcg_bio_issue_check
rcu_read_lock
blkg_lookup
spin_trylock(q->queue_lock)
blkg_destroy
spin_unlock(q->queue_lock)
blk_throtl_bio
spin_lock_irq(q->queue_lock)
...
spin_unlock_irq(q->queue_lock)
rcu_read_unlock
Since rcu can only prevent blkg from releasing when it is being used,
the blkg->refcnt can be decreased to 0 during blkg_destroy() and schedule
blkg release.
Then trying to blkg_get() in blk_throtl_bio() will complains the WARNING.
And then the corresponding blkg_put() will schedule blkg release again,
which result in double free.
This race is introduced by commit ae1188963611 ("blkcg: consolidate blkg
creation in blkcg_bio_issue_check()"). Before this commit, it will
lookup first and then try to lookup/create again with queue_lock. Since
revive this logic is a bit drastic, so fix it by only offlining pd during
blkcg_css_offline(), and move the rest destruction (especially
blkg_put()) into blkcg_css_free(), which should be the right way as
discussed.
Fixes: ae1188963611 ("blkcg: consolidate blkg creation in blkcg_bio_issue_check()")
Reported-by: Jiufei Xue <jiufei.xue@linux.alibaba.com>
Signed-off-by: Joseph Qi <joseph.qi@linux.alibaba.com>
Acked-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2018-03-16 00:51:27 -06:00
|
|
|
spin_unlock_irq(&blkcg->lock);
|
|
|
|
}
|
|
|
|
|
2013-08-08 18:11:23 -06:00
|
|
|
static void blkcg_css_free(struct cgroup_subsys_state *css)
|
2012-03-05 14:15:11 -07:00
|
|
|
{
|
2013-08-08 18:11:23 -06:00
|
|
|
struct blkcg *blkcg = css_to_blkcg(css);
|
2015-08-18 15:55:08 -06:00
|
|
|
int i;
|
2012-03-05 14:15:11 -07:00
|
|
|
|
2015-07-09 14:39:49 -06:00
|
|
|
mutex_lock(&blkcg_pol_mutex);
|
2015-08-18 15:55:16 -06:00
|
|
|
|
2015-07-09 14:39:49 -06:00
|
|
|
list_del(&blkcg->all_blkcgs_node);
|
|
|
|
|
2015-08-18 15:55:08 -06:00
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++)
|
2015-08-18 15:55:16 -06:00
|
|
|
if (blkcg->cpd[i])
|
|
|
|
blkcg_policy[i]->cpd_free_fn(blkcg->cpd[i]);
|
|
|
|
|
|
|
|
mutex_unlock(&blkcg_pol_mutex);
|
|
|
|
|
2015-08-18 15:55:08 -06:00
|
|
|
kfree(blkcg);
|
2009-12-03 10:59:42 -07:00
|
|
|
}
|
|
|
|
|
2013-08-08 18:11:23 -06:00
|
|
|
static struct cgroup_subsys_state *
|
|
|
|
blkcg_css_alloc(struct cgroup_subsys_state *parent_css)
|
2009-12-03 10:59:42 -07:00
|
|
|
{
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg *blkcg;
|
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-05 15:38:42 -06:00
|
|
|
struct cgroup_subsys_state *ret;
|
|
|
|
int i;
|
2009-12-03 10:59:42 -07:00
|
|
|
|
2015-07-09 14:39:49 -06:00
|
|
|
mutex_lock(&blkcg_pol_mutex);
|
|
|
|
|
2013-08-08 18:11:23 -06:00
|
|
|
if (!parent_css) {
|
2012-04-16 14:57:25 -06:00
|
|
|
blkcg = &blkcg_root;
|
2015-08-18 15:55:08 -06:00
|
|
|
} else {
|
|
|
|
blkcg = kzalloc(sizeof(*blkcg), GFP_KERNEL);
|
|
|
|
if (!blkcg) {
|
|
|
|
ret = ERR_PTR(-ENOMEM);
|
2017-08-25 09:49:32 -06:00
|
|
|
goto unlock;
|
2015-08-18 15:55:08 -06: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-05 15:38:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < BLKCG_MAX_POLS ; i++) {
|
|
|
|
struct blkcg_policy *pol = blkcg_policy[i];
|
|
|
|
struct blkcg_policy_data *cpd;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the policy hasn't been attached yet, wait for it
|
|
|
|
* to be attached before doing anything else. Otherwise,
|
|
|
|
* check if the policy requires any specific per-cgroup
|
|
|
|
* data: if it does, allocate and initialize it.
|
|
|
|
*/
|
2015-08-18 15:55:16 -06:00
|
|
|
if (!pol || !pol->cpd_alloc_fn)
|
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-05 15:38:42 -06:00
|
|
|
continue;
|
|
|
|
|
2015-08-18 15:55:16 -06:00
|
|
|
cpd = pol->cpd_alloc_fn(GFP_KERNEL);
|
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-05 15:38:42 -06:00
|
|
|
if (!cpd) {
|
|
|
|
ret = ERR_PTR(-ENOMEM);
|
|
|
|
goto free_pd_blkcg;
|
|
|
|
}
|
2015-08-18 15:55:15 -06:00
|
|
|
blkcg->cpd[i] = cpd;
|
|
|
|
cpd->blkcg = blkcg;
|
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-05 15:38:42 -06:00
|
|
|
cpd->plid = i;
|
2015-08-18 15:55:16 -06:00
|
|
|
if (pol->cpd_init_fn)
|
|
|
|
pol->cpd_init_fn(cpd);
|
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-05 15:38:42 -06:00
|
|
|
}
|
2009-12-03 10:59:42 -07:00
|
|
|
|
|
|
|
spin_lock_init(&blkcg->lock);
|
2016-11-21 16:03:32 -07:00
|
|
|
INIT_RADIX_TREE(&blkcg->blkg_tree, GFP_NOWAIT | __GFP_NOWARN);
|
2009-12-03 10:59:42 -07:00
|
|
|
INIT_HLIST_HEAD(&blkcg->blkg_list);
|
2015-05-22 15:13:37 -06:00
|
|
|
#ifdef CONFIG_CGROUP_WRITEBACK
|
|
|
|
INIT_LIST_HEAD(&blkcg->cgwb_list);
|
2018-08-31 14:22:43 -06:00
|
|
|
refcount_set(&blkcg->cgwb_refcnt, 1);
|
2015-05-22 15:13:37 -06:00
|
|
|
#endif
|
2015-07-09 14:39:49 -06:00
|
|
|
list_add_tail(&blkcg->all_blkcgs_node, &all_blkcgs);
|
|
|
|
|
|
|
|
mutex_unlock(&blkcg_pol_mutex);
|
2009-12-03 10:59:42 -07:00
|
|
|
return &blkcg->css;
|
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-05 15:38:42 -06:00
|
|
|
|
|
|
|
free_pd_blkcg:
|
|
|
|
for (i--; i >= 0; i--)
|
2015-08-18 15:55:16 -06:00
|
|
|
if (blkcg->cpd[i])
|
|
|
|
blkcg_policy[i]->cpd_free_fn(blkcg->cpd[i]);
|
2017-08-25 09:49:32 -06:00
|
|
|
|
|
|
|
if (blkcg != &blkcg_root)
|
|
|
|
kfree(blkcg);
|
|
|
|
unlock:
|
2015-07-09 14:39:49 -06:00
|
|
|
mutex_unlock(&blkcg_pol_mutex);
|
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-05 15:38:42 -06:00
|
|
|
return ret;
|
2009-12-03 10:59:42 -07:00
|
|
|
}
|
|
|
|
|
2012-03-05 14:15:12 -07:00
|
|
|
/**
|
|
|
|
* blkcg_init_queue - initialize blkcg part of request queue
|
|
|
|
* @q: request_queue to initialize
|
|
|
|
*
|
|
|
|
* Called from blk_alloc_queue_node(). Responsible for initializing blkcg
|
|
|
|
* part of new request_queue @q.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* 0 on success, -errno on failure.
|
|
|
|
*/
|
|
|
|
int blkcg_init_queue(struct request_queue *q)
|
|
|
|
{
|
2017-03-29 11:25:48 -06:00
|
|
|
struct blkcg_gq *new_blkg, *blkg;
|
|
|
|
bool preloaded;
|
2015-05-22 15:13:19 -06:00
|
|
|
int ret;
|
|
|
|
|
2017-03-29 11:25:48 -06:00
|
|
|
new_blkg = blkg_alloc(&blkcg_root, q, GFP_KERNEL);
|
|
|
|
if (!new_blkg)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
preloaded = !radix_tree_preload(GFP_KERNEL);
|
|
|
|
|
2018-04-18 22:04:26 -06:00
|
|
|
/* Make sure the root blkg exists. */
|
2015-05-22 15:13:19 -06:00
|
|
|
rcu_read_lock();
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_lock_irq(&q->queue_lock);
|
2017-03-29 11:25:48 -06:00
|
|
|
blkg = blkg_create(&blkcg_root, q, new_blkg);
|
2018-04-18 22:06:09 -06:00
|
|
|
if (IS_ERR(blkg))
|
|
|
|
goto err_unlock;
|
|
|
|
q->root_blkg = blkg;
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&q->queue_lock);
|
2015-05-22 15:13:19 -06:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2017-03-29 11:25:48 -06:00
|
|
|
if (preloaded)
|
|
|
|
radix_tree_preload_end();
|
|
|
|
|
2018-07-03 09:15:01 -06:00
|
|
|
ret = blk_iolatency_init(q);
|
2018-11-14 09:02:12 -07:00
|
|
|
if (ret)
|
|
|
|
goto err_destroy_all;
|
2018-07-03 09:15:01 -06:00
|
|
|
|
2015-05-22 15:13:19 -06:00
|
|
|
ret = blk_throtl_init(q);
|
2018-11-14 09:02:12 -07:00
|
|
|
if (ret)
|
|
|
|
goto err_destroy_all;
|
|
|
|
return 0;
|
2018-04-18 22:06:09 -06:00
|
|
|
|
2018-11-14 09:02:12 -07:00
|
|
|
err_destroy_all:
|
|
|
|
blkg_destroy_all(q);
|
|
|
|
return ret;
|
2018-04-18 22:06:09 -06:00
|
|
|
err_unlock:
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&q->queue_lock);
|
2018-04-18 22:06:09 -06:00
|
|
|
rcu_read_unlock();
|
|
|
|
if (preloaded)
|
|
|
|
radix_tree_preload_end();
|
|
|
|
return PTR_ERR(blkg);
|
2012-03-05 14:15:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkcg_exit_queue - exit and release blkcg part of request_queue
|
|
|
|
* @q: request_queue being released
|
|
|
|
*
|
2019-01-24 19:01:42 -07:00
|
|
|
* Called from blk_exit_queue(). Responsible for exiting blkcg part.
|
2012-03-05 14:15:12 -07:00
|
|
|
*/
|
|
|
|
void blkcg_exit_queue(struct request_queue *q)
|
|
|
|
{
|
2012-04-13 14:11:34 -06:00
|
|
|
blkg_destroy_all(q);
|
2012-03-05 14:15:12 -07:00
|
|
|
blk_throtl_exit(q);
|
|
|
|
}
|
|
|
|
|
2009-12-03 10:59:42 -07:00
|
|
|
/*
|
|
|
|
* We cannot support shared io contexts, as we have no mean to support
|
|
|
|
* two tasks with the same ioc in two different groups without major rework
|
|
|
|
* of the main cic data structures. For now we allow a task to change
|
|
|
|
* its cgroup only if it's the only owner of its ioc.
|
|
|
|
*/
|
cgroup: fix handling of multi-destination migration from subtree_control enabling
Consider the following v2 hierarchy.
P0 (+memory) --- P1 (-memory) --- A
\- B
P0 has memory enabled in its subtree_control while P1 doesn't. If
both A and B contain processes, they would belong to the memory css of
P1. Now if memory is enabled on P1's subtree_control, memory csses
should be created on both A and B and A's processes should be moved to
the former and B's processes the latter. IOW, enabling controllers
can cause atomic migrations into different csses.
The core cgroup migration logic has been updated accordingly but the
controller migration methods haven't and still assume that all tasks
migrate to a single target css; furthermore, the methods were fed the
css in which subtree_control was updated which is the parent of the
target csses. pids controller depends on the migration methods to
move charges and this made the controller attribute charges to the
wrong csses often triggering the following warning by driving a
counter negative.
WARNING: CPU: 1 PID: 1 at kernel/cgroup_pids.c:97 pids_cancel.constprop.6+0x31/0x40()
Modules linked in:
CPU: 1 PID: 1 Comm: systemd Not tainted 4.4.0-rc1+ #29
...
ffffffff81f65382 ffff88007c043b90 ffffffff81551ffc 0000000000000000
ffff88007c043bc8 ffffffff810de202 ffff88007a752000 ffff88007a29ab00
ffff88007c043c80 ffff88007a1d8400 0000000000000001 ffff88007c043bd8
Call Trace:
[<ffffffff81551ffc>] dump_stack+0x4e/0x82
[<ffffffff810de202>] warn_slowpath_common+0x82/0xc0
[<ffffffff810de2fa>] warn_slowpath_null+0x1a/0x20
[<ffffffff8118e031>] pids_cancel.constprop.6+0x31/0x40
[<ffffffff8118e0fd>] pids_can_attach+0x6d/0xf0
[<ffffffff81188a4c>] cgroup_taskset_migrate+0x6c/0x330
[<ffffffff81188e05>] cgroup_migrate+0xf5/0x190
[<ffffffff81189016>] cgroup_attach_task+0x176/0x200
[<ffffffff8118949d>] __cgroup_procs_write+0x2ad/0x460
[<ffffffff81189684>] cgroup_procs_write+0x14/0x20
[<ffffffff811854e5>] cgroup_file_write+0x35/0x1c0
[<ffffffff812e26f1>] kernfs_fop_write+0x141/0x190
[<ffffffff81265f88>] __vfs_write+0x28/0xe0
[<ffffffff812666fc>] vfs_write+0xac/0x1a0
[<ffffffff81267019>] SyS_write+0x49/0xb0
[<ffffffff81bcef32>] entry_SYSCALL_64_fastpath+0x12/0x76
This patch fixes the bug by removing @css parameter from the three
migration methods, ->can_attach, ->cancel_attach() and ->attach() and
updating cgroup_taskset iteration helpers also return the destination
css in addition to the task being migrated. All controllers are
updated accordingly.
* Controllers which don't care whether there are one or multiple
target csses can be converted trivially. cpu, io, freezer, perf,
netclassid and netprio fall in this category.
* cpuset's current implementation assumes that there's single source
and destination and thus doesn't support v2 hierarchy already. The
only change made by this patchset is how that single destination css
is obtained.
* memory migration path already doesn't do anything on v2. How the
single destination css is obtained is updated and the prep stage of
mem_cgroup_can_attach() is reordered to accomodate the change.
* pids is the only controller which was affected by this bug. It now
correctly handles multi-destination migrations and no longer causes
counter underflow from incorrect accounting.
Signed-off-by: Tejun Heo <tj@kernel.org>
Reported-and-tested-by: Daniel Wagner <daniel.wagner@bmw-carit.de>
Cc: Aleksa Sarai <cyphar@cyphar.com>
2015-12-03 08:18:21 -07:00
|
|
|
static int blkcg_can_attach(struct cgroup_taskset *tset)
|
2009-12-03 10:59:42 -07:00
|
|
|
{
|
2011-12-12 19:12:21 -07:00
|
|
|
struct task_struct *task;
|
cgroup: fix handling of multi-destination migration from subtree_control enabling
Consider the following v2 hierarchy.
P0 (+memory) --- P1 (-memory) --- A
\- B
P0 has memory enabled in its subtree_control while P1 doesn't. If
both A and B contain processes, they would belong to the memory css of
P1. Now if memory is enabled on P1's subtree_control, memory csses
should be created on both A and B and A's processes should be moved to
the former and B's processes the latter. IOW, enabling controllers
can cause atomic migrations into different csses.
The core cgroup migration logic has been updated accordingly but the
controller migration methods haven't and still assume that all tasks
migrate to a single target css; furthermore, the methods were fed the
css in which subtree_control was updated which is the parent of the
target csses. pids controller depends on the migration methods to
move charges and this made the controller attribute charges to the
wrong csses often triggering the following warning by driving a
counter negative.
WARNING: CPU: 1 PID: 1 at kernel/cgroup_pids.c:97 pids_cancel.constprop.6+0x31/0x40()
Modules linked in:
CPU: 1 PID: 1 Comm: systemd Not tainted 4.4.0-rc1+ #29
...
ffffffff81f65382 ffff88007c043b90 ffffffff81551ffc 0000000000000000
ffff88007c043bc8 ffffffff810de202 ffff88007a752000 ffff88007a29ab00
ffff88007c043c80 ffff88007a1d8400 0000000000000001 ffff88007c043bd8
Call Trace:
[<ffffffff81551ffc>] dump_stack+0x4e/0x82
[<ffffffff810de202>] warn_slowpath_common+0x82/0xc0
[<ffffffff810de2fa>] warn_slowpath_null+0x1a/0x20
[<ffffffff8118e031>] pids_cancel.constprop.6+0x31/0x40
[<ffffffff8118e0fd>] pids_can_attach+0x6d/0xf0
[<ffffffff81188a4c>] cgroup_taskset_migrate+0x6c/0x330
[<ffffffff81188e05>] cgroup_migrate+0xf5/0x190
[<ffffffff81189016>] cgroup_attach_task+0x176/0x200
[<ffffffff8118949d>] __cgroup_procs_write+0x2ad/0x460
[<ffffffff81189684>] cgroup_procs_write+0x14/0x20
[<ffffffff811854e5>] cgroup_file_write+0x35/0x1c0
[<ffffffff812e26f1>] kernfs_fop_write+0x141/0x190
[<ffffffff81265f88>] __vfs_write+0x28/0xe0
[<ffffffff812666fc>] vfs_write+0xac/0x1a0
[<ffffffff81267019>] SyS_write+0x49/0xb0
[<ffffffff81bcef32>] entry_SYSCALL_64_fastpath+0x12/0x76
This patch fixes the bug by removing @css parameter from the three
migration methods, ->can_attach, ->cancel_attach() and ->attach() and
updating cgroup_taskset iteration helpers also return the destination
css in addition to the task being migrated. All controllers are
updated accordingly.
* Controllers which don't care whether there are one or multiple
target csses can be converted trivially. cpu, io, freezer, perf,
netclassid and netprio fall in this category.
* cpuset's current implementation assumes that there's single source
and destination and thus doesn't support v2 hierarchy already. The
only change made by this patchset is how that single destination css
is obtained.
* memory migration path already doesn't do anything on v2. How the
single destination css is obtained is updated and the prep stage of
mem_cgroup_can_attach() is reordered to accomodate the change.
* pids is the only controller which was affected by this bug. It now
correctly handles multi-destination migrations and no longer causes
counter underflow from incorrect accounting.
Signed-off-by: Tejun Heo <tj@kernel.org>
Reported-and-tested-by: Daniel Wagner <daniel.wagner@bmw-carit.de>
Cc: Aleksa Sarai <cyphar@cyphar.com>
2015-12-03 08:18:21 -07:00
|
|
|
struct cgroup_subsys_state *dst_css;
|
2009-12-03 10:59:42 -07:00
|
|
|
struct io_context *ioc;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* task_lock() is needed to avoid races with exit_io_context() */
|
cgroup: fix handling of multi-destination migration from subtree_control enabling
Consider the following v2 hierarchy.
P0 (+memory) --- P1 (-memory) --- A
\- B
P0 has memory enabled in its subtree_control while P1 doesn't. If
both A and B contain processes, they would belong to the memory css of
P1. Now if memory is enabled on P1's subtree_control, memory csses
should be created on both A and B and A's processes should be moved to
the former and B's processes the latter. IOW, enabling controllers
can cause atomic migrations into different csses.
The core cgroup migration logic has been updated accordingly but the
controller migration methods haven't and still assume that all tasks
migrate to a single target css; furthermore, the methods were fed the
css in which subtree_control was updated which is the parent of the
target csses. pids controller depends on the migration methods to
move charges and this made the controller attribute charges to the
wrong csses often triggering the following warning by driving a
counter negative.
WARNING: CPU: 1 PID: 1 at kernel/cgroup_pids.c:97 pids_cancel.constprop.6+0x31/0x40()
Modules linked in:
CPU: 1 PID: 1 Comm: systemd Not tainted 4.4.0-rc1+ #29
...
ffffffff81f65382 ffff88007c043b90 ffffffff81551ffc 0000000000000000
ffff88007c043bc8 ffffffff810de202 ffff88007a752000 ffff88007a29ab00
ffff88007c043c80 ffff88007a1d8400 0000000000000001 ffff88007c043bd8
Call Trace:
[<ffffffff81551ffc>] dump_stack+0x4e/0x82
[<ffffffff810de202>] warn_slowpath_common+0x82/0xc0
[<ffffffff810de2fa>] warn_slowpath_null+0x1a/0x20
[<ffffffff8118e031>] pids_cancel.constprop.6+0x31/0x40
[<ffffffff8118e0fd>] pids_can_attach+0x6d/0xf0
[<ffffffff81188a4c>] cgroup_taskset_migrate+0x6c/0x330
[<ffffffff81188e05>] cgroup_migrate+0xf5/0x190
[<ffffffff81189016>] cgroup_attach_task+0x176/0x200
[<ffffffff8118949d>] __cgroup_procs_write+0x2ad/0x460
[<ffffffff81189684>] cgroup_procs_write+0x14/0x20
[<ffffffff811854e5>] cgroup_file_write+0x35/0x1c0
[<ffffffff812e26f1>] kernfs_fop_write+0x141/0x190
[<ffffffff81265f88>] __vfs_write+0x28/0xe0
[<ffffffff812666fc>] vfs_write+0xac/0x1a0
[<ffffffff81267019>] SyS_write+0x49/0xb0
[<ffffffff81bcef32>] entry_SYSCALL_64_fastpath+0x12/0x76
This patch fixes the bug by removing @css parameter from the three
migration methods, ->can_attach, ->cancel_attach() and ->attach() and
updating cgroup_taskset iteration helpers also return the destination
css in addition to the task being migrated. All controllers are
updated accordingly.
* Controllers which don't care whether there are one or multiple
target csses can be converted trivially. cpu, io, freezer, perf,
netclassid and netprio fall in this category.
* cpuset's current implementation assumes that there's single source
and destination and thus doesn't support v2 hierarchy already. The
only change made by this patchset is how that single destination css
is obtained.
* memory migration path already doesn't do anything on v2. How the
single destination css is obtained is updated and the prep stage of
mem_cgroup_can_attach() is reordered to accomodate the change.
* pids is the only controller which was affected by this bug. It now
correctly handles multi-destination migrations and no longer causes
counter underflow from incorrect accounting.
Signed-off-by: Tejun Heo <tj@kernel.org>
Reported-and-tested-by: Daniel Wagner <daniel.wagner@bmw-carit.de>
Cc: Aleksa Sarai <cyphar@cyphar.com>
2015-12-03 08:18:21 -07:00
|
|
|
cgroup_taskset_for_each(task, dst_css, tset) {
|
2011-12-12 19:12:21 -07:00
|
|
|
task_lock(task);
|
|
|
|
ioc = task->io_context;
|
|
|
|
if (ioc && atomic_read(&ioc->nr_tasks) > 1)
|
|
|
|
ret = -EINVAL;
|
|
|
|
task_unlock(task);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
}
|
2009-12-03 10:59:42 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-11-07 12:18:03 -07:00
|
|
|
static void blkg_iostat_set(struct blkg_iostat *dst, struct blkg_iostat *src)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BLKG_IOSTAT_NR; i++) {
|
|
|
|
dst->bytes[i] = src->bytes[i];
|
|
|
|
dst->ios[i] = src->ios[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void blkg_iostat_add(struct blkg_iostat *dst, struct blkg_iostat *src)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BLKG_IOSTAT_NR; i++) {
|
|
|
|
dst->bytes[i] += src->bytes[i];
|
|
|
|
dst->ios[i] += src->ios[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void blkg_iostat_sub(struct blkg_iostat *dst, struct blkg_iostat *src)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BLKG_IOSTAT_NR; i++) {
|
|
|
|
dst->bytes[i] -= src->bytes[i];
|
|
|
|
dst->ios[i] -= src->ios[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void blkcg_rstat_flush(struct cgroup_subsys_state *css, int cpu)
|
|
|
|
{
|
|
|
|
struct blkcg *blkcg = css_to_blkcg(css);
|
|
|
|
struct blkcg_gq *blkg;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
|
|
|
|
struct blkcg_gq *parent = blkg->parent;
|
|
|
|
struct blkg_iostat_set *bisc = per_cpu_ptr(blkg->iostat_cpu, cpu);
|
|
|
|
struct blkg_iostat cur, delta;
|
|
|
|
unsigned seq;
|
|
|
|
|
|
|
|
/* fetch the current per-cpu values */
|
|
|
|
do {
|
|
|
|
seq = u64_stats_fetch_begin(&bisc->sync);
|
|
|
|
blkg_iostat_set(&cur, &bisc->cur);
|
|
|
|
} while (u64_stats_fetch_retry(&bisc->sync, seq));
|
|
|
|
|
|
|
|
/* propagate percpu delta to global */
|
|
|
|
u64_stats_update_begin(&blkg->iostat.sync);
|
|
|
|
blkg_iostat_set(&delta, &cur);
|
|
|
|
blkg_iostat_sub(&delta, &bisc->last);
|
|
|
|
blkg_iostat_add(&blkg->iostat.cur, &delta);
|
|
|
|
blkg_iostat_add(&bisc->last, &delta);
|
|
|
|
u64_stats_update_end(&blkg->iostat.sync);
|
|
|
|
|
|
|
|
/* propagate global delta to parent */
|
|
|
|
if (parent) {
|
|
|
|
u64_stats_update_begin(&parent->iostat.sync);
|
|
|
|
blkg_iostat_set(&delta, &blkg->iostat.cur);
|
|
|
|
blkg_iostat_sub(&delta, &blkg->iostat.last);
|
|
|
|
blkg_iostat_add(&parent->iostat.cur, &delta);
|
|
|
|
blkg_iostat_add(&blkg->iostat.last, &delta);
|
|
|
|
u64_stats_update_end(&parent->iostat.sync);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2015-08-18 15:55:36 -06:00
|
|
|
static void blkcg_bind(struct cgroup_subsys_state *root_css)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_lock(&blkcg_pol_mutex);
|
|
|
|
|
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++) {
|
|
|
|
struct blkcg_policy *pol = blkcg_policy[i];
|
|
|
|
struct blkcg *blkcg;
|
|
|
|
|
|
|
|
if (!pol || !pol->cpd_bind_fn)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node)
|
|
|
|
if (blkcg->cpd[pol->plid])
|
|
|
|
pol->cpd_bind_fn(blkcg->cpd[pol->plid]);
|
|
|
|
}
|
|
|
|
mutex_unlock(&blkcg_pol_mutex);
|
|
|
|
}
|
|
|
|
|
2018-07-03 09:14:55 -06:00
|
|
|
static void blkcg_exit(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
if (tsk->throttle_queue)
|
|
|
|
blk_put_queue(tsk->throttle_queue);
|
|
|
|
tsk->throttle_queue = NULL;
|
|
|
|
}
|
|
|
|
|
blkcg: rename subsystem name from blkio to io
blkio interface has become messy over time and is currently the
largest. In addition to the inconsistent naming scheme, it has
multiple stat files which report more or less the same thing, a number
of debug stat files which expose internal details which shouldn't have
been part of the public interface in the first place, recursive and
non-recursive stats and leaf and non-leaf knobs.
Both recursive vs. non-recursive and leaf vs. non-leaf distinctions
don't make any sense on the unified hierarchy as only leaf cgroups can
contain processes. cgroups is going through a major interface
revision with the unified hierarchy involving significant fundamental
usage changes and given that a significant portion of the interface
doesn't make sense anymore, it's a good time to reorganize the
interface.
As the first step, this patch renames the external visible subsystem
name from "blkio" to "io". This is more concise, matches the other
two major subsystem names, "cpu" and "memory", and better suited as
blkcg will be involved in anything writeback related too whether an
actual block device is involved or not.
As the subsystem legacy_name is set to "blkio", the only userland
visible change outside the unified hierarchy is that blkcg is reported
as "io" instead of "blkio" in the subsystem initialized message during
boot. On the unified hierarchy, blkcg now appears as "io".
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: cgroups@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-08-18 15:55:29 -06:00
|
|
|
struct cgroup_subsys io_cgrp_subsys = {
|
2012-11-19 09:13:38 -07:00
|
|
|
.css_alloc = blkcg_css_alloc,
|
|
|
|
.css_offline = blkcg_css_offline,
|
|
|
|
.css_free = blkcg_css_free,
|
2012-04-16 14:57:25 -06:00
|
|
|
.can_attach = blkcg_can_attach,
|
2019-11-07 12:18:03 -07:00
|
|
|
.css_rstat_flush = blkcg_rstat_flush,
|
2015-08-18 15:55:36 -06:00
|
|
|
.bind = blkcg_bind,
|
2015-08-18 15:55:34 -06:00
|
|
|
.dfl_cftypes = blkcg_files,
|
2015-08-18 15:55:30 -06:00
|
|
|
.legacy_cftypes = blkcg_legacy_files,
|
blkcg: rename subsystem name from blkio to io
blkio interface has become messy over time and is currently the
largest. In addition to the inconsistent naming scheme, it has
multiple stat files which report more or less the same thing, a number
of debug stat files which expose internal details which shouldn't have
been part of the public interface in the first place, recursive and
non-recursive stats and leaf and non-leaf knobs.
Both recursive vs. non-recursive and leaf vs. non-leaf distinctions
don't make any sense on the unified hierarchy as only leaf cgroups can
contain processes. cgroups is going through a major interface
revision with the unified hierarchy involving significant fundamental
usage changes and given that a significant portion of the interface
doesn't make sense anymore, it's a good time to reorganize the
interface.
As the first step, this patch renames the external visible subsystem
name from "blkio" to "io". This is more concise, matches the other
two major subsystem names, "cpu" and "memory", and better suited as
blkcg will be involved in anything writeback related too whether an
actual block device is involved or not.
As the subsystem legacy_name is set to "blkio", the only userland
visible change outside the unified hierarchy is that blkcg is reported
as "io" instead of "blkio" in the subsystem initialized message during
boot. On the unified hierarchy, blkcg now appears as "io".
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: cgroups@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-08-18 15:55:29 -06:00
|
|
|
.legacy_name = "blkio",
|
2018-07-03 09:14:55 -06:00
|
|
|
.exit = blkcg_exit,
|
2014-07-08 16:02:57 -06:00
|
|
|
#ifdef CONFIG_MEMCG
|
|
|
|
/*
|
|
|
|
* This ensures that, if available, memcg is automatically enabled
|
|
|
|
* together on the default hierarchy so that the owner cgroup can
|
|
|
|
* be retrieved from writeback pages.
|
|
|
|
*/
|
|
|
|
.depends_on = 1 << memory_cgrp_id,
|
|
|
|
#endif
|
2012-04-01 13:09:55 -06:00
|
|
|
};
|
blkcg: rename subsystem name from blkio to io
blkio interface has become messy over time and is currently the
largest. In addition to the inconsistent naming scheme, it has
multiple stat files which report more or less the same thing, a number
of debug stat files which expose internal details which shouldn't have
been part of the public interface in the first place, recursive and
non-recursive stats and leaf and non-leaf knobs.
Both recursive vs. non-recursive and leaf vs. non-leaf distinctions
don't make any sense on the unified hierarchy as only leaf cgroups can
contain processes. cgroups is going through a major interface
revision with the unified hierarchy involving significant fundamental
usage changes and given that a significant portion of the interface
doesn't make sense anymore, it's a good time to reorganize the
interface.
As the first step, this patch renames the external visible subsystem
name from "blkio" to "io". This is more concise, matches the other
two major subsystem names, "cpu" and "memory", and better suited as
blkcg will be involved in anything writeback related too whether an
actual block device is involved or not.
As the subsystem legacy_name is set to "blkio", the only userland
visible change outside the unified hierarchy is that blkcg is reported
as "io" instead of "blkio" in the subsystem initialized message during
boot. On the unified hierarchy, blkcg now appears as "io".
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: cgroups@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-08-18 15:55:29 -06:00
|
|
|
EXPORT_SYMBOL_GPL(io_cgrp_subsys);
|
2012-04-01 13:09:55 -06:00
|
|
|
|
2012-04-13 14:11:33 -06:00
|
|
|
/**
|
|
|
|
* blkcg_activate_policy - activate a blkcg policy on a request_queue
|
|
|
|
* @q: request_queue of interest
|
|
|
|
* @pol: blkcg policy to activate
|
|
|
|
*
|
|
|
|
* Activate @pol on @q. Requires %GFP_KERNEL context. @q goes through
|
|
|
|
* bypass mode to populate its blkgs with policy_data for @pol.
|
|
|
|
*
|
|
|
|
* Activation happens with @q bypassed, so nobody would be accessing blkgs
|
|
|
|
* from IO path. Update of each blkg is protected by both queue and blkcg
|
|
|
|
* locks so that holding either lock and testing blkcg_policy_enabled() is
|
|
|
|
* always enough for dereferencing policy data.
|
|
|
|
*
|
|
|
|
* The caller is responsible for synchronizing [de]activations and policy
|
|
|
|
* [un]registerations. Returns 0 on success, -errno on failure.
|
|
|
|
*/
|
|
|
|
int blkcg_activate_policy(struct request_queue *q,
|
2012-04-16 14:57:25 -06:00
|
|
|
const struct blkcg_policy *pol)
|
2012-04-13 14:11:33 -06:00
|
|
|
{
|
2015-08-18 15:55:09 -06:00
|
|
|
struct blkg_policy_data *pd_prealloc = NULL;
|
2019-10-15 10:03:47 -06:00
|
|
|
struct blkcg_gq *blkg, *pinned_blkg = NULL;
|
2015-08-18 15:55:09 -06:00
|
|
|
int ret;
|
2012-04-13 14:11:33 -06:00
|
|
|
|
|
|
|
if (blkcg_policy_enabled(q, pol))
|
|
|
|
return 0;
|
|
|
|
|
2018-11-15 12:22:51 -07:00
|
|
|
if (queue_is_mq(q))
|
2017-01-17 06:03:22 -07:00
|
|
|
blk_mq_freeze_queue(q);
|
2019-10-15 10:03:47 -06:00
|
|
|
retry:
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_lock_irq(&q->queue_lock);
|
2012-04-13 14:11:33 -06:00
|
|
|
|
2019-10-15 10:03:47 -06:00
|
|
|
/* blkg_list is pushed at the head, reverse walk to allocate parents first */
|
2019-06-13 16:30:40 -06:00
|
|
|
list_for_each_entry_reverse(blkg, &q->blkg_list, q_node) {
|
2015-08-18 15:55:09 -06:00
|
|
|
struct blkg_policy_data *pd;
|
|
|
|
|
|
|
|
if (blkg->pd[pol->plid])
|
|
|
|
continue;
|
2012-04-13 14:11:33 -06:00
|
|
|
|
2019-10-15 10:03:47 -06:00
|
|
|
/* If prealloc matches, use it; otherwise try GFP_NOWAIT */
|
|
|
|
if (blkg == pinned_blkg) {
|
|
|
|
pd = pd_prealloc;
|
|
|
|
pd_prealloc = NULL;
|
|
|
|
} else {
|
|
|
|
pd = pol->pd_alloc_fn(GFP_NOWAIT | __GFP_NOWARN, q,
|
|
|
|
blkg->blkcg);
|
|
|
|
}
|
|
|
|
|
2015-08-18 15:55:09 -06:00
|
|
|
if (!pd) {
|
2019-10-15 10:03:47 -06:00
|
|
|
/*
|
|
|
|
* GFP_NOWAIT failed. Free the existing one and
|
|
|
|
* prealloc for @blkg w/ GFP_KERNEL.
|
|
|
|
*/
|
|
|
|
if (pinned_blkg)
|
|
|
|
blkg_put(pinned_blkg);
|
|
|
|
blkg_get(blkg);
|
|
|
|
pinned_blkg = blkg;
|
|
|
|
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&q->queue_lock);
|
2019-10-15 10:03:47 -06:00
|
|
|
|
|
|
|
if (pd_prealloc)
|
|
|
|
pol->pd_free_fn(pd_prealloc);
|
|
|
|
pd_prealloc = pol->pd_alloc_fn(GFP_KERNEL, q,
|
|
|
|
blkg->blkcg);
|
|
|
|
if (pd_prealloc)
|
|
|
|
goto retry;
|
|
|
|
else
|
|
|
|
goto enomem;
|
2015-08-18 15:55:09 -06:00
|
|
|
}
|
2012-04-13 14:11:33 -06:00
|
|
|
|
|
|
|
blkg->pd[pol->plid] = pd;
|
|
|
|
pd->blkg = blkg;
|
2013-01-09 09:05:12 -07:00
|
|
|
pd->plid = pol->plid;
|
2012-04-13 14:11:33 -06:00
|
|
|
}
|
|
|
|
|
2019-10-15 10:03:47 -06:00
|
|
|
/* all allocated, init in the same order */
|
|
|
|
if (pol->pd_init_fn)
|
|
|
|
list_for_each_entry_reverse(blkg, &q->blkg_list, q_node)
|
|
|
|
pol->pd_init_fn(blkg->pd[pol->plid]);
|
|
|
|
|
2012-04-13 14:11:33 -06:00
|
|
|
__set_bit(pol->plid, q->blkcg_pols);
|
|
|
|
ret = 0;
|
2015-08-18 15:55:09 -06:00
|
|
|
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&q->queue_lock);
|
2019-10-15 10:03:47 -06:00
|
|
|
out:
|
2018-11-15 12:22:51 -07:00
|
|
|
if (queue_is_mq(q))
|
2017-01-17 06:03:22 -07:00
|
|
|
blk_mq_unfreeze_queue(q);
|
2019-10-15 10:03:47 -06:00
|
|
|
if (pinned_blkg)
|
|
|
|
blkg_put(pinned_blkg);
|
2015-08-18 15:55:11 -06:00
|
|
|
if (pd_prealloc)
|
|
|
|
pol->pd_free_fn(pd_prealloc);
|
2012-04-13 14:11:33 -06:00
|
|
|
return ret;
|
2019-10-15 10:03:47 -06:00
|
|
|
|
|
|
|
enomem:
|
|
|
|
/* alloc failed, nothing's initialized yet, free everything */
|
|
|
|
spin_lock_irq(&q->queue_lock);
|
|
|
|
list_for_each_entry(blkg, &q->blkg_list, q_node) {
|
|
|
|
if (blkg->pd[pol->plid]) {
|
|
|
|
pol->pd_free_fn(blkg->pd[pol->plid]);
|
|
|
|
blkg->pd[pol->plid] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&q->queue_lock);
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
2012-04-13 14:11:33 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blkcg_activate_policy);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkcg_deactivate_policy - deactivate a blkcg policy on a request_queue
|
|
|
|
* @q: request_queue of interest
|
|
|
|
* @pol: blkcg policy to deactivate
|
|
|
|
*
|
|
|
|
* Deactivate @pol on @q. Follows the same synchronization rules as
|
|
|
|
* blkcg_activate_policy().
|
|
|
|
*/
|
|
|
|
void blkcg_deactivate_policy(struct request_queue *q,
|
2012-04-16 14:57:25 -06:00
|
|
|
const struct blkcg_policy *pol)
|
2012-04-13 14:11:33 -06:00
|
|
|
{
|
2012-04-16 14:57:25 -06:00
|
|
|
struct blkcg_gq *blkg;
|
2012-04-13 14:11:33 -06:00
|
|
|
|
|
|
|
if (!blkcg_policy_enabled(q, pol))
|
|
|
|
return;
|
|
|
|
|
2018-11-15 12:22:51 -07:00
|
|
|
if (queue_is_mq(q))
|
2017-01-17 06:03:22 -07:00
|
|
|
blk_mq_freeze_queue(q);
|
|
|
|
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_lock_irq(&q->queue_lock);
|
2012-04-13 14:11:33 -06:00
|
|
|
|
|
|
|
__clear_bit(pol->plid, q->blkcg_pols);
|
|
|
|
|
|
|
|
list_for_each_entry(blkg, &q->blkg_list, q_node) {
|
2015-08-18 15:55:11 -06:00
|
|
|
if (blkg->pd[pol->plid]) {
|
2018-08-31 14:22:42 -06:00
|
|
|
if (pol->pd_offline_fn)
|
2015-08-18 15:55:14 -06:00
|
|
|
pol->pd_offline_fn(blkg->pd[pol->plid]);
|
2015-08-18 15:55:11 -06:00
|
|
|
pol->pd_free_fn(blkg->pd[pol->plid]);
|
|
|
|
blkg->pd[pol->plid] = NULL;
|
|
|
|
}
|
2012-04-13 14:11:33 -06:00
|
|
|
}
|
|
|
|
|
2018-11-15 12:17:28 -07:00
|
|
|
spin_unlock_irq(&q->queue_lock);
|
2017-01-17 06:03:22 -07:00
|
|
|
|
2018-11-15 12:22:51 -07:00
|
|
|
if (queue_is_mq(q))
|
2017-01-17 06:03:22 -07:00
|
|
|
blk_mq_unfreeze_queue(q);
|
2012-04-13 14:11:33 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);
|
|
|
|
|
2012-04-13 14:11:28 -06:00
|
|
|
/**
|
2012-04-16 14:57:25 -06:00
|
|
|
* blkcg_policy_register - register a blkcg policy
|
|
|
|
* @pol: blkcg policy to register
|
2012-04-13 14:11:28 -06:00
|
|
|
*
|
2012-04-16 14:57:25 -06:00
|
|
|
* Register @pol with blkcg core. Might sleep and @pol may be modified on
|
|
|
|
* successful registration. Returns 0 on success and -errno on failure.
|
2012-04-13 14:11:28 -06:00
|
|
|
*/
|
2014-06-22 16:31:56 -06:00
|
|
|
int blkcg_policy_register(struct blkcg_policy *pol)
|
2009-12-04 08:36:42 -07:00
|
|
|
{
|
2015-07-09 14:39:50 -06:00
|
|
|
struct blkcg *blkcg;
|
2012-04-13 14:11:28 -06:00
|
|
|
int i, ret;
|
2012-03-05 14:15:20 -07:00
|
|
|
|
2015-07-09 14:39:47 -06:00
|
|
|
mutex_lock(&blkcg_pol_register_mutex);
|
2012-04-13 14:11:26 -06:00
|
|
|
mutex_lock(&blkcg_pol_mutex);
|
|
|
|
|
2012-04-13 14:11:28 -06:00
|
|
|
/* find an empty slot */
|
|
|
|
ret = -ENOSPC;
|
|
|
|
for (i = 0; i < BLKCG_MAX_POLS; i++)
|
2012-04-16 14:57:25 -06:00
|
|
|
if (!blkcg_policy[i])
|
2012-04-13 14:11:28 -06:00
|
|
|
break;
|
2018-09-11 10:59:53 -06:00
|
|
|
if (i >= BLKCG_MAX_POLS) {
|
|
|
|
pr_warn("blkcg_policy_register: BLKCG_MAX_POLS too small\n");
|
2015-07-09 14:39:47 -06:00
|
|
|
goto err_unlock;
|
2018-09-11 10:59:53 -06:00
|
|
|
}
|
2012-03-05 14:15:04 -07:00
|
|
|
|
2017-10-17 09:56:21 -06:00
|
|
|
/* Make sure cpd/pd_alloc_fn and cpd/pd_free_fn in pairs */
|
|
|
|
if ((!pol->cpd_alloc_fn ^ !pol->cpd_free_fn) ||
|
|
|
|
(!pol->pd_alloc_fn ^ !pol->pd_free_fn))
|
|
|
|
goto err_unlock;
|
|
|
|
|
2015-07-09 14:39:50 -06:00
|
|
|
/* register @pol */
|
2012-04-16 14:57:25 -06:00
|
|
|
pol->plid = i;
|
2015-07-09 14:39:50 -06:00
|
|
|
blkcg_policy[pol->plid] = pol;
|
|
|
|
|
|
|
|
/* allocate and install cpd's */
|
2015-08-18 15:55:16 -06:00
|
|
|
if (pol->cpd_alloc_fn) {
|
2015-07-09 14:39:50 -06:00
|
|
|
list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
|
|
|
|
struct blkcg_policy_data *cpd;
|
|
|
|
|
2015-08-18 15:55:16 -06:00
|
|
|
cpd = pol->cpd_alloc_fn(GFP_KERNEL);
|
2016-09-29 09:33:30 -06:00
|
|
|
if (!cpd)
|
2015-07-09 14:39:50 -06:00
|
|
|
goto err_free_cpds;
|
|
|
|
|
2015-08-18 15:55:15 -06:00
|
|
|
blkcg->cpd[pol->plid] = cpd;
|
|
|
|
cpd->blkcg = blkcg;
|
2015-07-09 14:39:50 -06:00
|
|
|
cpd->plid = pol->plid;
|
2019-08-28 16:05:52 -06:00
|
|
|
if (pol->cpd_init_fn)
|
|
|
|
pol->cpd_init_fn(cpd);
|
2015-07-09 14:39:50 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-09 14:39:47 -06:00
|
|
|
mutex_unlock(&blkcg_pol_mutex);
|
2012-04-13 14:11:28 -06:00
|
|
|
|
|
|
|
/* everything is in place, add intf files for the new policy */
|
2015-08-18 15:55:34 -06:00
|
|
|
if (pol->dfl_cftypes)
|
|
|
|
WARN_ON(cgroup_add_dfl_cftypes(&io_cgrp_subsys,
|
|
|
|
pol->dfl_cftypes));
|
2015-08-18 15:55:30 -06:00
|
|
|
if (pol->legacy_cftypes)
|
blkcg: rename subsystem name from blkio to io
blkio interface has become messy over time and is currently the
largest. In addition to the inconsistent naming scheme, it has
multiple stat files which report more or less the same thing, a number
of debug stat files which expose internal details which shouldn't have
been part of the public interface in the first place, recursive and
non-recursive stats and leaf and non-leaf knobs.
Both recursive vs. non-recursive and leaf vs. non-leaf distinctions
don't make any sense on the unified hierarchy as only leaf cgroups can
contain processes. cgroups is going through a major interface
revision with the unified hierarchy involving significant fundamental
usage changes and given that a significant portion of the interface
doesn't make sense anymore, it's a good time to reorganize the
interface.
As the first step, this patch renames the external visible subsystem
name from "blkio" to "io". This is more concise, matches the other
two major subsystem names, "cpu" and "memory", and better suited as
blkcg will be involved in anything writeback related too whether an
actual block device is involved or not.
As the subsystem legacy_name is set to "blkio", the only userland
visible change outside the unified hierarchy is that blkcg is reported
as "io" instead of "blkio" in the subsystem initialized message during
boot. On the unified hierarchy, blkcg now appears as "io".
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Li Zefan <lizefan@huawei.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: cgroups@vger.kernel.org
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-08-18 15:55:29 -06:00
|
|
|
WARN_ON(cgroup_add_legacy_cftypes(&io_cgrp_subsys,
|
2015-08-18 15:55:30 -06:00
|
|
|
pol->legacy_cftypes));
|
2015-07-09 14:39:47 -06:00
|
|
|
mutex_unlock(&blkcg_pol_register_mutex);
|
|
|
|
return 0;
|
|
|
|
|
2015-07-09 14:39:50 -06:00
|
|
|
err_free_cpds:
|
2017-10-10 08:53:46 -06:00
|
|
|
if (pol->cpd_free_fn) {
|
2015-07-09 14:39:50 -06:00
|
|
|
list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
|
2015-08-18 15:55:16 -06:00
|
|
|
if (blkcg->cpd[pol->plid]) {
|
|
|
|
pol->cpd_free_fn(blkcg->cpd[pol->plid]);
|
|
|
|
blkcg->cpd[pol->plid] = NULL;
|
|
|
|
}
|
2015-07-09 14:39:50 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
blkcg_policy[pol->plid] = NULL;
|
2015-07-09 14:39:47 -06:00
|
|
|
err_unlock:
|
2012-04-13 14:11:26 -06:00
|
|
|
mutex_unlock(&blkcg_pol_mutex);
|
2015-07-09 14:39:47 -06:00
|
|
|
mutex_unlock(&blkcg_pol_register_mutex);
|
2012-04-13 14:11:28 -06:00
|
|
|
return ret;
|
2009-12-04 08:36:42 -07:00
|
|
|
}
|
2012-04-16 14:57:25 -06:00
|
|
|
EXPORT_SYMBOL_GPL(blkcg_policy_register);
|
2009-12-04 08:36:42 -07:00
|
|
|
|
2012-04-13 14:11:28 -06:00
|
|
|
/**
|
2012-04-16 14:57:25 -06:00
|
|
|
* blkcg_policy_unregister - unregister a blkcg policy
|
|
|
|
* @pol: blkcg policy to unregister
|
2012-04-13 14:11:28 -06:00
|
|
|
*
|
2012-04-16 14:57:25 -06:00
|
|
|
* Undo blkcg_policy_register(@pol). Might sleep.
|
2012-04-13 14:11:28 -06:00
|
|
|
*/
|
2012-04-16 14:57:25 -06:00
|
|
|
void blkcg_policy_unregister(struct blkcg_policy *pol)
|
2009-12-04 08:36:42 -07:00
|
|
|
{
|
2015-07-09 14:39:50 -06:00
|
|
|
struct blkcg *blkcg;
|
|
|
|
|
2015-07-09 14:39:47 -06:00
|
|
|
mutex_lock(&blkcg_pol_register_mutex);
|
2012-04-13 14:11:26 -06:00
|
|
|
|
2012-04-16 14:57:25 -06:00
|
|
|
if (WARN_ON(blkcg_policy[pol->plid] != pol))
|
2012-04-13 14:11:28 -06:00
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
/* kill the intf files first */
|
2015-08-18 15:55:34 -06:00
|
|
|
if (pol->dfl_cftypes)
|
|
|
|
cgroup_rm_cftypes(pol->dfl_cftypes);
|
2015-08-18 15:55:30 -06:00
|
|
|
if (pol->legacy_cftypes)
|
|
|
|
cgroup_rm_cftypes(pol->legacy_cftypes);
|
2012-04-01 15:38:43 -06:00
|
|
|
|
2015-07-09 14:39:50 -06:00
|
|
|
/* remove cpds and unregister */
|
2015-07-09 14:39:47 -06:00
|
|
|
mutex_lock(&blkcg_pol_mutex);
|
2015-07-09 14:39:50 -06:00
|
|
|
|
2017-10-10 08:53:46 -06:00
|
|
|
if (pol->cpd_free_fn) {
|
2015-07-09 14:39:50 -06:00
|
|
|
list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
|
2015-08-18 15:55:16 -06:00
|
|
|
if (blkcg->cpd[pol->plid]) {
|
|
|
|
pol->cpd_free_fn(blkcg->cpd[pol->plid]);
|
|
|
|
blkcg->cpd[pol->plid] = NULL;
|
|
|
|
}
|
2015-07-09 14:39:50 -06:00
|
|
|
}
|
|
|
|
}
|
2012-04-16 14:57:25 -06:00
|
|
|
blkcg_policy[pol->plid] = NULL;
|
2015-07-09 14:39:50 -06:00
|
|
|
|
2012-04-13 14:11:26 -06:00
|
|
|
mutex_unlock(&blkcg_pol_mutex);
|
2015-07-09 14:39:47 -06:00
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&blkcg_pol_register_mutex);
|
2009-12-04 08:36:42 -07:00
|
|
|
}
|
2012-04-16 14:57:25 -06:00
|
|
|
EXPORT_SYMBOL_GPL(blkcg_policy_unregister);
|
2018-07-03 09:14:52 -06:00
|
|
|
|
2019-06-27 14:39:52 -06:00
|
|
|
bool __blkcg_punt_bio_submit(struct bio *bio)
|
|
|
|
{
|
|
|
|
struct blkcg_gq *blkg = bio->bi_blkg;
|
|
|
|
|
|
|
|
/* consume the flag first */
|
|
|
|
bio->bi_opf &= ~REQ_CGROUP_PUNT;
|
|
|
|
|
|
|
|
/* never bounce for the root cgroup */
|
|
|
|
if (!blkg->parent)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
spin_lock_bh(&blkg->async_bio_lock);
|
|
|
|
bio_list_add(&blkg->async_bios, bio);
|
|
|
|
spin_unlock_bh(&blkg->async_bio_lock);
|
|
|
|
|
|
|
|
queue_work(blkcg_punt_bio_wq, &blkg->async_bio_work);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-07-03 09:14:55 -06:00
|
|
|
/*
|
|
|
|
* Scale the accumulated delay based on how long it has been since we updated
|
|
|
|
* the delay. We only call this when we are adding delay, in case it's been a
|
|
|
|
* while since we added delay, and when we are checking to see if we need to
|
|
|
|
* delay a task, to account for any delays that may have occurred.
|
|
|
|
*/
|
|
|
|
static void blkcg_scale_delay(struct blkcg_gq *blkg, u64 now)
|
|
|
|
{
|
|
|
|
u64 old = atomic64_read(&blkg->delay_start);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only want to scale down every second. The idea here is that we
|
|
|
|
* want to delay people for min(delay_nsec, NSEC_PER_SEC) in a certain
|
|
|
|
* time window. We only want to throttle tasks for recent delay that
|
|
|
|
* has occurred, in 1 second time windows since that's the maximum
|
|
|
|
* things can be throttled. We save the current delay window in
|
|
|
|
* blkg->last_delay so we know what amount is still left to be charged
|
|
|
|
* to the blkg from this point onward. blkg->last_use keeps track of
|
|
|
|
* the use_delay counter. The idea is if we're unthrottling the blkg we
|
|
|
|
* are ok with whatever is happening now, and we can take away more of
|
|
|
|
* the accumulated delay as we've already throttled enough that
|
|
|
|
* everybody is happy with their IO latencies.
|
|
|
|
*/
|
|
|
|
if (time_before64(old + NSEC_PER_SEC, now) &&
|
|
|
|
atomic64_cmpxchg(&blkg->delay_start, old, now) == old) {
|
|
|
|
u64 cur = atomic64_read(&blkg->delay_nsec);
|
|
|
|
u64 sub = min_t(u64, blkg->last_delay, now - old);
|
|
|
|
int cur_use = atomic_read(&blkg->use_delay);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We've been unthrottled, subtract a larger chunk of our
|
|
|
|
* accumulated delay.
|
|
|
|
*/
|
|
|
|
if (cur_use < blkg->last_use)
|
|
|
|
sub = max_t(u64, sub, blkg->last_delay >> 1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This shouldn't happen, but handle it anyway. Our delay_nsec
|
|
|
|
* should only ever be growing except here where we subtract out
|
|
|
|
* min(last_delay, 1 second), but lord knows bugs happen and I'd
|
|
|
|
* rather not end up with negative numbers.
|
|
|
|
*/
|
|
|
|
if (unlikely(cur < sub)) {
|
|
|
|
atomic64_set(&blkg->delay_nsec, 0);
|
|
|
|
blkg->last_delay = 0;
|
|
|
|
} else {
|
|
|
|
atomic64_sub(sub, &blkg->delay_nsec);
|
|
|
|
blkg->last_delay = cur - sub;
|
|
|
|
}
|
|
|
|
blkg->last_use = cur_use;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called when we want to actually walk up the hierarchy and check to
|
|
|
|
* see if we need to throttle, and then actually throttle if there is some
|
|
|
|
* accumulated delay. This should only be called upon return to user space so
|
|
|
|
* we're not holding some lock that would induce a priority inversion.
|
|
|
|
*/
|
|
|
|
static void blkcg_maybe_throttle_blkg(struct blkcg_gq *blkg, bool use_memdelay)
|
|
|
|
{
|
2019-07-09 15:41:29 -06:00
|
|
|
unsigned long pflags;
|
2018-07-03 09:14:55 -06:00
|
|
|
u64 now = ktime_to_ns(ktime_get());
|
|
|
|
u64 exp;
|
|
|
|
u64 delay_nsec = 0;
|
|
|
|
int tok;
|
|
|
|
|
|
|
|
while (blkg->parent) {
|
|
|
|
if (atomic_read(&blkg->use_delay)) {
|
|
|
|
blkcg_scale_delay(blkg, now);
|
|
|
|
delay_nsec = max_t(u64, delay_nsec,
|
|
|
|
atomic64_read(&blkg->delay_nsec));
|
|
|
|
}
|
|
|
|
blkg = blkg->parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!delay_nsec)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Let's not sleep for all eternity if we've amassed a huge delay.
|
|
|
|
* Swapping or metadata IO can accumulate 10's of seconds worth of
|
|
|
|
* delay, and we want userspace to be able to do _something_ so cap the
|
|
|
|
* delays at 1 second. If there's 10's of seconds worth of delay then
|
|
|
|
* the tasks will be delayed for 1 second for every syscall.
|
|
|
|
*/
|
|
|
|
delay_nsec = min_t(u64, delay_nsec, 250 * NSEC_PER_MSEC);
|
|
|
|
|
2019-07-09 15:41:29 -06:00
|
|
|
if (use_memdelay)
|
|
|
|
psi_memstall_enter(&pflags);
|
2018-07-03 09:14:55 -06:00
|
|
|
|
|
|
|
exp = ktime_add_ns(now, delay_nsec);
|
|
|
|
tok = io_schedule_prepare();
|
|
|
|
do {
|
|
|
|
__set_current_state(TASK_KILLABLE);
|
|
|
|
if (!schedule_hrtimeout(&exp, HRTIMER_MODE_ABS))
|
|
|
|
break;
|
|
|
|
} while (!fatal_signal_pending(current));
|
|
|
|
io_schedule_finish(tok);
|
2019-07-09 15:41:29 -06:00
|
|
|
|
|
|
|
if (use_memdelay)
|
|
|
|
psi_memstall_leave(&pflags);
|
2018-07-03 09:14:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkcg_maybe_throttle_current - throttle the current task if it has been marked
|
|
|
|
*
|
|
|
|
* This is only called if we've been marked with set_notify_resume(). Obviously
|
|
|
|
* we can be set_notify_resume() for reasons other than blkcg throttling, so we
|
|
|
|
* check to see if current->throttle_queue is set and if not this doesn't do
|
|
|
|
* anything. This should only ever be called by the resume code, it's not meant
|
|
|
|
* to be called by people willy-nilly as it will actually do the work to
|
|
|
|
* throttle the task if it is setup for throttling.
|
|
|
|
*/
|
|
|
|
void blkcg_maybe_throttle_current(void)
|
|
|
|
{
|
|
|
|
struct request_queue *q = current->throttle_queue;
|
|
|
|
struct cgroup_subsys_state *css;
|
|
|
|
struct blkcg *blkcg;
|
|
|
|
struct blkcg_gq *blkg;
|
|
|
|
bool use_memdelay = current->use_memdelay;
|
|
|
|
|
|
|
|
if (!q)
|
|
|
|
return;
|
|
|
|
|
|
|
|
current->throttle_queue = NULL;
|
|
|
|
current->use_memdelay = false;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
css = kthread_blkcg();
|
|
|
|
if (css)
|
|
|
|
blkcg = css_to_blkcg(css);
|
|
|
|
else
|
|
|
|
blkcg = css_to_blkcg(task_css(current, io_cgrp_id));
|
|
|
|
|
|
|
|
if (!blkcg)
|
|
|
|
goto out;
|
|
|
|
blkg = blkg_lookup(blkcg, q);
|
|
|
|
if (!blkg)
|
|
|
|
goto out;
|
2018-12-05 10:10:39 -07:00
|
|
|
if (!blkg_tryget(blkg))
|
2018-07-03 09:14:55 -06:00
|
|
|
goto out;
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
blkcg_maybe_throttle_blkg(blkg, use_memdelay);
|
|
|
|
blkg_put(blkg);
|
2018-07-31 10:39:03 -06:00
|
|
|
blk_put_queue(q);
|
2018-07-03 09:14:55 -06:00
|
|
|
return;
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
|
|
|
blk_put_queue(q);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkcg_schedule_throttle - this task needs to check for throttling
|
2019-03-20 14:18:45 -06:00
|
|
|
* @q: the request queue IO was submitted on
|
|
|
|
* @use_memdelay: do we charge this to memory delay for PSI
|
2018-07-03 09:14:55 -06:00
|
|
|
*
|
|
|
|
* This is called by the IO controller when we know there's delay accumulated
|
|
|
|
* for the blkg for this task. We do not pass the blkg because there are places
|
|
|
|
* we call this that may not have that information, the swapping code for
|
|
|
|
* instance will only have a request_queue at that point. This set's the
|
|
|
|
* notify_resume for the task to check and see if it requires throttling before
|
|
|
|
* returning to user space.
|
|
|
|
*
|
|
|
|
* We will only schedule once per syscall. You can call this over and over
|
|
|
|
* again and it will only do the check once upon return to user space, and only
|
|
|
|
* throttle once. If the task needs to be throttled again it'll need to be
|
|
|
|
* re-set at the next time we see the task.
|
|
|
|
*/
|
|
|
|
void blkcg_schedule_throttle(struct request_queue *q, bool use_memdelay)
|
|
|
|
{
|
|
|
|
if (unlikely(current->flags & PF_KTHREAD))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!blk_get_queue(q))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (current->throttle_queue)
|
|
|
|
blk_put_queue(current->throttle_queue);
|
|
|
|
current->throttle_queue = q;
|
|
|
|
if (use_memdelay)
|
|
|
|
current->use_memdelay = use_memdelay;
|
|
|
|
set_notify_resume(current);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blkcg_add_delay - add delay to this blkg
|
2019-03-20 14:18:45 -06:00
|
|
|
* @blkg: blkg of interest
|
|
|
|
* @now: the current time in nanoseconds
|
|
|
|
* @delta: how many nanoseconds of delay to add
|
2018-07-03 09:14:55 -06:00
|
|
|
*
|
|
|
|
* Charge @delta to the blkg's current delay accumulation. This is used to
|
|
|
|
* throttle tasks if an IO controller thinks we need more throttling.
|
|
|
|
*/
|
|
|
|
void blkcg_add_delay(struct blkcg_gq *blkg, u64 now, u64 delta)
|
|
|
|
{
|
|
|
|
blkcg_scale_delay(blkg, now);
|
|
|
|
atomic64_add(delta, &blkg->delay_nsec);
|
|
|
|
}
|
|
|
|
|
2019-06-27 14:39:52 -06:00
|
|
|
static int __init blkcg_init(void)
|
|
|
|
{
|
|
|
|
blkcg_punt_bio_wq = alloc_workqueue("blkcg_punt_bio",
|
|
|
|
WQ_MEM_RECLAIM | WQ_FREEZABLE |
|
|
|
|
WQ_UNBOUND | WQ_SYSFS, 0);
|
|
|
|
if (!blkcg_punt_bio_wq)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
subsys_initcall(blkcg_init);
|
|
|
|
|
2018-07-03 09:14:52 -06:00
|
|
|
module_param(blkcg_debug_stats, bool, 0644);
|
|
|
|
MODULE_PARM_DESC(blkcg_debug_stats, "True if you want debug stats, false if not");
|