Skip to content

Commit

Permalink
---
Browse files Browse the repository at this point in the history 
yaml
---
r: 309268
b: refs/heads/master
c: a2b1693
h: refs/heads/master
v: v3
  • Loading branch information
Tejun Heo authored and Jens Axboe committed Apr 20, 2012
1 parent 771febe commit 691cd6d
Show file tree
Hide file tree
Showing 7 changed files with 202 additions and 135 deletions.
2 changes: 1 addition & 1 deletion [refs]
View file
Original file line number Diff line number Diff line change
@@ -1,2 +1,2 @@
---
refs/heads/master: 03d8e11142a893ad322285d3c8a08e88b570cda1
refs/heads/master: a2b1693bac45ea3fe3ba612fd22c45f17449f610
228 changes: 154 additions & 74 deletions trunk/block/blk-cgroup.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -54,6 +54,17 @@ struct blkio_cgroup *bio_blkio_cgroup(struct bio *bio)
}
EXPORT_SYMBOL_GPL(bio_blkio_cgroup);

static bool blkcg_policy_enabled(struct request_queue *q,
const struct blkio_policy_type *pol)
{
return pol && test_bit(pol->plid, q->blkcg_pols);
}

static size_t blkg_pd_size(const struct blkio_policy_type *pol)
{
return sizeof(struct blkg_policy_data) + pol->pdata_size;
}

/**
* blkg_free - free a blkg
* @blkg: blkg to free
Expand Down Expand Up @@ -111,12 +122,11 @@ static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg,
struct blkio_policy_type *pol = blkio_policy[i];
struct blkg_policy_data *pd;

if (!pol)
if (!blkcg_policy_enabled(q, pol))
continue;

/* alloc per-policy data and attach it to blkg */
pd = kzalloc_node(sizeof(*pd) + pol->pdata_size, GFP_ATOMIC,
q->node);
pd = kzalloc_node(blkg_pd_size(pol), GFP_ATOMIC, q->node);
if (!pd) {
blkg_free(blkg);
return NULL;
Expand All @@ -130,7 +140,7 @@ static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg,
for (i = 0; i < BLKCG_MAX_POLS; i++) {
struct blkio_policy_type *pol = blkio_policy[i];

if (pol)
if (blkcg_policy_enabled(blkg->q, pol))
pol->ops.blkio_init_group_fn(blkg);
}

Expand Down Expand Up @@ -236,36 +246,6 @@ static void blkg_destroy(struct blkio_group *blkg)
blkg_put(blkg);
}

/*
* XXX: This updates blkg policy data in-place for root blkg, which is
* necessary across elevator switch and policy registration as root blkgs
* aren't shot down. This broken and racy implementation is temporary.
* Eventually, blkg shoot down will be replaced by proper in-place update.
*/
void update_root_blkg_pd(struct request_queue *q,
const struct blkio_policy_type *pol)
{
struct blkio_group *blkg = blkg_lookup(&blkio_root_cgroup, q);
struct blkg_policy_data *pd;

if (!blkg)
return;

kfree(blkg->pd[pol->plid]);
blkg->pd[pol->plid] = NULL;

if (!pol)
return;

pd = kzalloc(sizeof(*pd) + pol->pdata_size, GFP_KERNEL);
WARN_ON_ONCE(!pd);

blkg->pd[pol->plid] = pd;
pd->blkg = blkg;
pol->ops.blkio_init_group_fn(blkg);
}
EXPORT_SYMBOL_GPL(update_root_blkg_pd);

/**
* blkg_destroy_all - destroy all blkgs associated with a request_queue
* @q: request_queue of interest
Expand Down Expand Up @@ -339,7 +319,8 @@ blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val)
for (i = 0; i < BLKCG_MAX_POLS; i++) {
struct blkio_policy_type *pol = blkio_policy[i];

if (pol && pol->ops.blkio_reset_group_stats_fn)
if (blkcg_policy_enabled(blkg->q, pol) &&
pol->ops.blkio_reset_group_stats_fn)
pol->ops.blkio_reset_group_stats_fn(blkg);
}
}
Expand Down Expand Up @@ -385,7 +366,7 @@ void blkcg_print_blkgs(struct seq_file *sf, struct blkio_cgroup *blkcg,

spin_lock_irq(&blkcg->lock);
hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node)
if (blkg->pd[pol->plid])
if (blkcg_policy_enabled(blkg->q, pol))
total += prfill(sf, blkg->pd[pol->plid]->pdata, data);
spin_unlock_irq(&blkcg->lock);

Expand Down Expand Up @@ -510,7 +491,10 @@ int blkg_conf_prep(struct blkio_cgroup *blkcg,
rcu_read_lock();
spin_lock_irq(disk->queue->queue_lock);

blkg = blkg_lookup_create(blkcg, disk->queue, false);
if (blkcg_policy_enabled(disk->queue, pol))
blkg = blkg_lookup_create(blkcg, disk->queue, false);
else
blkg = ERR_PTR(-EINVAL);

if (IS_ERR(blkg)) {
ret = PTR_ERR(blkg);
Expand Down Expand Up @@ -712,30 +696,6 @@ static int blkiocg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
return ret;
}

static void blkcg_bypass_start(void)
__acquires(&all_q_mutex)
{
struct request_queue *q;

mutex_lock(&all_q_mutex);

list_for_each_entry(q, &all_q_list, all_q_node) {
blk_queue_bypass_start(q);
blkg_destroy_all(q, false);
}
}

static void blkcg_bypass_end(void)
__releases(&all_q_mutex)
{
struct request_queue *q;

list_for_each_entry(q, &all_q_list, all_q_node)
blk_queue_bypass_end(q);

mutex_unlock(&all_q_mutex);
}

struct cgroup_subsys blkio_subsys = {
.name = "blkio",
.create = blkiocg_create,
Expand All @@ -748,6 +708,139 @@ struct cgroup_subsys blkio_subsys = {
};
EXPORT_SYMBOL_GPL(blkio_subsys);

/**
* 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,
const struct blkio_policy_type *pol)
{
LIST_HEAD(pds);
struct blkio_group *blkg;
struct blkg_policy_data *pd, *n;
int cnt = 0, ret;

if (blkcg_policy_enabled(q, pol))
return 0;

blk_queue_bypass_start(q);

/* make sure the root blkg exists and count the existing blkgs */
spin_lock_irq(q->queue_lock);

rcu_read_lock();
blkg = blkg_lookup_create(&blkio_root_cgroup, q, true);
rcu_read_unlock();

if (IS_ERR(blkg)) {
ret = PTR_ERR(blkg);
goto out_unlock;
}
q->root_blkg = blkg;

list_for_each_entry(blkg, &q->blkg_list, q_node)
cnt++;

spin_unlock_irq(q->queue_lock);

/* allocate policy_data for all existing blkgs */
while (cnt--) {
pd = kzalloc_node(blkg_pd_size(pol), GFP_KERNEL, q->node);
if (!pd) {
ret = -ENOMEM;
goto out_free;
}
list_add_tail(&pd->alloc_node, &pds);
}

/*
* Install the allocated pds. With @q bypassing, no new blkg
* should have been created while the queue lock was dropped.
*/
spin_lock_irq(q->queue_lock);

list_for_each_entry(blkg, &q->blkg_list, q_node) {
if (WARN_ON(list_empty(&pds))) {
/* umm... this shouldn't happen, just abort */
ret = -ENOMEM;
goto out_unlock;
}
pd = list_first_entry(&pds, struct blkg_policy_data, alloc_node);
list_del_init(&pd->alloc_node);

/* grab blkcg lock too while installing @pd on @blkg */
spin_lock(&blkg->blkcg->lock);

blkg->pd[pol->plid] = pd;
pd->blkg = blkg;
pol->ops.blkio_init_group_fn(blkg);

spin_unlock(&blkg->blkcg->lock);
}

__set_bit(pol->plid, q->blkcg_pols);
ret = 0;
out_unlock:
spin_unlock_irq(q->queue_lock);
out_free:
blk_queue_bypass_end(q);
list_for_each_entry_safe(pd, n, &pds, alloc_node)
kfree(pd);
return ret;
}
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,
const struct blkio_policy_type *pol)
{
struct blkio_group *blkg;

if (!blkcg_policy_enabled(q, pol))
return;

blk_queue_bypass_start(q);
spin_lock_irq(q->queue_lock);

__clear_bit(pol->plid, q->blkcg_pols);

list_for_each_entry(blkg, &q->blkg_list, q_node) {
/* grab blkcg lock too while removing @pd from @blkg */
spin_lock(&blkg->blkcg->lock);

if (pol->ops.blkio_exit_group_fn)
pol->ops.blkio_exit_group_fn(blkg);

kfree(blkg->pd[pol->plid]);
blkg->pd[pol->plid] = NULL;

spin_unlock(&blkg->blkcg->lock);
}

spin_unlock_irq(q->queue_lock);
blk_queue_bypass_end(q);
}
EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);

/**
* blkio_policy_register - register a blkcg policy
* @blkiop: blkcg policy to register
Expand All @@ -758,7 +851,6 @@ EXPORT_SYMBOL_GPL(blkio_subsys);
*/
int blkio_policy_register(struct blkio_policy_type *blkiop)
{
struct request_queue *q;
int i, ret;

mutex_lock(&blkcg_pol_mutex);
Expand All @@ -775,11 +867,6 @@ int blkio_policy_register(struct blkio_policy_type *blkiop)
blkiop->plid = i;
blkio_policy[i] = blkiop;

blkcg_bypass_start();
list_for_each_entry(q, &all_q_list, all_q_node)
update_root_blkg_pd(q, blkiop);
blkcg_bypass_end();

/* everything is in place, add intf files for the new policy */
if (blkiop->cftypes)
WARN_ON(cgroup_add_cftypes(&blkio_subsys, blkiop->cftypes));
Expand All @@ -798,8 +885,6 @@ EXPORT_SYMBOL_GPL(blkio_policy_register);
*/
void blkio_policy_unregister(struct blkio_policy_type *blkiop)
{
struct request_queue *q;

mutex_lock(&blkcg_pol_mutex);

if (WARN_ON(blkio_policy[blkiop->plid] != blkiop))
Expand All @@ -811,11 +896,6 @@ void blkio_policy_unregister(struct blkio_policy_type *blkiop)

/* unregister and update blkgs */
blkio_policy[blkiop->plid] = NULL;

blkcg_bypass_start();
list_for_each_entry(q, &all_q_list, all_q_node)
update_root_blkg_pd(q, blkiop);
blkcg_bypass_end();
out_unlock:
mutex_unlock(&blkcg_pol_mutex);
}
Expand Down
15 changes: 11 additions & 4 deletions trunk/block/blk-cgroup.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -64,6 +64,9 @@ struct blkg_policy_data {
/* the blkg this per-policy data belongs to */
struct blkio_group *blkg;

/* used during policy activation */
struct list_head alloc_node;

/* pol->pdata_size bytes of private data used by policy impl */
char pdata[] __aligned(__alignof__(unsigned long long));
};
Expand Down Expand Up @@ -108,9 +111,11 @@ extern void blkcg_exit_queue(struct request_queue *q);
/* Blkio controller policy registration */
extern int blkio_policy_register(struct blkio_policy_type *);
extern void blkio_policy_unregister(struct blkio_policy_type *);
extern int blkcg_activate_policy(struct request_queue *q,
const struct blkio_policy_type *pol);
extern void blkcg_deactivate_policy(struct request_queue *q,
const struct blkio_policy_type *pol);
extern void blkg_destroy_all(struct request_queue *q, bool destroy_root);
extern void update_root_blkg_pd(struct request_queue *q,
const struct blkio_policy_type *pol);

void blkcg_print_blkgs(struct seq_file *sf, struct blkio_cgroup *blkcg,
u64 (*prfill)(struct seq_file *, void *, int),
Expand Down Expand Up @@ -325,10 +330,12 @@ static inline void blkcg_drain_queue(struct request_queue *q) { }
static inline void blkcg_exit_queue(struct request_queue *q) { }
static inline int blkio_policy_register(struct blkio_policy_type *blkiop) { return 0; }
static inline void blkio_policy_unregister(struct blkio_policy_type *blkiop) { }
static inline int blkcg_activate_policy(struct request_queue *q,
const struct blkio_policy_type *pol) { return 0; }
static inline void blkcg_deactivate_policy(struct request_queue *q,
const struct blkio_policy_type *pol) { }
static inline void blkg_destroy_all(struct request_queue *q,
bool destory_root) { }
static inline void update_root_blkg_pd(struct request_queue *q,
const struct blkio_policy_type *pol) { }

static inline void *blkg_to_pdata(struct blkio_group *blkg,
struct blkio_policy_type *pol) { return NULL; }
Expand Down
Loading

0 comments on commit 691cd6d

Please sign in to comment.