lkml.org 
[lkml]   [2012]   [Jan]   [21]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH 16/17] blkcg: kill blkio_policy_node
Date
Now that blkcg configuration lives in blkg's, blkio_policy_node is no
longer necessary. Kill it.

blkio_policy_parse_and_set() now fails if invoked for missing device
and functions to print out configurations are updated to print from
blkg's.

cftype_blkg_same_policy() is dropped along with other policy functions
for consistency. Its one line is open coded in the only user -
blkio_read_blkg_stats().

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
---
block/blk-cgroup.c | 430 +++++++---------------------------------------------
block/blk-cgroup.h | 32 ----
2 files changed, 58 insertions(+), 404 deletions(-)
diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
index f9b4976..a983c43 100644
--- a/block/blk-cgroup.c
+++ b/block/blk-cgroup.c
@@ -58,54 +58,6 @@ struct cgroup_subsys blkio_subsys = {
};
EXPORT_SYMBOL_GPL(blkio_subsys);

-static inline void blkio_policy_insert_node(struct blkio_cgroup *blkcg,
- struct blkio_policy_node *pn)
-{
- list_add(&pn->node, &blkcg->policy_list);
-}
-
-static inline bool cftype_blkg_same_policy(struct cftype *cft,
- struct blkio_group *blkg)
-{
- enum blkio_policy_id plid = BLKIOFILE_POLICY(cft->private);
-
- if (blkg->plid == plid)
- return 1;
-
- return 0;
-}
-
-/* Determines if policy node matches cgroup file being accessed */
-static inline bool pn_matches_cftype(struct cftype *cft,
- struct blkio_policy_node *pn)
-{
- enum blkio_policy_id plid = BLKIOFILE_POLICY(cft->private);
- int fileid = BLKIOFILE_ATTR(cft->private);
-
- return (plid == pn->plid && fileid == pn->fileid);
-}
-
-/* Must be called with blkcg->lock held */
-static inline void blkio_policy_delete_node(struct blkio_policy_node *pn)
-{
- list_del(&pn->node);
-}
-
-/* Must be called with blkcg->lock held */
-static struct blkio_policy_node *
-blkio_policy_search_node(const struct blkio_cgroup *blkcg, dev_t dev,
- enum blkio_policy_id plid, int fileid)
-{
- struct blkio_policy_node *pn;
-
- list_for_each_entry(pn, &blkcg->policy_list, node) {
- if (pn->dev == dev && pn->plid == plid && pn->fileid == fileid)
- return pn;
- }
-
- return NULL;
-}
-
struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
{
return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),
@@ -818,10 +770,8 @@ static uint64_t blkio_get_stat(struct blkio_group *blkg,
return disk_total;
}

-static int blkio_policy_parse_and_set(char *buf,
- struct blkio_policy_node *newpn,
- enum blkio_policy_id plid, int fileid,
- struct blkio_cgroup *blkcg)
+static int blkio_policy_parse_and_set(char *buf, enum blkio_policy_id plid,
+ int fileid, struct blkio_cgroup *blkcg)
{
struct gendisk *disk = NULL;
struct blkio_group *blkg = NULL;
@@ -869,23 +819,18 @@ static int blkio_policy_parse_and_set(char *buf,
if (strict_strtoull(s[1], 10, &temp))
goto out;

- /* For rule removal, do not check for device presence. */
disk = get_gendisk(dev, &part);
-
- if ((!disk || part) && temp) {
- ret = -ENODEV;
+ if (!disk || part)
goto out;
- }

rcu_read_lock();

- if (disk && !part) {
- spin_lock_irq(disk->queue->queue_lock);
- blkg = blkg_lookup_create(blkcg, disk->queue, plid);
- spin_unlock_irq(disk->queue->queue_lock);
- }
+ spin_lock_irq(disk->queue->queue_lock);
+ blkg = blkg_lookup_create(blkcg, disk->queue, plid);
+ spin_unlock_irq(disk->queue->queue_lock);

- newpn->dev = dev;
+ if (!blkg)
+ goto out_unlock;

switch (plid) {
case BLKIO_POLICY_PROP:
@@ -893,47 +838,30 @@ static int blkio_policy_parse_and_set(char *buf,
temp > BLKIO_WEIGHT_MAX)
goto out_unlock;

- newpn->plid = plid;
- newpn->fileid = fileid;
- newpn->val.weight = temp;
- if (blkg)
- blkg->conf.weight = temp;
+ blkg->conf.weight = temp;
+ blkio_update_group_weight(blkg, temp ?: blkcg->weight);
break;
case BLKIO_POLICY_THROTL:
switch(fileid) {
case BLKIO_THROTL_read_bps_device:
- if (blkg)
- blkg->conf.bps[READ] = temp;
- newpn->plid = plid;
- newpn->fileid = fileid;
- newpn->val.bps = temp;
+ blkg->conf.bps[READ] = temp;
+ blkio_update_group_bps(blkg, temp ?: -1, fileid);
break;
case BLKIO_THROTL_write_bps_device:
- if (blkg)
- blkg->conf.bps[WRITE] = temp;
- newpn->plid = plid;
- newpn->fileid = fileid;
- newpn->val.bps = temp;
+ blkg->conf.bps[WRITE] = temp;
+ blkio_update_group_bps(blkg, temp ?: -1, fileid);
break;
case BLKIO_THROTL_read_iops_device:
if (temp > THROTL_IOPS_MAX)
goto out_unlock;
-
- if (blkg)
- blkg->conf.iops[READ] = temp;
- newpn->plid = plid;
- newpn->fileid = fileid;
- newpn->val.iops = (unsigned int)temp;
+ blkg->conf.iops[READ] = temp;
+ blkio_update_group_iops(blkg, temp ?: -1, fileid);
break;
case BLKIO_THROTL_write_iops_device:
if (temp > THROTL_IOPS_MAX)
goto out_unlock;
-
- if (blkg)
- blkg->conf.iops[WRITE] = temp;
- newpn->plid = plid;
- newpn->fileid = fileid;
- newpn->val.iops = (unsigned int)temp;
+ blkg->conf.iops[WRITE] = temp;
+ blkio_update_group_iops(blkg, temp ?: -1, fileid);
break;
}
break;
@@ -948,212 +876,12 @@ out:
return ret;
}

-unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
- dev_t dev)
-{
- struct blkio_policy_node *pn;
- unsigned long flags;
- unsigned int weight;
-
- spin_lock_irqsave(&blkcg->lock, flags);
-
- pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_PROP,
- BLKIO_PROP_weight_device);
- if (pn)
- weight = pn->val.weight;
- else
- weight = blkcg->weight;
-
- spin_unlock_irqrestore(&blkcg->lock, flags);
-
- return weight;
-}
-EXPORT_SYMBOL_GPL(blkcg_get_weight);
-
-uint64_t blkcg_get_read_bps(struct blkio_cgroup *blkcg, dev_t dev)
-{
- struct blkio_policy_node *pn;
- unsigned long flags;
- uint64_t bps = -1;
-
- spin_lock_irqsave(&blkcg->lock, flags);
- pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_THROTL,
- BLKIO_THROTL_read_bps_device);
- if (pn)
- bps = pn->val.bps;
- spin_unlock_irqrestore(&blkcg->lock, flags);
-
- return bps;
-}
-
-uint64_t blkcg_get_write_bps(struct blkio_cgroup *blkcg, dev_t dev)
-{
- struct blkio_policy_node *pn;
- unsigned long flags;
- uint64_t bps = -1;
-
- spin_lock_irqsave(&blkcg->lock, flags);
- pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_THROTL,
- BLKIO_THROTL_write_bps_device);
- if (pn)
- bps = pn->val.bps;
- spin_unlock_irqrestore(&blkcg->lock, flags);
-
- return bps;
-}
-
-unsigned int blkcg_get_read_iops(struct blkio_cgroup *blkcg, dev_t dev)
-{
- struct blkio_policy_node *pn;
- unsigned long flags;
- unsigned int iops = -1;
-
- spin_lock_irqsave(&blkcg->lock, flags);
- pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_THROTL,
- BLKIO_THROTL_read_iops_device);
- if (pn)
- iops = pn->val.iops;
- spin_unlock_irqrestore(&blkcg->lock, flags);
-
- return iops;
-}
-
-unsigned int blkcg_get_write_iops(struct blkio_cgroup *blkcg, dev_t dev)
-{
- struct blkio_policy_node *pn;
- unsigned long flags;
- unsigned int iops = -1;
-
- spin_lock_irqsave(&blkcg->lock, flags);
- pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_THROTL,
- BLKIO_THROTL_write_iops_device);
- if (pn)
- iops = pn->val.iops;
- spin_unlock_irqrestore(&blkcg->lock, flags);
-
- return iops;
-}
-
-/* Checks whether user asked for deleting a policy rule */
-static bool blkio_delete_rule_command(struct blkio_policy_node *pn)
-{
- switch(pn->plid) {
- case BLKIO_POLICY_PROP:
- if (pn->val.weight == 0)
- return 1;
- break;
- case BLKIO_POLICY_THROTL:
- switch(pn->fileid) {
- case BLKIO_THROTL_read_bps_device:
- case BLKIO_THROTL_write_bps_device:
- if (pn->val.bps == 0)
- return 1;
- break;
- case BLKIO_THROTL_read_iops_device:
- case BLKIO_THROTL_write_iops_device:
- if (pn->val.iops == 0)
- return 1;
- }
- break;
- default:
- BUG();
- }
-
- return 0;
-}
-
-static void blkio_update_policy_rule(struct blkio_policy_node *oldpn,
- struct blkio_policy_node *newpn)
-{
- switch(oldpn->plid) {
- case BLKIO_POLICY_PROP:
- oldpn->val.weight = newpn->val.weight;
- break;
- case BLKIO_POLICY_THROTL:
- switch(newpn->fileid) {
- case BLKIO_THROTL_read_bps_device:
- case BLKIO_THROTL_write_bps_device:
- oldpn->val.bps = newpn->val.bps;
- break;
- case BLKIO_THROTL_read_iops_device:
- case BLKIO_THROTL_write_iops_device:
- oldpn->val.iops = newpn->val.iops;
- }
- break;
- default:
- BUG();
- }
-}
-
-/*
- * Some rules/values in blkg have changed. Propagate those to respective
- * policies.
- */
-static void blkio_update_blkg_policy(struct blkio_cgroup *blkcg,
- struct blkio_group *blkg, struct blkio_policy_node *pn)
-{
- struct blkio_group_conf *conf = &blkg->conf;
-
- switch(pn->plid) {
- case BLKIO_POLICY_PROP:
- blkio_update_group_weight(blkg, conf->weight ?: blkcg->weight);
- break;
- case BLKIO_POLICY_THROTL:
- switch(pn->fileid) {
- case BLKIO_THROTL_read_bps_device:
- blkio_update_group_bps(blkg, conf->bps[READ] ?: -1,
- pn->fileid);
- break;
- case BLKIO_THROTL_write_bps_device:
- blkio_update_group_bps(blkg, conf->bps[WRITE] ?: -1,
- pn->fileid);
- break;
- case BLKIO_THROTL_read_iops_device:
- blkio_update_group_iops(blkg, conf->iops[READ] ?: -1,
- pn->fileid);
- break;
- case BLKIO_THROTL_write_iops_device:
- blkio_update_group_iops(blkg, conf->iops[WRITE] ?: -1,
- pn->fileid);
- break;
- }
- break;
- default:
- BUG();
- }
-}
-
-/*
- * A policy node rule has been updated. Propagate this update to all the
- * block groups which might be affected by this update.
- */
-static void blkio_update_policy_node_blkg(struct blkio_cgroup *blkcg,
- struct blkio_policy_node *pn)
-{
- struct blkio_group *blkg;
- struct hlist_node *n;
-
- spin_lock_irq(&blkio_list_lock);
- spin_lock(&blkcg->lock);
-
- hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
- if (pn->dev != blkg->dev || pn->plid != blkg->plid)
- continue;
- blkio_update_blkg_policy(blkcg, blkg, pn);
- }
-
- spin_unlock(&blkcg->lock);
- spin_unlock_irq(&blkio_list_lock);
-}
-
static int blkiocg_file_write(struct cgroup *cgrp, struct cftype *cft,
const char *buffer)
{
int ret = 0;
char *buf;
- struct blkio_policy_node *newpn, *pn;
struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgrp);
- int keep_newpn = 0;
enum blkio_policy_id plid = BLKIOFILE_POLICY(cft->private);
int fileid = BLKIOFILE_ATTR(cft->private);

@@ -1161,69 +889,42 @@ static int blkiocg_file_write(struct cgroup *cgrp, struct cftype *cft,
if (!buf)
return -ENOMEM;

- newpn = kzalloc(sizeof(*newpn), GFP_KERNEL);
- if (!newpn) {
- ret = -ENOMEM;
- goto free_buf;
- }
-
- ret = blkio_policy_parse_and_set(buf, newpn, plid, fileid, blkcg);
- if (ret)
- goto free_newpn;
-
- spin_lock_irq(&blkcg->lock);
-
- pn = blkio_policy_search_node(blkcg, newpn->dev, plid, fileid);
- if (!pn) {
- if (!blkio_delete_rule_command(newpn)) {
- blkio_policy_insert_node(blkcg, newpn);
- keep_newpn = 1;
- }
- spin_unlock_irq(&blkcg->lock);
- goto update_io_group;
- }
-
- if (blkio_delete_rule_command(newpn)) {
- blkio_policy_delete_node(pn);
- kfree(pn);
- spin_unlock_irq(&blkcg->lock);
- goto update_io_group;
- }
- spin_unlock_irq(&blkcg->lock);
-
- blkio_update_policy_rule(pn, newpn);
-
-update_io_group:
- blkio_update_policy_node_blkg(blkcg, newpn);
-
-free_newpn:
- if (!keep_newpn)
- kfree(newpn);
-free_buf:
+ ret = blkio_policy_parse_and_set(buf, plid, fileid, blkcg);
kfree(buf);
return ret;
}

-static void
-blkio_print_policy_node(struct seq_file *m, struct blkio_policy_node *pn)
+static void blkio_print_group_conf(struct cftype *cft, struct blkio_group *blkg,
+ struct seq_file *m)
{
- switch(pn->plid) {
+ int fileid = BLKIOFILE_ATTR(cft->private);
+ int rw = WRITE;
+
+ switch (blkg->plid) {
case BLKIO_POLICY_PROP:
- if (pn->fileid == BLKIO_PROP_weight_device)
- seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
- MINOR(pn->dev), pn->val.weight);
+ if (blkg->conf.weight)
+ seq_printf(m, "%u:%u\t%u\n", MAJOR(blkg->dev),
+ MINOR(blkg->dev), blkg->conf.weight);
break;
case BLKIO_POLICY_THROTL:
- switch(pn->fileid) {
+ switch (fileid) {
case BLKIO_THROTL_read_bps_device:
+ rw = READ;
case BLKIO_THROTL_write_bps_device:
- seq_printf(m, "%u:%u\t%llu\n", MAJOR(pn->dev),
- MINOR(pn->dev), pn->val.bps);
+ if (blkg->conf.bps[rw])
+ seq_printf(m, "%u:%u\t%llu\n",
+ MAJOR(blkg->dev),
+ MINOR(blkg->dev),
+ blkg->conf.bps[rw]);
break;
case BLKIO_THROTL_read_iops_device:
+ rw = READ;
case BLKIO_THROTL_write_iops_device:
- seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
- MINOR(pn->dev), pn->val.iops);
+ if (blkg->conf.iops[rw])
+ seq_printf(m, "%u:%u\t%u\n",
+ MAJOR(blkg->dev),
+ MINOR(blkg->dev),
+ blkg->conf.iops[rw]);
break;
}
break;
@@ -1233,20 +934,17 @@ blkio_print_policy_node(struct seq_file *m, struct blkio_policy_node *pn)
}

/* cgroup files which read their data from policy nodes end up here */
-static void blkio_read_policy_node_files(struct cftype *cft,
- struct blkio_cgroup *blkcg, struct seq_file *m)
+static void blkio_read_conf(struct cftype *cft, struct blkio_cgroup *blkcg,
+ struct seq_file *m)
{
- struct blkio_policy_node *pn;
+ struct blkio_group *blkg;
+ struct hlist_node *n;

- if (!list_empty(&blkcg->policy_list)) {
- spin_lock_irq(&blkcg->lock);
- list_for_each_entry(pn, &blkcg->policy_list, node) {
- if (!pn_matches_cftype(cft, pn))
- continue;
- blkio_print_policy_node(m, pn);
- }
- spin_unlock_irq(&blkcg->lock);
- }
+ spin_lock_irq(&blkcg->lock);
+ hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node)
+ if (BLKIOFILE_POLICY(cft->private) == blkg->plid)
+ blkio_print_group_conf(cft, blkg, m);
+ spin_unlock_irq(&blkcg->lock);
}

static int blkiocg_file_read(struct cgroup *cgrp, struct cftype *cft,
@@ -1262,7 +960,7 @@ static int blkiocg_file_read(struct cgroup *cgrp, struct cftype *cft,
case BLKIO_POLICY_PROP:
switch(name) {
case BLKIO_PROP_weight_device:
- blkio_read_policy_node_files(cft, blkcg, m);
+ blkio_read_conf(cft, blkcg, m);
return 0;
default:
BUG();
@@ -1274,7 +972,7 @@ static int blkiocg_file_read(struct cgroup *cgrp, struct cftype *cft,
case BLKIO_THROTL_write_bps_device:
case BLKIO_THROTL_read_iops_device:
case BLKIO_THROTL_write_iops_device:
- blkio_read_policy_node_files(cft, blkcg, m);
+ blkio_read_conf(cft, blkcg, m);
return 0;
default:
BUG();
@@ -1298,7 +996,7 @@ static int blkio_read_blkg_stats(struct blkio_cgroup *blkcg,
rcu_read_lock();
hlist_for_each_entry_rcu(blkg, n, &blkcg->blkg_list, blkcg_node) {
if (blkg->dev) {
- if (!cftype_blkg_same_policy(cft, blkg))
+ if (BLKIOFILE_POLICY(cft->private) != blkg->plid)
continue;
if (pcpu)
cgroup_total += blkio_get_stat_cpu(blkg, cb,
@@ -1397,11 +1095,10 @@ static int blkiocg_file_read_map(struct cgroup *cgrp, struct cftype *cft,
return 0;
}

-static int blkio_weight_write(struct blkio_cgroup *blkcg, u64 val)
+static int blkio_weight_write(struct blkio_cgroup *blkcg, int plid, u64 val)
{
struct blkio_group *blkg;
struct hlist_node *n;
- struct blkio_policy_node *pn;

if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
return -EINVAL;
@@ -1410,14 +1107,10 @@ static int blkio_weight_write(struct blkio_cgroup *blkcg, u64 val)
spin_lock(&blkcg->lock);
blkcg->weight = (unsigned int)val;

- hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
- pn = blkio_policy_search_node(blkcg, blkg->dev,
- BLKIO_POLICY_PROP, BLKIO_PROP_weight_device);
- if (pn)
- continue;
+ hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node)
+ if (blkg->plid == plid && !blkg->conf.weight)
+ blkio_update_group_weight(blkg, blkcg->weight);

- blkio_update_group_weight(blkg, blkcg->weight);
- }
spin_unlock(&blkcg->lock);
spin_unlock_irq(&blkio_list_lock);
return 0;
@@ -1456,7 +1149,7 @@ blkiocg_file_write_u64(struct cgroup *cgrp, struct cftype *cft, u64 val)
case BLKIO_POLICY_PROP:
switch(name) {
case BLKIO_PROP_weight:
- return blkio_weight_write(blkcg, val);
+ return blkio_weight_write(blkcg, plid, val);
}
break;
default:
@@ -1637,7 +1330,6 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
struct blkio_group *blkg;
struct request_queue *q;
struct blkio_policy_type *blkiop;
- struct blkio_policy_node *pn, *pntmp;

rcu_read_lock();
do {
@@ -1669,11 +1361,6 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
spin_unlock_irqrestore(&blkio_list_lock, flags);
} while (1);

- list_for_each_entry_safe(pn, pntmp, &blkcg->policy_list, node) {
- blkio_policy_delete_node(pn);
- kfree(pn);
- }
-
free_css_id(&blkio_subsys, &blkcg->css);
rcu_read_unlock();
if (blkcg != &blkio_root_cgroup)
@@ -1700,7 +1387,6 @@ done:
spin_lock_init(&blkcg->lock);
INIT_HLIST_HEAD(&blkcg->blkg_list);

- INIT_LIST_HEAD(&blkcg->policy_list);
return &blkcg->css;
}

diff --git a/block/blk-cgroup.h b/block/blk-cgroup.h
index 280e55c..9e5a5ff 100644
--- a/block/blk-cgroup.h
+++ b/block/blk-cgroup.h
@@ -112,7 +112,6 @@ struct blkio_cgroup {
unsigned int weight;
spinlock_t lock;
struct hlist_head blkg_list;
- struct list_head policy_list; /* list of blkio_policy_node */
};

struct blkio_group_stats {
@@ -182,37 +181,6 @@ struct blkio_group {
struct blkio_group_stats_cpu __percpu *stats_cpu;
};

-struct blkio_policy_node {
- struct list_head node;
- dev_t dev;
- /* This node belongs to max bw policy or porportional weight policy */
- enum blkio_policy_id plid;
- /* cgroup file to which this rule belongs to */
- int fileid;
-
- union {
- unsigned int weight;
- /*
- * Rate read/write in terms of bytes per second
- * Whether this rate represents read or write is determined
- * by file type "fileid".
- */
- u64 bps;
- unsigned int iops;
- } val;
-};
-
-extern unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
- dev_t dev);
-extern uint64_t blkcg_get_read_bps(struct blkio_cgroup *blkcg,
- dev_t dev);
-extern uint64_t blkcg_get_write_bps(struct blkio_cgroup *blkcg,
- dev_t dev);
-extern unsigned int blkcg_get_read_iops(struct blkio_cgroup *blkcg,
- dev_t dev);
-extern unsigned int blkcg_get_write_iops(struct blkio_cgroup *blkcg,
- dev_t dev);
-
typedef struct blkio_group *(blkio_alloc_group_fn)(struct request_queue *q,
struct blkio_cgroup *blkcg);
typedef void (blkio_link_group_fn)(struct request_queue *q,
--
1.7.7.3


\
 
 \ /
  Last update: 2012-01-22 04:29    [from the cache]
©2003-2011 Jasper Spaans