Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

blkcg: move blkio_group_conf->weight to cfq

Browse source 
blkio_group_conf->weight is owned by cfq and has no reason to be
defined in blkcg core.  Replace it with cfq_group->dev_weight and let
conf setting functions directly set it.  If dev_weight is zero, the
cfqg doesn't have device specific weight configured.

Also, rename BLKIO_WEIGHT_* constants to CFQ_WEIGHT_* and rename
blkio_cgroup->weight to blkio_cgroup->cfq_weight.  We eventually want
per-policy storage in blkio_cgroup but just mark the ownership of the
field for now.

Signed-off-by: Tejun Heo <tj@kernel.org>
This commit is contained in:
Tejun Heo 2012-04-01 14:38:44 -07:00
parent 8a3d26151f
commit 3381cb8d2e
3 changed files with 45 additions and 50 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
block/blk-cgroup.c
View file

@ -30,7 +30,7 @@ static LIST_HEAD(blkio_list);
static DEFINE_MUTEX(all_q_mutex); static DEFINE_MUTEX(all_q_mutex);
static LIST_HEAD(all_q_list); static LIST_HEAD(all_q_list);
struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT }; struct blkio_cgroup blkio_root_cgroup = { .cfq_weight = 2 * CFQ_WEIGHT_DEFAULT };
EXPORT_SYMBOL_GPL(blkio_root_cgroup); EXPORT_SYMBOL_GPL(blkio_root_cgroup);
static struct blkio_policy_type *blkio_policy[BLKIO_NR_POLICIES]; static struct blkio_policy_type *blkio_policy[BLKIO_NR_POLICIES];
@ -611,7 +611,7 @@ static struct cgroup_subsys_state *blkiocg_create(struct cgroup *cgroup)
if (!blkcg) if (!blkcg)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
blkcg->weight = BLKIO_WEIGHT_DEFAULT; blkcg->cfq_weight = CFQ_WEIGHT_DEFAULT;
blkcg->id = atomic64_inc_return(&id_seq); /* root is 0, start from 1 */ blkcg->id = atomic64_inc_return(&id_seq); /* root is 0, start from 1 */
done: done:
spin_lock_init(&blkcg->lock); spin_lock_init(&blkcg->lock);

14
block/blk-cgroup.h
View file

@ -29,6 +29,11 @@ enum blkio_policy_id {
#ifdef CONFIG_BLK_CGROUP #ifdef CONFIG_BLK_CGROUP
/* CFQ specific, out here for blkcg->cfq_weight */
#define CFQ_WEIGHT_MIN 10
#define CFQ_WEIGHT_MAX 1000
#define CFQ_WEIGHT_DEFAULT 500
/* cft->private [un]packing for stat printing */ /* cft->private [un]packing for stat printing */
#define BLKCG_STAT_PRIV(pol, off) (((unsigned)(pol) << 16) | (off)) #define BLKCG_STAT_PRIV(pol, off) (((unsigned)(pol) << 16) | (off))
#define BLKCG_STAT_POL(prv) ((unsigned)(prv) >> 16) #define BLKCG_STAT_POL(prv) ((unsigned)(prv) >> 16)
@ -46,12 +51,14 @@ enum blkg_rwstat_type {
struct blkio_cgroup { struct blkio_cgroup {
struct cgroup_subsys_state css; struct cgroup_subsys_state css;
unsigned int weight;
spinlock_t lock; spinlock_t lock;
struct hlist_head blkg_list; struct hlist_head blkg_list;
/* for policies to test whether associated blkcg has changed */ /* for policies to test whether associated blkcg has changed */
uint64_t id; uint64_t id;
/* TODO: per-policy storage in blkio_cgroup */
unsigned int cfq_weight; /* belongs to cfq */
}; };
struct blkg_stat { struct blkg_stat {
@ -65,7 +72,6 @@ struct blkg_rwstat {
}; };
struct blkio_group_conf { struct blkio_group_conf {
unsigned int weight;
u64 iops[2]; u64 iops[2];
u64 bps[2]; u64 bps[2];
}; };
@ -355,10 +361,6 @@ static inline void blkg_put(struct blkio_group *blkg) { }
#endif #endif
#define BLKIO_WEIGHT_MIN 10
#define BLKIO_WEIGHT_MAX 1000
#define BLKIO_WEIGHT_DEFAULT 500
#ifdef CONFIG_BLK_CGROUP #ifdef CONFIG_BLK_CGROUP
extern struct blkio_cgroup blkio_root_cgroup; extern struct blkio_cgroup blkio_root_cgroup;
extern struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup); extern struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup);

77
block/cfq-iosched.c
View file

@ -224,7 +224,7 @@ struct cfq_group {
u64 vdisktime; u64 vdisktime;
unsigned int weight; unsigned int weight;
unsigned int new_weight; unsigned int new_weight;
bool needs_update; unsigned int dev_weight;
/* number of cfqq currently on this group */ /* number of cfqq currently on this group */
int nr_cfqq; int nr_cfqq;
@ -838,7 +838,7 @@ static inline u64 cfq_scale_slice(unsigned long delta, struct cfq_group *cfqg)
{ {
u64 d = delta << CFQ_SERVICE_SHIFT; u64 d = delta << CFQ_SERVICE_SHIFT;
d = d * BLKIO_WEIGHT_DEFAULT; d = d * CFQ_WEIGHT_DEFAULT;
do_div(d, cfqg->weight); do_div(d, cfqg->weight);
return d; return d;
} }
@ -1165,9 +1165,9 @@ static void
cfq_update_group_weight(struct cfq_group *cfqg) cfq_update_group_weight(struct cfq_group *cfqg)
{ {
BUG_ON(!RB_EMPTY_NODE(&cfqg->rb_node)); BUG_ON(!RB_EMPTY_NODE(&cfqg->rb_node));
if (cfqg->needs_update) { if (cfqg->new_weight) {
cfqg->weight = cfqg->new_weight; cfqg->weight = cfqg->new_weight;
cfqg->needs_update = false; cfqg->new_weight = 0;
} }
} }
@ -1325,21 +1325,12 @@ static void cfq_init_cfqg_base(struct cfq_group *cfqg)
} }
#ifdef CONFIG_CFQ_GROUP_IOSCHED #ifdef CONFIG_CFQ_GROUP_IOSCHED
static void cfq_update_blkio_group_weight(struct blkio_group *blkg,
unsigned int weight)
{
struct cfq_group *cfqg = blkg_to_cfqg(blkg);
cfqg->new_weight = weight;
cfqg->needs_update = true;
}
static void cfq_init_blkio_group(struct blkio_group *blkg) static void cfq_init_blkio_group(struct blkio_group *blkg)
{ {
struct cfq_group *cfqg = blkg_to_cfqg(blkg); struct cfq_group *cfqg = blkg_to_cfqg(blkg);
cfq_init_cfqg_base(cfqg); cfq_init_cfqg_base(cfqg);
cfqg->weight = blkg->blkcg->weight; cfqg->weight = blkg->blkcg->cfq_weight;
} }
/* /*
@ -1377,36 +1368,38 @@ static void cfq_link_cfqq_cfqg(struct cfq_queue *cfqq, struct cfq_group *cfqg)
cfqg_get(cfqg); cfqg_get(cfqg);
} }
static u64 blkg_prfill_weight_device(struct seq_file *sf, static u64 cfqg_prfill_weight_device(struct seq_file *sf,
struct blkg_policy_data *pd, int off) struct blkg_policy_data *pd, int off)
{ {
if (!pd->conf.weight) struct cfq_group *cfqg = (void *)pd->pdata;
if (!cfqg->dev_weight)
return 0; return 0;
return __blkg_prfill_u64(sf, pd, pd->conf.weight); return __blkg_prfill_u64(sf, pd, cfqg->dev_weight);
} }
static int blkcg_print_weight_device(struct cgroup *cgrp, struct cftype *cft, static int cfqg_print_weight_device(struct cgroup *cgrp, struct cftype *cft,
struct seq_file *sf) struct seq_file *sf)
{ {
blkcg_print_blkgs(sf, cgroup_to_blkio_cgroup(cgrp), blkcg_print_blkgs(sf, cgroup_to_blkio_cgroup(cgrp),
blkg_prfill_weight_device, BLKIO_POLICY_PROP, 0, cfqg_prfill_weight_device, BLKIO_POLICY_PROP, 0,
false); false);
return 0; return 0;
} }
static int blkcg_print_weight(struct cgroup *cgrp, struct cftype *cft, static int cfq_print_weight(struct cgroup *cgrp, struct cftype *cft,
struct seq_file *sf) struct seq_file *sf)
{ {
seq_printf(sf, "%u\n", cgroup_to_blkio_cgroup(cgrp)->weight); seq_printf(sf, "%u\n", cgroup_to_blkio_cgroup(cgrp)->cfq_weight);
return 0; return 0;
} }
static int blkcg_set_weight_device(struct cgroup *cgrp, struct cftype *cft, static int cfqg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
const char *buf) const char *buf)
{ {
struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgrp); struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgrp);
struct blkg_policy_data *pd;
struct blkg_conf_ctx ctx; struct blkg_conf_ctx ctx;
struct cfq_group *cfqg;
int ret; int ret;
ret = blkg_conf_prep(blkcg, buf, &ctx); ret = blkg_conf_prep(blkcg, buf, &ctx);
@ -1414,11 +1407,11 @@ static int blkcg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
return ret; return ret;
ret = -EINVAL; ret = -EINVAL;
pd = ctx.blkg->pd[BLKIO_POLICY_PROP]; cfqg = blkg_to_cfqg(ctx.blkg);
if (pd && (!ctx.v || (ctx.v >= BLKIO_WEIGHT_MIN && if (cfqg && (!ctx.v || (ctx.v >= CFQ_WEIGHT_MIN &&
ctx.v <= BLKIO_WEIGHT_MAX))) { ctx.v <= CFQ_WEIGHT_MAX))) {
pd->conf.weight = ctx.v; cfqg->dev_weight = ctx.v;
cfq_update_blkio_group_weight(ctx.blkg, ctx.v ?: blkcg->weight); cfqg->new_weight = cfqg->dev_weight ?: blkcg->cfq_weight;
ret = 0; ret = 0;
} }
@ -1426,23 +1419,23 @@ static int blkcg_set_weight_device(struct cgroup *cgrp, struct cftype *cft,
return ret; return ret;
} }
static int blkcg_set_weight(struct cgroup *cgrp, struct cftype *cft, u64 val) static int cfq_set_weight(struct cgroup *cgrp, struct cftype *cft, u64 val)
{ {
struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgrp); struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgrp);
struct blkio_group *blkg; struct blkio_group *blkg;
struct hlist_node *n; struct hlist_node *n;
if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX) if (val < CFQ_WEIGHT_MIN || val > CFQ_WEIGHT_MAX)
return -EINVAL; return -EINVAL;
spin_lock_irq(&blkcg->lock); spin_lock_irq(&blkcg->lock);
blkcg->weight = (unsigned int)val; blkcg->cfq_weight = (unsigned int)val;
hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) { hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
struct blkg_policy_data *pd = blkg->pd[BLKIO_POLICY_PROP]; struct cfq_group *cfqg = blkg_to_cfqg(blkg);
if (pd && !pd->conf.weight) if (cfqg && !cfqg->dev_weight)
cfq_update_blkio_group_weight(blkg, blkcg->weight); cfqg->new_weight = blkcg->cfq_weight;
} }
spin_unlock_irq(&blkcg->lock); spin_unlock_irq(&blkcg->lock);
@ -1480,14 +1473,14 @@ static int cfqg_print_avg_queue_size(struct cgroup *cgrp, struct cftype *cft,
static struct cftype cfq_blkcg_files[] = { static struct cftype cfq_blkcg_files[] = {
{ {
.name = "weight_device", .name = "weight_device",
.read_seq_string = blkcg_print_weight_device, .read_seq_string = cfqg_print_weight_device,
.write_string = blkcg_set_weight_device, .write_string = cfqg_set_weight_device,
.max_write_len = 256, .max_write_len = 256,
}, },
{ {
.name = "weight", .name = "weight",
.read_seq_string = blkcg_print_weight, .read_seq_string = cfq_print_weight,
.write_u64 = blkcg_set_weight, .write_u64 = cfq_set_weight,
}, },
{ {
.name = "time", .name = "time",
@ -3983,7 +3976,7 @@ static int cfq_init_queue(struct request_queue *q)
return -ENOMEM; return -ENOMEM;
} }
cfqd->root_group->weight = 2*BLKIO_WEIGHT_DEFAULT; cfqd->root_group->weight = 2 * CFQ_WEIGHT_DEFAULT;
/* /*
* Not strictly needed (since RB_ROOT just clears the node and we * Not strictly needed (since RB_ROOT just clears the node and we