io-controller: Add a new interface "policy" for IO Controller

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.policy" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by blkio.policy.

You can use the following format to assigned specific weight for a given device:
#echo "major:minor weight" > blkio.policy

major:minor represents device number.

And you can remove a policy as following:
#echo "major:minor 0" > blkio.policy

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.policy" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by blkio.policy.

You can use the following format to assigned specific weight for a given device:
#echo "major:minor weight" > blkio.policy

major:minor represents device number.

And you can remove a policy as following:
#echo "major:minor 0" > blkio.policy

Signed-off-by Gui Jianfeng <[email protected]>

---
 block/blk-cgroup.c  |  248 +++++++++++++++++++++++++++++++++++++++++++++++++++
 block/blk-cgroup.h  |    9 ++
 block/cfq-iosched.c |    2 +-
 3 files changed, 258 insertions(+), 1 deletions(-)

block/blk-cgroup.c +248 -0

index e7dbbaf..1fddb98 100644
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include "blk-cgroup.h"
+#include <linux/genhd.h>
 
 static DEFINE_SPINLOCK(blkio_list_lock);
 static LIST_HEAD(blkio_list);

@@ -23,6 +24,12 @@ static LIST_HEAD(blkio_list);
 struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT };
 EXPORT_SYMBOL_GPL(blkio_root_cgroup);
 
+static inline void policy_insert_node(struct blkio_cgroup *blkcg,
+				      struct io_policy_node *pn);
+static inline void policy_delete_node(struct io_policy_node *pn);
+static struct io_policy_node *policy_search_node(const struct blkio_cgroup *blkcg,
+						 dev_t dev);
+
 bool blkiocg_css_tryget(struct blkio_cgroup *blkcg)
 {
 	if (!css_tryget(&blkcg->css))

@@ -142,6 +149,7 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	struct blkio_group *blkg;
 	struct hlist_node *n;
 	struct blkio_policy_type *blkiop;
+	struct io_policy_node *pn;
 
 	if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
 		return -EINVAL;

@@ -150,7 +158,13 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	spin_lock(&blkio_list_lock);
 	spin_lock_irq(&blkcg->lock);
 	blkcg->weight = (unsigned int)val;
+
 	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		pn = policy_search_node(blkcg, blkg->dev);
+
+		if (pn)
+			continue;
+
 		list_for_each_entry(blkiop, &blkio_list, list)
 			blkiop->ops.blkio_update_group_weight_fn(blkg,
 					blkcg->weight);

@@ -199,8 +213,235 @@ void blkiocg_update_blkio_group_dequeue_stats(struct blkio_group *blkg,
 EXPORT_SYMBOL_GPL(blkiocg_update_blkio_group_dequeue_stats);
 #endif
 
+static int check_dev_num(dev_t dev)
+{
+	int part = 0;
+	struct gendisk *disk;
+
+	disk = get_gendisk(dev, &part);
+
+	if (!disk || part)
+		return -ENODEV;
+
+	return 0;
+}
+
+static int policy_parse_and_set(char *buf, struct io_policy_node *newpn)
+{
+	char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+	int ret;
+	unsigned long major, minor, temp;
+	int i = 0;
+	dev_t dev;
+
+	memset(s, 0, sizeof(s));
+
+	while ((p = strsep(&buf, " ")) != NULL) {
+		if (!*p)
+			continue;
+
+		s[i++] = p;
+
+		/* Prevent from inputing too many things */
+		if (i == 3)
+			break;
+	}
+
+	if (i != 2)
+		return -EINVAL;
+
+	p = strsep(&s[0], ":");
+
+	if (p != NULL)
+		major_s = p;
+	else
+		return -EINVAL;
+
+	minor_s = s[0];
+
+	if (!minor_s)
+		return -EINVAL;
+
+	ret = strict_strtoul(major_s, 10, &major);
+	if (ret)
+		return -EINVAL;
+
+	ret = strict_strtoul(minor_s, 10, &minor);
+	if (ret)
+		return -EINVAL;
+
+	dev = MKDEV(major, minor);
+
+	ret = check_dev_num(dev);
+	if (ret)
+		return ret;
+
+	newpn->dev = dev;
+
+	if (s[1] == NULL)
+		return -EINVAL;
+
+	ret = strict_strtoul(s[1], 10, &temp);
+	if (ret || (temp < BLKIO_WEIGHT_MIN && temp > 0) ||
+	    temp > BLKIO_WEIGHT_MAX)
+		return -EINVAL;
+
+	newpn->weight =  temp;
+
+	return 0;
+}
+
+unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				    dev_t dev)
+{
+	struct io_policy_node *pn;
+
+	pn = policy_search_node(blkcg, dev);
+
+	if (pn)
+		return pn->weight;
+	else
+		return blkcg->weight;
+}
+EXPORT_SYMBOL_GPL(blkcg_get_weight);
+
+static inline void policy_insert_node(struct blkio_cgroup *blkcg,
+				      struct io_policy_node *pn)
+{
+	list_add(&pn->node, &blkcg->policy_list);
+}
+
+/* Must be called with blkcg->lock held */
+static inline void policy_delete_node(struct io_policy_node *pn)
+{
+	list_del(&pn->node);
+}
+
+/* Must be called with blkcg->lock held */
+static struct io_policy_node *policy_search_node(const struct blkio_cgroup *blkcg,
+						 dev_t dev)
+{
+	struct io_policy_node *pn;
+
+	if (list_empty(&blkcg->policy_list))
+		return NULL;
+
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		if (pn->dev == dev)
+			return pn;
+	}
+
+	return NULL;
+}
+
+
+static int blkiocg_policy_write(struct cgroup *cgrp, struct cftype *cft,
+				const char *buffer)
+{
+	int ret = 0;
+	char *buf;
+	struct io_policy_node *newpn, *pn;
+	struct blkio_cgroup *blkcg;
+	struct blkio_group *blkg;
+	int keep_newpn = 0;
+	struct hlist_node *n;
+	struct blkio_policy_type *blkiop;
+
+	buf = kstrdup(buffer, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	newpn = kzalloc(sizeof(*newpn), GFP_KERNEL);
+	if (!newpn) {
+		ret = -ENOMEM;
+		goto free_buf;
+	}
+
+	ret = policy_parse_and_set(buf, newpn);
+	if (ret)
+		goto free_newpn;
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+
+	spin_lock_irq(&blkcg->lock);
+
+	pn = policy_search_node(blkcg, newpn->dev);
+	if (!pn) {
+		if (newpn->weight != 0) {
+			policy_insert_node(blkcg, newpn);
+			keep_newpn = 1;
+		}
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+
+	if (newpn->weight == 0) {
+		/* weight == 0 means deleteing a policy */
+		policy_delete_node(pn);
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+	spin_unlock_irq(&blkcg->lock);
+
+	pn->weight = newpn->weight;
+
+update_io_group:
+	/* update weight for each cfqg */
+	spin_lock(&blkio_list_lock);
+	spin_lock_irq(&blkcg->lock);
+
+	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		if (newpn->dev == blkg->dev) {
+			list_for_each_entry(blkiop, &blkio_list, list)
+				blkiop->ops.blkio_update_group_weight_fn(blkg,
+						newpn->weight ?
+						newpn->weight :
+						blkcg->weight);
+		}
+	}
+
+	spin_unlock_irq(&blkcg->lock);
+	spin_unlock(&blkio_list_lock);
+
+free_newpn:
+	if (!keep_newpn)
+		kfree(newpn);
+free_buf:
+	kfree(buf);
+	return ret;
+}
+
+static int blkiocg_policy_read(struct cgroup *cgrp, struct cftype *cft,
+			       struct seq_file *m)
+{
+	struct blkio_cgroup *blkcg;
+	struct io_policy_node *pn;
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+
+	if (list_empty(&blkcg->policy_list))
+		goto out;
+
+	seq_printf(m, "dev\tweight\n");
+
+	spin_lock_irq(&blkcg->lock);
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
+			   MINOR(pn->dev), pn->weight);
+	}
+	spin_unlock_irq(&blkcg->lock);
+out:
+	return 0;
+}
+
 struct cftype blkio_files[] = {
 	{
+		.name = "policy",
+		.read_seq_string = blkiocg_policy_read,
+		.write_string = blkiocg_policy_write,
+		.max_write_len = 256,
+	},
+	{
 		.name = "weight",
 		.read_u64 = blkiocg_weight_read,
 		.write_u64 = blkiocg_weight_write,

@@ -234,6 +475,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 	struct blkio_group *blkg;
 	void *key;
 	struct blkio_policy_type *blkiop;
+	struct io_policy_node *pn, *pntmp;
 
 	rcu_read_lock();
 remove_entry:

@@ -264,7 +506,12 @@ remove_entry:
 		blkiop->ops.blkio_unlink_group_fn(key, blkg);
 	spin_unlock(&blkio_list_lock);
 	goto remove_entry;
+
 done:
+	list_for_each_entry_safe(pn, pntmp, &blkcg->policy_list, node) {
+		policy_delete_node(pn);
+		kfree(pn);
+	}
 	free_css_id(&blkio_subsys, &blkcg->css);
 	rcu_read_unlock();
 	kfree(blkcg);

@@ -294,6 +541,7 @@ done:
 	spin_lock_init(&blkcg->lock);
 	INIT_HLIST_HEAD(&blkcg->blkg_list);
 
+	INIT_LIST_HEAD(&blkcg->policy_list);
 	return &blkcg->css;
 }
 

block/blk-cgroup.h +9 -0

index 4d316df..0551aa1 100644
@@ -22,6 +22,7 @@ struct blkio_cgroup {
 	unsigned int weight;
 	spinlock_t lock;
 	struct hlist_head blkg_list;
+	struct list_head policy_list; /* list of io_policy_node */
 };
 
 struct blkio_group {

@@ -43,8 +44,16 @@ struct blkio_group {
 	unsigned long sectors;
 };
 
+struct io_policy_node {
+	struct list_head node;
+	dev_t dev;
+	unsigned int weight;
+};
+
 extern bool blkiocg_css_tryget(struct blkio_cgroup *blkcg);
 extern void blkiocg_css_put(struct blkio_cgroup *blkcg);
+extern unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				     dev_t dev);
 
 typedef void (blkio_unlink_group_fn) (void *key, struct blkio_group *blkg);
 typedef void (blkio_update_group_weight_fn) (struct blkio_group *blkg,

block/cfq-iosched.c +1 -1

index 023f4e6..3d0dea1 100644
@@ -963,7 +963,6 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	if (!cfqg)
 		goto done;
 
-	cfqg->weight = blkcg->weight;
 	for_each_cfqg_st(cfqg, i, j, st)
 		*st = CFQ_RB_ROOT;
 	RB_CLEAR_NODE(&cfqg->rb_node);

@@ -980,6 +979,7 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);
 	blkiocg_add_blkio_group(blkcg, &cfqg->blkg, (void *)cfqd,
 					MKDEV(major, minor));
+	cfqg->weight = blkcg_get_weight(blkcg, cfqg->blkg.dev);
 
 	/* Add group on cfqd list */
 	hlist_add_head(&cfqg->cfqd_node, &cfqd->cfqg_list);

Signature · 1 line

1.5.4.rc3

Quoted 9 lines · Gui Jianfeng

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.policy" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by blkio.policy.

You can use the following format to assigned specific weight for a given device:
#echo "major:minor weight" > blkio.policy

Hi Gui,

Can we use a different name for per device weight file name than "blkio.policy". May be "blkio.weight_device" or "blkio.weight_per_device" etc.

The reason being that "blkio.policy" name might be more suitable to switch between differnt kind of BW control policies (proportional, max bandwidth etc), once we implement some kind of max BW controlling policies also. So it might be a good idea to not use that file name for specifying per device weights.

Secondly, where is it useful. I mean do you have a scenario where you will use it. Why I am asking is that we never had ioprio per device kind of interface. ioprio was associated with task and was global and same on every device in the system.

I am wondering, what are the scenarios where an application is more important on one device and less important on other device to warrant different weights on different devices.

Thanks
Vivek

Quoted 375 lines

major:minor represents device number.

And you can remove a policy as following:
#echo "major:minor 0" > blkio.policy

Signed-off-by Gui Jianfeng <[email protected]>

---
 block/blk-cgroup.c  |  248 +++++++++++++++++++++++++++++++++++++++++++++++++++
 block/blk-cgroup.h  |    9 ++
 block/cfq-iosched.c |    2 +-
 3 files changed, 258 insertions(+), 1 deletions(-)

block/blk-cgroup.c +248 -0

index e7dbbaf..1fddb98 100644
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include "blk-cgroup.h"
+#include <linux/genhd.h>
 
 static DEFINE_SPINLOCK(blkio_list_lock);
 static LIST_HEAD(blkio_list);

@@ -23,6 +24,12 @@ static LIST_HEAD(blkio_list);
 struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT };
 EXPORT_SYMBOL_GPL(blkio_root_cgroup);
 
+static inline void policy_insert_node(struct blkio_cgroup *blkcg,
+				      struct io_policy_node *pn);
+static inline void policy_delete_node(struct io_policy_node *pn);
+static struct io_policy_node *policy_search_node(const struct blkio_cgroup *blkcg,
+						 dev_t dev);
+
 bool blkiocg_css_tryget(struct blkio_cgroup *blkcg)
 {
 	if (!css_tryget(&blkcg->css))

@@ -142,6 +149,7 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	struct blkio_group *blkg;
 	struct hlist_node *n;
 	struct blkio_policy_type *blkiop;
+	struct io_policy_node *pn;
 
 	if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
 		return -EINVAL;

@@ -150,7 +158,13 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	spin_lock(&blkio_list_lock);
 	spin_lock_irq(&blkcg->lock);
 	blkcg->weight = (unsigned int)val;
+
 	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		pn = policy_search_node(blkcg, blkg->dev);
+
+		if (pn)
+			continue;
+
 		list_for_each_entry(blkiop, &blkio_list, list)
 			blkiop->ops.blkio_update_group_weight_fn(blkg,
 					blkcg->weight);

@@ -199,8 +213,235 @@ void blkiocg_update_blkio_group_dequeue_stats(struct blkio_group *blkg,
 EXPORT_SYMBOL_GPL(blkiocg_update_blkio_group_dequeue_stats);
 #endif
 
+static int check_dev_num(dev_t dev)
+{
+	int part = 0;
+	struct gendisk *disk;
+
+	disk = get_gendisk(dev, &part);
+
+	if (!disk || part)
+		return -ENODEV;
+
+	return 0;
+}
+
+static int policy_parse_and_set(char *buf, struct io_policy_node *newpn)
+{
+	char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+	int ret;
+	unsigned long major, minor, temp;
+	int i = 0;
+	dev_t dev;
+
+	memset(s, 0, sizeof(s));
+
+	while ((p = strsep(&buf, " ")) != NULL) {
+		if (!*p)
+			continue;
+
+		s[i++] = p;
+
+		/* Prevent from inputing too many things */
+		if (i == 3)
+			break;
+	}
+
+	if (i != 2)
+		return -EINVAL;
+
+	p = strsep(&s[0], ":");
+
+	if (p != NULL)
+		major_s = p;
+	else
+		return -EINVAL;
+
+	minor_s = s[0];
+
+	if (!minor_s)
+		return -EINVAL;
+
+	ret = strict_strtoul(major_s, 10, &major);
+	if (ret)
+		return -EINVAL;
+
+	ret = strict_strtoul(minor_s, 10, &minor);
+	if (ret)
+		return -EINVAL;
+
+	dev = MKDEV(major, minor);
+
+	ret = check_dev_num(dev);
+	if (ret)
+		return ret;
+
+	newpn->dev = dev;
+
+	if (s[1] == NULL)
+		return -EINVAL;
+
+	ret = strict_strtoul(s[1], 10, &temp);
+	if (ret || (temp < BLKIO_WEIGHT_MIN && temp > 0) ||
+	    temp > BLKIO_WEIGHT_MAX)
+		return -EINVAL;
+
+	newpn->weight =  temp;
+
+	return 0;
+}
+
+unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				    dev_t dev)
+{
+	struct io_policy_node *pn;
+
+	pn = policy_search_node(blkcg, dev);
+
+	if (pn)
+		return pn->weight;
+	else
+		return blkcg->weight;
+}
+EXPORT_SYMBOL_GPL(blkcg_get_weight);
+
+static inline void policy_insert_node(struct blkio_cgroup *blkcg,
+				      struct io_policy_node *pn)
+{
+	list_add(&pn->node, &blkcg->policy_list);
+}
+
+/* Must be called with blkcg->lock held */
+static inline void policy_delete_node(struct io_policy_node *pn)
+{
+	list_del(&pn->node);
+}
+
+/* Must be called with blkcg->lock held */
+static struct io_policy_node *policy_search_node(const struct blkio_cgroup *blkcg,
+						 dev_t dev)
+{
+	struct io_policy_node *pn;
+
+	if (list_empty(&blkcg->policy_list))
+		return NULL;
+
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		if (pn->dev == dev)
+			return pn;
+	}
+
+	return NULL;
+}
+
+
+static int blkiocg_policy_write(struct cgroup *cgrp, struct cftype *cft,
+				const char *buffer)
+{
+	int ret = 0;
+	char *buf;
+	struct io_policy_node *newpn, *pn;
+	struct blkio_cgroup *blkcg;
+	struct blkio_group *blkg;
+	int keep_newpn = 0;
+	struct hlist_node *n;
+	struct blkio_policy_type *blkiop;
+
+	buf = kstrdup(buffer, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	newpn = kzalloc(sizeof(*newpn), GFP_KERNEL);
+	if (!newpn) {
+		ret = -ENOMEM;
+		goto free_buf;
+	}
+
+	ret = policy_parse_and_set(buf, newpn);
+	if (ret)
+		goto free_newpn;
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+
+	spin_lock_irq(&blkcg->lock);
+
+	pn = policy_search_node(blkcg, newpn->dev);
+	if (!pn) {
+		if (newpn->weight != 0) {
+			policy_insert_node(blkcg, newpn);
+			keep_newpn = 1;
+		}
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+
+	if (newpn->weight == 0) {
+		/* weight == 0 means deleteing a policy */
+		policy_delete_node(pn);
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+	spin_unlock_irq(&blkcg->lock);
+
+	pn->weight = newpn->weight;
+
+update_io_group:
+	/* update weight for each cfqg */
+	spin_lock(&blkio_list_lock);
+	spin_lock_irq(&blkcg->lock);
+
+	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		if (newpn->dev == blkg->dev) {
+			list_for_each_entry(blkiop, &blkio_list, list)
+				blkiop->ops.blkio_update_group_weight_fn(blkg,
+						newpn->weight ?
+						newpn->weight :
+						blkcg->weight);
+		}
+	}
+
+	spin_unlock_irq(&blkcg->lock);
+	spin_unlock(&blkio_list_lock);
+
+free_newpn:
+	if (!keep_newpn)
+		kfree(newpn);
+free_buf:
+	kfree(buf);
+	return ret;
+}
+
+static int blkiocg_policy_read(struct cgroup *cgrp, struct cftype *cft,
+			       struct seq_file *m)
+{
+	struct blkio_cgroup *blkcg;
+	struct io_policy_node *pn;
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+
+	if (list_empty(&blkcg->policy_list))
+		goto out;
+
+	seq_printf(m, "dev\tweight\n");
+
+	spin_lock_irq(&blkcg->lock);
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
+			   MINOR(pn->dev), pn->weight);
+	}
+	spin_unlock_irq(&blkcg->lock);
+out:
+	return 0;
+}
+
 struct cftype blkio_files[] = {
 	{
+		.name = "policy",
+		.read_seq_string = blkiocg_policy_read,
+		.write_string = blkiocg_policy_write,
+		.max_write_len = 256,
+	},
+	{
 		.name = "weight",
 		.read_u64 = blkiocg_weight_read,
 		.write_u64 = blkiocg_weight_write,

@@ -234,6 +475,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 	struct blkio_group *blkg;
 	void *key;
 	struct blkio_policy_type *blkiop;
+	struct io_policy_node *pn, *pntmp;
 
 	rcu_read_lock();
 remove_entry:

@@ -264,7 +506,12 @@ remove_entry:
 		blkiop->ops.blkio_unlink_group_fn(key, blkg);
 	spin_unlock(&blkio_list_lock);
 	goto remove_entry;
+
 done:
+	list_for_each_entry_safe(pn, pntmp, &blkcg->policy_list, node) {
+		policy_delete_node(pn);
+		kfree(pn);
+	}
 	free_css_id(&blkio_subsys, &blkcg->css);
 	rcu_read_unlock();
 	kfree(blkcg);

@@ -294,6 +541,7 @@ done:
 	spin_lock_init(&blkcg->lock);
 	INIT_HLIST_HEAD(&blkcg->blkg_list);
 
+	INIT_LIST_HEAD(&blkcg->policy_list);
 	return &blkcg->css;
 }
 

block/blk-cgroup.h +9 -0

index 4d316df..0551aa1 100644
@@ -22,6 +22,7 @@ struct blkio_cgroup {
 	unsigned int weight;
 	spinlock_t lock;
 	struct hlist_head blkg_list;
+	struct list_head policy_list; /* list of io_policy_node */
 };
 
 struct blkio_group {

@@ -43,8 +44,16 @@ struct blkio_group {
 	unsigned long sectors;
 };
 
+struct io_policy_node {
+	struct list_head node;
+	dev_t dev;
+	unsigned int weight;
+};
+
 extern bool blkiocg_css_tryget(struct blkio_cgroup *blkcg);
 extern void blkiocg_css_put(struct blkio_cgroup *blkcg);
+extern unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				     dev_t dev);
 
 typedef void (blkio_unlink_group_fn) (void *key, struct blkio_group *blkg);
 typedef void (blkio_update_group_weight_fn) (struct blkio_group *blkg,

block/cfq-iosched.c +1 -1

index 023f4e6..3d0dea1 100644
@@ -963,7 +963,6 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	if (!cfqg)
 		goto done;
 
-	cfqg->weight = blkcg->weight;
 	for_each_cfqg_st(cfqg, i, j, st)
 		*st = CFQ_RB_ROOT;
 	RB_CLEAR_NODE(&cfqg->rb_node);

@@ -980,6 +979,7 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);
 	blkiocg_add_blkio_group(blkcg, &cfqg->blkg, (void *)cfqd,
 					MKDEV(major, minor));
+	cfqg->weight = blkcg_get_weight(blkcg, cfqg->blkg.dev);
 
 	/* Add group on cfqd list */
 	hlist_add_head(&cfqg->cfqd_node, &cfqd->cfqg_list);

Signature · 1 line

1.5.4.rc3

Quoted 7 lines · Vivek Goyal

Quoted 3 lines · Gui Jianfeng

You can use the following format to assigned specific weight for a given device:
#echo "major:minor weight" > blkio.policy

Can we use a different name for per device weight file name than "blkio.policy". May be "blkio.weight_device" or "blkio.weight_per_device" etc.

Quoted 5 lines

The reason being that "blkio.policy" name might be more suitable to switch between differnt kind of BW control policies (proportional, max bandwidth etc), once we implement some kind of max BW controlling policies also. So it might be a good idea to not use that file name for specifying per device weights.

Well, thinking more about it, what kind of policy you implement on a block device will not be a per cgroup property. It will not be the case that on a device you are implementing max-bw for one cgroup and proportional weight for other cgroup. It probably will be a per device attribute and if need be should be controlled by /sys/block/<dev> interface.

Still, being very clear what a particular cgroup file does makes sense. So that in future for max-bw control, we can bring in more cgroup files like blkio.max_bw or blkio.max_iops etc which can co-exist with blkio.weight_device etc.

Quoted 8 lines · Nauman Rafique

Quoted 7 lines · Vivek Goyal

Quoted 3 lines · Gui Jianfeng

You can use the following format to assigned specific weight for a given device:
#echo "major:minor weight" > blkio.policy

Can we use a different name for per device weight file name than "blkio.policy". May be "blkio.weight_device" or "blkio.weight_per_device" etc.

I agree with Vivek here, and his reasoning below. This becomes more important as more attributes are added.

Quoted 11 lines

Quoted 5 lines

The reason being that "blkio.policy" name might be more suitable to switch between differnt kind of BW control policies (proportional, max bandwidth etc), once we implement some kind of max BW controlling policies also. So it might be a good idea to not use that file name for specifying per device weights.

Well, thinking more about it, what kind of policy you implement on a block device will not be a per cgroup property. It will not be the case that on a device you are implementing max-bw for one cgroup and proportional weight for other cgroup. It probably will be a per device attribute and if need be should be controlled by /sys/block/<dev> interface.

Quoted 4 lines

Still, being very clear what a particular cgroup file does makes sense. So that in future for max-bw control, we can bring in more cgroup files like blkio.max_bw or blkio.max_iops etc which can co-exist with blkio.weight_device etc.

Agreed. I'd like to add that since we are already thinking about expanding the policy with more attributes, perhaps blkio_update_group_weight_fn in blkio_policy_ops should be renamed to blkio_policy_updated_fn. Then it could be called if the user changed any part of the policy. Further, instead of storing "weight" in blkio_cgroup, we could store a blkio_policy_node there instead. Then the handling of whole-cgroup and per-block-device policy items could be more regular.

Some quick code comments:

policy_parse_and_set() could be simplified with scanf, like:

if (sscanf(buf, "%d:%d %d", &major, &minor, &temp) != 3)

        return -EINVAL;

blkcg_get_weight() might better be blkcg_get_policy() and it could return a per-disk policy node, or fall back to the cgroup policy if none existed for this dev. This would be across policy attributes, rather than just weight.

Thanks,
Chad

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.weight_device" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by "blkio.weight_device"

You can use the following format to assigned specific weight for a given device:
#echo "major:minor weight" > blkio.weight_device

major:minor represents device number.

And you can remove a specific weight as following:
#echo "major:minor 0" > blkio.weight_device

V1->V2 changes:
- use user interface "weight_device" instead of "policy" suggested by Vivek
- rename some struct suggested by Vivek
- rebase to 2.6-block "for-linus" branch
- remove an useless list_empty check pointed out by Li Zefan
- some trivial typo fix

Signed-off-by Gui Jianfeng <[email protected]>

---
 block/blk-cgroup.c  |  240 +++++++++++++++++++++++++++++++++++++++++++++++++++
 block/blk-cgroup.h  |   10 ++
 block/cfq-iosched.c |    2 +-
 3 files changed, 251 insertions(+), 1 deletions(-)

block/blk-cgroup.c +1 -0

index c85d74c..37f1d8f 100644
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include "blk-cgroup.h"
+#include <linux/genhd.h>
 
 static DEFINE_SPINLOCK(blkio_list_lock);
 static LIST_HEAD(blkio_list);

block/blk-cgroup.c +234 -0

+
 struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
 {
 	return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),

@@ -128,6 +135,7 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	struct blkio_group *blkg;
 	struct hlist_node *n;
 	struct blkio_policy_type *blkiop;
+	struct blkio_policy_node *pn;
 
 	if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
 		return -EINVAL;

@@ -136,7 +144,13 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	spin_lock(&blkio_list_lock);
 	spin_lock_irq(&blkcg->lock);
 	blkcg->weight = (unsigned int)val;
+
 	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		pn = policy_search_node(blkcg, blkg->dev);
+
+		if (pn)
+			continue;
+
 		list_for_each_entry(blkiop, &blkio_list, list)
 			blkiop->ops.blkio_update_group_weight_fn(blkg,
 					blkcg->weight);

@@ -185,8 +199,227 @@ void blkiocg_update_blkio_group_dequeue_stats(struct blkio_group *blkg,
 EXPORT_SYMBOL_GPL(blkiocg_update_blkio_group_dequeue_stats);
 #endif
 
+static int check_dev_num(dev_t dev)
+{
+	int part = 0;
+	struct gendisk *disk;
+
+	disk = get_gendisk(dev, &part);
+	if (!disk || part)
+		return -ENODEV;
+
+	return 0;
+}
+
+static int policy_parse_and_set(char *buf, struct blkio_policy_node *newpn)
+{
+	char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+	int ret;
+	unsigned long major, minor, temp;
+	int i = 0;
+	dev_t dev;
+
+	memset(s, 0, sizeof(s));
+
+	while ((p = strsep(&buf, " ")) != NULL) {
+		if (!*p)
+			continue;
+
+		s[i++] = p;
+
+		/* Prevent from inputing too many things */
+		if (i == 3)
+			break;
+	}
+
+	if (i != 2)
+		return -EINVAL;
+
+	p = strsep(&s[0], ":");
+	if (p != NULL)
+		major_s = p;
+	else
+		return -EINVAL;
+
+	minor_s = s[0];
+	if (!minor_s)
+		return -EINVAL;
+
+	ret = strict_strtoul(major_s, 10, &major);
+	if (ret)
+		return -EINVAL;
+
+	ret = strict_strtoul(minor_s, 10, &minor);
+	if (ret)
+		return -EINVAL;
+
+	dev = MKDEV(major, minor);
+
+	ret = check_dev_num(dev);
+	if (ret)
+		return ret;
+
+	newpn->dev = dev;
+
+	if (s[1] == NULL)
+		return -EINVAL;
+
+	ret = strict_strtoul(s[1], 10, &temp);
+	if (ret || (temp < BLKIO_WEIGHT_MIN && temp > 0) ||
+	    temp > BLKIO_WEIGHT_MAX)
+		return -EINVAL;
+
+	newpn->weight =  temp;
+
+	return 0;
+}
+
+unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				    dev_t dev)
+{
+	struct blkio_policy_node *pn;
+
+	pn = policy_search_node(blkcg, dev);
+	if (pn)
+		return pn->weight;
+	else
+		return blkcg->weight;
+}
+EXPORT_SYMBOL_GPL(blkcg_get_weight);
+
+static inline void policy_insert_node(struct blkio_cgroup *blkcg,
+				      struct blkio_policy_node *pn)
+{
+	list_add(&pn->node, &blkcg->policy_list);
+}
+
+/* Must be called with blkcg->lock held */
+static inline void policy_delete_node(struct blkio_policy_node *pn)
+{
+	list_del(&pn->node);
+}
+
+/* Must be called with blkcg->lock held */
+static struct blkio_policy_node *policy_search_node(const struct blkio_cgroup *blkcg,
+						 dev_t dev)
+{
+	struct blkio_policy_node *pn;
+
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		if (pn->dev == dev)
+			return pn;
+	}
+
+	return NULL;
+}
+
+
+static int blkiocg_weight_device_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;
+	struct blkio_group *blkg;
+	int keep_newpn = 0;
+	struct hlist_node *n;
+	struct blkio_policy_type *blkiop;
+
+	buf = kstrdup(buffer, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	newpn = kzalloc(sizeof(*newpn), GFP_KERNEL);
+	if (!newpn) {
+		ret = -ENOMEM;
+		goto free_buf;
+	}
+
+	ret = policy_parse_and_set(buf, newpn);
+	if (ret)
+		goto free_newpn;
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+
+	spin_lock_irq(&blkcg->lock);
+
+	pn = policy_search_node(blkcg, newpn->dev);
+	if (!pn) {
+		if (newpn->weight != 0) {
+			policy_insert_node(blkcg, newpn);
+			keep_newpn = 1;
+		}
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+
+	if (newpn->weight == 0) {
+		/* weight == 0 means deleteing a specific weight */
+		policy_delete_node(pn);
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+	spin_unlock_irq(&blkcg->lock);
+
+	pn->weight = newpn->weight;
+
+update_io_group:
+	/* update weight for each cfqg */
+	spin_lock(&blkio_list_lock);
+	spin_lock_irq(&blkcg->lock);
+
+	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		if (newpn->dev == blkg->dev) {
+			list_for_each_entry(blkiop, &blkio_list, list)
+				blkiop->ops.blkio_update_group_weight_fn(blkg,
+						newpn->weight ?
+						newpn->weight :
+						blkcg->weight);
+		}
+	}
+
+	spin_unlock_irq(&blkcg->lock);
+	spin_unlock(&blkio_list_lock);
+
+free_newpn:
+	if (!keep_newpn)
+		kfree(newpn);
+free_buf:
+	kfree(buf);
+	return ret;
+}
+
+static int blkiocg_weight_device_read(struct cgroup *cgrp, struct cftype *cft,
+				       struct seq_file *m)
+{
+	struct blkio_cgroup *blkcg;
+	struct blkio_policy_node *pn;
+
+	seq_printf(m, "dev\tweight\n");
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+	if (list_empty(&blkcg->policy_list))
+		goto out;
+
+	spin_lock_irq(&blkcg->lock);
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
+			   MINOR(pn->dev), pn->weight);
+	}
+	spin_unlock_irq(&blkcg->lock);
+out:
+	return 0;
+}
+
 struct cftype blkio_files[] = {
 	{
+		.name = "weight_device",
+		.read_seq_string = blkiocg_weight_device_read,
+		.write_string = blkiocg_weight_device_write,
+		.max_write_len = 256,
+	},
+	{
 		.name = "weight",
 		.read_u64 = blkiocg_weight_read,
 		.write_u64 = blkiocg_weight_write,

@@ -220,6 +453,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 	struct blkio_group *blkg;
 	void *key;
 	struct blkio_policy_type *blkiop;
+	struct blkio_policy_node *pn, *pntmp;
 
 	rcu_read_lock();
 remove_entry:

@@ -250,7 +484,12 @@ remove_entry:
 		blkiop->ops.blkio_unlink_group_fn(key, blkg);
 	spin_unlock(&blkio_list_lock);
 	goto remove_entry;
+
 done:
+	list_for_each_entry_safe(pn, pntmp, &blkcg->policy_list, node) {
+		policy_delete_node(pn);
+		kfree(pn);
+	}
 	free_css_id(&blkio_subsys, &blkcg->css);
 	rcu_read_unlock();
 	kfree(blkcg);

@@ -280,6 +519,7 @@ done:
 	spin_lock_init(&blkcg->lock);
 	INIT_HLIST_HEAD(&blkcg->blkg_list);
 
+	INIT_LIST_HEAD(&blkcg->policy_list);
 	return &blkcg->css;
 }
 

block/blk-cgroup.h +10 -0

index 84bf745..c8144a2 100644
@@ -22,6 +22,7 @@ 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 {

@@ -43,6 +44,15 @@ struct blkio_group {
 	unsigned long sectors;
 };
 
+struct blkio_policy_node {
+	struct list_head node;
+	dev_t dev;
+	unsigned int weight;
+};
+
+extern unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				     dev_t dev);
+
 typedef void (blkio_unlink_group_fn) (void *key, struct blkio_group *blkg);
 typedef void (blkio_update_group_weight_fn) (struct blkio_group *blkg,
 						unsigned int weight);

block/cfq-iosched.c +1 -1

index dee9d93..6945e9b 100644
@@ -954,7 +954,6 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	if (!cfqg)
 		goto done;
 
-	cfqg->weight = blkcg->weight;
 	for_each_cfqg_st(cfqg, i, j, st)
 		*st = CFQ_RB_ROOT;
 	RB_CLEAR_NODE(&cfqg->rb_node);

@@ -971,6 +970,7 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);
 	blkiocg_add_blkio_group(blkcg, &cfqg->blkg, (void *)cfqd,
 					MKDEV(major, minor));
+	cfqg->weight = blkcg_get_weight(blkcg, cfqg->blkg.dev);
 
 	/* Add group on cfqd list */
 	hlist_add_head(&cfqg->cfqd_node, &cfqd->cfqg_list);

Signature · 1 line

1.5.4.rc3 

Quoted 41 lines · Gui Jianfeng

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.weight_device" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by "blkio.weight_device"

You can use the following format to assigned specific weight for a given device:
#echo "major:minor weight" > blkio.weight_device

major:minor represents device number.

And you can remove a specific weight as following:
#echo "major:minor 0" > blkio.weight_device

V1->V2 changes:
- use user interface "weight_device" instead of "policy" suggested by Vivek
- rename some struct suggested by Vivek
- rebase to 2.6-block "for-linus" branch
- remove an useless list_empty check pointed out by Li Zefan
- some trivial typo fix

Signed-off-by Gui Jianfeng <[email protected]>

---
 block/blk-cgroup.c  |  240 +++++++++++++++++++++++++++++++++++++++++++++++++++
 block/blk-cgroup.h  |   10 ++
 block/cfq-iosched.c |    2 +-
 3 files changed, 251 insertions(+), 1 deletions(-)

block/blk-cgroup.c +1 -0

index c85d74c..37f1d8f 100644
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include "blk-cgroup.h"
+#include <linux/genhd.h>
 
 static DEFINE_SPINLOCK(blkio_list_lock);
 static LIST_HEAD(blkio_list);

block/blk-cgroup.c static LIST_HEAD(blkio_list); · line 31

Quoted 8 lines

block/blk-cgroup.c +5 -0

@@ -23,6 +24,12 @@ static LIST_HEAD(blkio_list);
 struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT };
 EXPORT_SYMBOL_GPL(blkio_root_cgroup);
 
+static inline void policy_insert_node(struct blkio_cgroup *blkcg,
+				      struct blkio_policy_node *pn);
+static inline void policy_delete_node(struct blkio_policy_node *pn);
+static struct blkio_policy_node *policy_search_node(const struct blkio_cgroup *blkcg,
+						 dev_t dev);

Hi Gui,

Thanks. Can we move above functions up in the file and get rid of these forward declarations?

Also as I suggested last time, it might be good idea to prefix "blkio_" before function names.

policy_insert_node ---> blkio_policy_insert_node() policy_delete_node ---> blkio_policy_delete_node() policy_search_node ---> blkio_policy_search_node() chekc_dev_num ---> blkio_check_dev_num()
.
.

Thanks
Vivek

Quoted 335 lines

block/blk-cgroup.c +234 -0

+
 struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
 {
 	return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),

@@ -128,6 +135,7 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	struct blkio_group *blkg;
 	struct hlist_node *n;
 	struct blkio_policy_type *blkiop;
+	struct blkio_policy_node *pn;
 
 	if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
 		return -EINVAL;

@@ -136,7 +144,13 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	spin_lock(&blkio_list_lock);
 	spin_lock_irq(&blkcg->lock);
 	blkcg->weight = (unsigned int)val;
+
 	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		pn = policy_search_node(blkcg, blkg->dev);
+
+		if (pn)
+			continue;
+
 		list_for_each_entry(blkiop, &blkio_list, list)
 			blkiop->ops.blkio_update_group_weight_fn(blkg,
 					blkcg->weight);

@@ -185,8 +199,227 @@ void blkiocg_update_blkio_group_dequeue_stats(struct blkio_group *blkg,
 EXPORT_SYMBOL_GPL(blkiocg_update_blkio_group_dequeue_stats);
 #endif
 
+static int check_dev_num(dev_t dev)
+{
+	int part = 0;
+	struct gendisk *disk;
+
+	disk = get_gendisk(dev, &part);
+	if (!disk || part)
+		return -ENODEV;
+
+	return 0;
+}
+
+static int policy_parse_and_set(char *buf, struct blkio_policy_node *newpn)
+{
+	char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+	int ret;
+	unsigned long major, minor, temp;
+	int i = 0;
+	dev_t dev;
+
+	memset(s, 0, sizeof(s));
+
+	while ((p = strsep(&buf, " ")) != NULL) {
+		if (!*p)
+			continue;
+
+		s[i++] = p;
+
+		/* Prevent from inputing too many things */
+		if (i == 3)
+			break;
+	}
+
+	if (i != 2)
+		return -EINVAL;
+
+	p = strsep(&s[0], ":");
+	if (p != NULL)
+		major_s = p;
+	else
+		return -EINVAL;
+
+	minor_s = s[0];
+	if (!minor_s)
+		return -EINVAL;
+
+	ret = strict_strtoul(major_s, 10, &major);
+	if (ret)
+		return -EINVAL;
+
+	ret = strict_strtoul(minor_s, 10, &minor);
+	if (ret)
+		return -EINVAL;
+
+	dev = MKDEV(major, minor);
+
+	ret = check_dev_num(dev);
+	if (ret)
+		return ret;
+
+	newpn->dev = dev;
+
+	if (s[1] == NULL)
+		return -EINVAL;
+
+	ret = strict_strtoul(s[1], 10, &temp);
+	if (ret || (temp < BLKIO_WEIGHT_MIN && temp > 0) ||
+	    temp > BLKIO_WEIGHT_MAX)
+		return -EINVAL;
+
+	newpn->weight =  temp;
+
+	return 0;
+}
+
+unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				    dev_t dev)
+{
+	struct blkio_policy_node *pn;
+
+	pn = policy_search_node(blkcg, dev);
+	if (pn)
+		return pn->weight;
+	else
+		return blkcg->weight;
+}
+EXPORT_SYMBOL_GPL(blkcg_get_weight);
+
+static inline void policy_insert_node(struct blkio_cgroup *blkcg,
+				      struct blkio_policy_node *pn)
+{
+	list_add(&pn->node, &blkcg->policy_list);
+}
+
+/* Must be called with blkcg->lock held */
+static inline void policy_delete_node(struct blkio_policy_node *pn)
+{
+	list_del(&pn->node);
+}
+
+/* Must be called with blkcg->lock held */
+static struct blkio_policy_node *policy_search_node(const struct blkio_cgroup *blkcg,
+						 dev_t dev)
+{
+	struct blkio_policy_node *pn;
+
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		if (pn->dev == dev)
+			return pn;
+	}
+
+	return NULL;
+}
+
+
+static int blkiocg_weight_device_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;
+	struct blkio_group *blkg;
+	int keep_newpn = 0;
+	struct hlist_node *n;
+	struct blkio_policy_type *blkiop;
+
+	buf = kstrdup(buffer, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	newpn = kzalloc(sizeof(*newpn), GFP_KERNEL);
+	if (!newpn) {
+		ret = -ENOMEM;
+		goto free_buf;
+	}
+
+	ret = policy_parse_and_set(buf, newpn);
+	if (ret)
+		goto free_newpn;
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+
+	spin_lock_irq(&blkcg->lock);
+
+	pn = policy_search_node(blkcg, newpn->dev);
+	if (!pn) {
+		if (newpn->weight != 0) {
+			policy_insert_node(blkcg, newpn);
+			keep_newpn = 1;
+		}
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+
+	if (newpn->weight == 0) {
+		/* weight == 0 means deleteing a specific weight */
+		policy_delete_node(pn);
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+	spin_unlock_irq(&blkcg->lock);
+
+	pn->weight = newpn->weight;
+
+update_io_group:
+	/* update weight for each cfqg */
+	spin_lock(&blkio_list_lock);
+	spin_lock_irq(&blkcg->lock);
+
+	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		if (newpn->dev == blkg->dev) {
+			list_for_each_entry(blkiop, &blkio_list, list)
+				blkiop->ops.blkio_update_group_weight_fn(blkg,
+						newpn->weight ?
+						newpn->weight :
+						blkcg->weight);
+		}
+	}
+
+	spin_unlock_irq(&blkcg->lock);
+	spin_unlock(&blkio_list_lock);
+
+free_newpn:
+	if (!keep_newpn)
+		kfree(newpn);
+free_buf:
+	kfree(buf);
+	return ret;
+}
+
+static int blkiocg_weight_device_read(struct cgroup *cgrp, struct cftype *cft,
+				       struct seq_file *m)
+{
+	struct blkio_cgroup *blkcg;
+	struct blkio_policy_node *pn;
+
+	seq_printf(m, "dev\tweight\n");
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+	if (list_empty(&blkcg->policy_list))
+		goto out;
+
+	spin_lock_irq(&blkcg->lock);
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
+			   MINOR(pn->dev), pn->weight);
+	}
+	spin_unlock_irq(&blkcg->lock);
+out:
+	return 0;
+}
+
 struct cftype blkio_files[] = {
 	{
+		.name = "weight_device",
+		.read_seq_string = blkiocg_weight_device_read,
+		.write_string = blkiocg_weight_device_write,
+		.max_write_len = 256,
+	},
+	{
 		.name = "weight",
 		.read_u64 = blkiocg_weight_read,
 		.write_u64 = blkiocg_weight_write,

@@ -220,6 +453,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 	struct blkio_group *blkg;
 	void *key;
 	struct blkio_policy_type *blkiop;
+	struct blkio_policy_node *pn, *pntmp;
 
 	rcu_read_lock();
 remove_entry:

@@ -250,7 +484,12 @@ remove_entry:
 		blkiop->ops.blkio_unlink_group_fn(key, blkg);
 	spin_unlock(&blkio_list_lock);
 	goto remove_entry;
+
 done:
+	list_for_each_entry_safe(pn, pntmp, &blkcg->policy_list, node) {
+		policy_delete_node(pn);
+		kfree(pn);
+	}
 	free_css_id(&blkio_subsys, &blkcg->css);
 	rcu_read_unlock();
 	kfree(blkcg);

@@ -280,6 +519,7 @@ done:
 	spin_lock_init(&blkcg->lock);
 	INIT_HLIST_HEAD(&blkcg->blkg_list);
 
+	INIT_LIST_HEAD(&blkcg->policy_list);
 	return &blkcg->css;
 }
 

block/blk-cgroup.h +10 -0

index 84bf745..c8144a2 100644
@@ -22,6 +22,7 @@ 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 {

@@ -43,6 +44,15 @@ struct blkio_group {
 	unsigned long sectors;
 };
 
+struct blkio_policy_node {
+	struct list_head node;
+	dev_t dev;
+	unsigned int weight;
+};
+
+extern unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				     dev_t dev);
+
 typedef void (blkio_unlink_group_fn) (void *key, struct blkio_group *blkg);
 typedef void (blkio_update_group_weight_fn) (struct blkio_group *blkg,
 						unsigned int weight);

block/cfq-iosched.c +1 -1

index dee9d93..6945e9b 100644
@@ -954,7 +954,6 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	if (!cfqg)
 		goto done;
 
-	cfqg->weight = blkcg->weight;
 	for_each_cfqg_st(cfqg, i, j, st)
 		*st = CFQ_RB_ROOT;
 	RB_CLEAR_NODE(&cfqg->rb_node);

@@ -971,6 +970,7 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);
 	blkiocg_add_blkio_group(blkcg, &cfqg->blkg, (void *)cfqd,
 					MKDEV(major, minor));
+	cfqg->weight = blkcg_get_weight(blkcg, cfqg->blkg.dev);
 
 	/* Add group on cfqd list */
 	hlist_add_head(&cfqg->cfqd_node, &cfqd->cfqg_list);

Signature · 1 line

1.5.4.rc3 

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.weight_device" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by "blkio.weight_device"

You can use the following format to assigned specific weight for a given device:

major:minor represents device number.

And you can remove a specific weight as following:

V1->V2 changes:
- use user interface "weight_device" instead of "policy" suggested by Vivek
- rename some struct suggested by Vivek
- rebase to 2.6-block "for-linus" branch
- remove an useless list_empty check pointed out by Li Zefan
- some trivial typo fix

V2->V3 changes:
- Move policy_*_node() functions up to get rid of forward declarations
- rename related functions by adding prefix "blkio_"

Signed-off-by Gui Jianfeng <[email protected]>

---
 block/blk-cgroup.c  |  236 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 block/blk-cgroup.h  |   10 ++
 block/cfq-iosched.c |    2 +-
 3 files changed, 246 insertions(+), 2 deletions(-)

block/blk-cgroup.c +235 -1

index c85d74c..8825e49 100644
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include "blk-cgroup.h"
+#include <linux/genhd.h>
 
 static DEFINE_SPINLOCK(blkio_list_lock);
 static LIST_HEAD(blkio_list);

@@ -23,6 +24,32 @@ static LIST_HEAD(blkio_list);
 struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT };
 EXPORT_SYMBOL_GPL(blkio_root_cgroup);
 
+static inline void blkio_policy_insert_node(struct blkio_cgroup *blkcg,
+					    struct blkio_policy_node *pn)
+{
+	list_add(&pn->node, &blkcg->policy_list);
+}
+
+/* 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)
+{
+	struct blkio_policy_node *pn;
+
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		if (pn->dev == dev)
+			return pn;
+	}
+
+	return NULL;
+}
+
 struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
 {
 	return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),

@@ -128,6 +155,7 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	struct blkio_group *blkg;
 	struct hlist_node *n;
 	struct blkio_policy_type *blkiop;
+	struct blkio_policy_node *pn;
 
 	if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
 		return -EINVAL;

@@ -136,7 +164,13 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 	spin_lock(&blkio_list_lock);
 	spin_lock_irq(&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);
+
+		if (pn)
+			continue;
+
 		list_for_each_entry(blkiop, &blkio_list, list)
 			blkiop->ops.blkio_update_group_weight_fn(blkg,
 					blkcg->weight);

@@ -178,15 +212,208 @@ SHOW_FUNCTION_PER_GROUP(dequeue);
 
 #ifdef CONFIG_DEBUG_BLK_CGROUP
 void blkiocg_update_blkio_group_dequeue_stats(struct blkio_group *blkg,
-			unsigned long dequeue)
+					      unsigned long dequeue)
 {
 	blkg->dequeue += dequeue;
 }
 EXPORT_SYMBOL_GPL(blkiocg_update_blkio_group_dequeue_stats);
 #endif
 
+static int blkio_check_dev_num(dev_t dev)
+{
+	int part = 0;
+	struct gendisk *disk;
+
+	disk = get_gendisk(dev, &part);
+	if (!disk || part)
+		return -ENODEV;
+
+	return 0;
+}
+
+static int blkio_policy_parse_and_set(char *buf,
+				      struct blkio_policy_node *newpn)
+{
+	char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+	int ret;
+	unsigned long major, minor, temp;
+	int i = 0;
+	dev_t dev;
+
+	memset(s, 0, sizeof(s));
+
+	while ((p = strsep(&buf, " ")) != NULL) {
+		if (!*p)
+			continue;
+
+		s[i++] = p;
+
+		/* Prevent from inputing too many things */
+		if (i == 3)
+			break;
+	}
+
+	if (i != 2)
+		return -EINVAL;
+
+	p = strsep(&s[0], ":");
+	if (p != NULL)
+		major_s = p;
+	else
+		return -EINVAL;
+
+	minor_s = s[0];
+	if (!minor_s)
+		return -EINVAL;
+
+	ret = strict_strtoul(major_s, 10, &major);
+	if (ret)
+		return -EINVAL;
+
+	ret = strict_strtoul(minor_s, 10, &minor);
+	if (ret)
+		return -EINVAL;
+
+	dev = MKDEV(major, minor);
+
+	ret = blkio_check_dev_num(dev);
+	if (ret)
+		return ret;
+
+	newpn->dev = dev;
+
+	if (s[1] == NULL)
+		return -EINVAL;
+
+	ret = strict_strtoul(s[1], 10, &temp);
+	if (ret || (temp < BLKIO_WEIGHT_MIN && temp > 0) ||
+	    temp > BLKIO_WEIGHT_MAX)
+		return -EINVAL;
+
+	newpn->weight =  temp;
+
+	return 0;
+}
+
+unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+			      dev_t dev)
+{
+	struct blkio_policy_node *pn;
+
+	pn = blkio_policy_search_node(blkcg, dev);
+	if (pn)
+		return pn->weight;
+	else
+		return blkcg->weight;
+}
+EXPORT_SYMBOL_GPL(blkcg_get_weight);
+
+static int blkiocg_weight_device_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;
+	struct blkio_group *blkg;
+	int keep_newpn = 0;
+	struct hlist_node *n;
+	struct blkio_policy_type *blkiop;
+
+	buf = kstrdup(buffer, GFP_KERNEL);
+	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);
+	if (ret)
+		goto free_newpn;
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+
+	spin_lock_irq(&blkcg->lock);
+
+	pn = blkio_policy_search_node(blkcg, newpn->dev);
+	if (!pn) {
+		if (newpn->weight != 0) {
+			blkio_policy_insert_node(blkcg, newpn);
+			keep_newpn = 1;
+		}
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+
+	if (newpn->weight == 0) {
+		/* weight == 0 means deleteing a specific weight */
+		blkio_policy_delete_node(pn);
+		spin_unlock_irq(&blkcg->lock);
+		goto update_io_group;
+	}
+	spin_unlock_irq(&blkcg->lock);
+
+	pn->weight = newpn->weight;
+
+update_io_group:
+	/* update weight for each cfqg */
+	spin_lock(&blkio_list_lock);
+	spin_lock_irq(&blkcg->lock);
+
+	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+		if (newpn->dev == blkg->dev) {
+			list_for_each_entry(blkiop, &blkio_list, list)
+				blkiop->ops.blkio_update_group_weight_fn(blkg,
+						newpn->weight ?
+						newpn->weight :
+						blkcg->weight);
+		}
+	}
+
+	spin_unlock_irq(&blkcg->lock);
+	spin_unlock(&blkio_list_lock);
+
+free_newpn:
+	if (!keep_newpn)
+		kfree(newpn);
+free_buf:
+	kfree(buf);
+	return ret;
+}
+
+static int blkiocg_weight_device_read(struct cgroup *cgrp, struct cftype *cft,
+				      struct seq_file *m)
+{
+	struct blkio_cgroup *blkcg;
+	struct blkio_policy_node *pn;
+
+	seq_printf(m, "dev\tweight\n");
+
+	blkcg = cgroup_to_blkio_cgroup(cgrp);
+	if (list_empty(&blkcg->policy_list))
+		goto out;
+
+	spin_lock_irq(&blkcg->lock);
+	list_for_each_entry(pn, &blkcg->policy_list, node) {
+		seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
+			   MINOR(pn->dev), pn->weight);
+	}
+	spin_unlock_irq(&blkcg->lock);
+out:
+	return 0;
+}
+
 struct cftype blkio_files[] = {
 	{
+		.name = "weight_device",
+		.read_seq_string = blkiocg_weight_device_read,
+		.write_string = blkiocg_weight_device_write,
+		.max_write_len = 256,
+	},
+	{
 		.name = "weight",
 		.read_u64 = blkiocg_weight_read,
 		.write_u64 = blkiocg_weight_write,

@@ -220,6 +447,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 	struct blkio_group *blkg;
 	void *key;
 	struct blkio_policy_type *blkiop;
+	struct blkio_policy_node *pn, *pntmp;
 
 	rcu_read_lock();
 remove_entry:

@@ -250,7 +478,12 @@ remove_entry:
 		blkiop->ops.blkio_unlink_group_fn(key, blkg);
 	spin_unlock(&blkio_list_lock);
 	goto remove_entry;
+
 done:
+	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();
 	kfree(blkcg);

@@ -280,6 +513,7 @@ done:
 	spin_lock_init(&blkcg->lock);
 	INIT_HLIST_HEAD(&blkcg->blkg_list);
 
+	INIT_LIST_HEAD(&blkcg->policy_list);
 	return &blkcg->css;
 }
 

block/blk-cgroup.h +10 -0

index 84bf745..c8144a2 100644
@@ -22,6 +22,7 @@ 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 {

@@ -43,6 +44,15 @@ struct blkio_group {
 	unsigned long sectors;
 };
 
+struct blkio_policy_node {
+	struct list_head node;
+	dev_t dev;
+	unsigned int weight;
+};
+
+extern unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+				     dev_t dev);
+
 typedef void (blkio_unlink_group_fn) (void *key, struct blkio_group *blkg);
 typedef void (blkio_update_group_weight_fn) (struct blkio_group *blkg,
 						unsigned int weight);

block/cfq-iosched.c +1 -1

index dee9d93..6945e9b 100644
@@ -954,7 +954,6 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	if (!cfqg)
 		goto done;
 
-	cfqg->weight = blkcg->weight;
 	for_each_cfqg_st(cfqg, i, j, st)
 		*st = CFQ_RB_ROOT;
 	RB_CLEAR_NODE(&cfqg->rb_node);

@@ -971,6 +970,7 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
 	sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);
 	blkiocg_add_blkio_group(blkcg, &cfqg->blkg, (void *)cfqd,
 					MKDEV(major, minor));
+	cfqg->weight = blkcg_get_weight(blkcg, cfqg->blkg.dev);
 
 	/* Add group on cfqd list */
 	hlist_add_head(&cfqg->cfqd_node, &cfqd->cfqg_list);

Signature · 1 line

1.5.4.rc3

Quoted 19 lines · Gui Jianfeng

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.weight_device" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by "blkio.weight_device"

You can use the following format to assigned specific weight for a given device:

major:minor represents device number.

And you can remove a specific weight as following:

V1->V2 changes:
- use user interface "weight_device" instead of "policy" suggested by Vivek
- rename some struct suggested by Vivek
- rebase to 2.6-block "for-linus" branch
- remove an useless list_empty check pointed out by Li Zefan
- some trivial typo fix

Quoted 4 lines

V2->V3 changes:
- Move policy_*_node() functions up to get rid of forward declarations
- rename related functions by adding prefix "blkio_"

Thanks for the changes Gui. Looks good to me.

Acked-by Vivek Goyal <[email protected]>

Vivek

Quoted 134 lines

Signed-off-by Gui Jianfeng <[email protected]>

---
 block/blk-cgroup.c  |  236 ++++++++++++++++++++++++++++++++++++++++++++++++++- block/blk-cgroup.h  |   10 ++
 block/cfq-iosched.c |    2 +-

 3 files changed, 246 insertions(+), 2 deletions(-)

block/blk-cgroup.c +83 -1

index c85d74c..8825e49 100644
@@ -16,6 +16,7 @@
  #include <linux/module.h>
  #include <linux/err.h>
  #include "blk-cgroup.h"
+#include <linux/genhd.h>
 
  static DEFINE_SPINLOCK(blkio_list_lock);
  static LIST_HEAD(blkio_list);

@@ -23,6 +24,32 @@ static LIST_HEAD(blkio_list);
  struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT };
  EXPORT_SYMBOL_GPL(blkio_root_cgroup);
 
+static inline void blkio_policy_insert_node(struct blkio_cgroup *blkcg,
+                                         struct blkio_policy_node *pn)
+{
+     list_add(&pn->node, &blkcg->policy_list);
+}
+
+/* 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)
+{
+     struct blkio_policy_node *pn;
+
+     list_for_each_entry(pn, &blkcg->policy_list, node) {
+             if (pn->dev == dev)
+                     return pn;
+     }
+
+     return NULL;
+}
+
  struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
  {
       return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),

@@ -128,6 +155,7 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
       struct blkio_group *blkg;
       struct hlist_node *n;
       struct blkio_policy_type *blkiop;
+     struct blkio_policy_node *pn;
 
       if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
               return -EINVAL;

@@ -136,7 +164,13 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
       spin_lock(&blkio_list_lock);
       spin_lock_irq(&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);
+
+             if (pn)
+                     continue;
+
               list_for_each_entry(blkiop, &blkio_list, list)
                       blkiop->ops.blkio_update_group_weight_fn(blkg,
                                       blkcg->weight);

@@ -178,15 +212,208 @@ SHOW_FUNCTION_PER_GROUP(dequeue);
 
  #ifdef CONFIG_DEBUG_BLK_CGROUP
  void blkiocg_update_blkio_group_dequeue_stats(struct blkio_group *blkg,
-                     unsigned long dequeue)
+                                           unsigned long dequeue)
  {
       blkg->dequeue += dequeue;
  }
  EXPORT_SYMBOL_GPL(blkiocg_update_blkio_group_dequeue_stats);
  #endif
 
+static int blkio_check_dev_num(dev_t dev)
+{
+     int part = 0;
+     struct gendisk *disk;
+
+     disk = get_gendisk(dev, &part);
+     if (!disk || part)
+             return -ENODEV;
+
+     return 0;
+}
+
+static int blkio_policy_parse_and_set(char *buf,
+                                   struct blkio_policy_node *newpn)
+{
+     char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+     int ret;
+     unsigned long major, minor, temp;
+     int i = 0;
+     dev_t dev;
+
+     memset(s, 0, sizeof(s));
+
+     while ((p = strsep(&buf, " ")) != NULL) {
+             if (!*p)
+                     continue;
+
+             s[i++] = p;
+
+             /* Prevent from inputing too many things */
+             if (i == 3)
+                     break;
+     }
+
+     if (i != 2)
+             return -EINVAL;
+
+     p = strsep(&s[0], ":");
+     if (p != NULL)
+             major_s = p;
+     else
+             return -EINVAL;
+
+     minor_s = s[0];
+     if (!minor_s)
+             return -EINVAL;
+
+     ret = strict_strtoul(major_s, 10, &major);

block/blk-cgroup.c SHOW_FUNCTION_PER_GROUP(dequeue); · line 277

Quoted 8 lines

block/blk-cgroup.c +8 -0

+     if (ret)
+             return -EINVAL;
+
+     ret = strict_strtoul(minor_s, 10, &minor);
+     if (ret)
+             return -EINVAL;
+
+     dev = MKDEV(major, minor);

Quoted 225 lines

block/blk-cgroup.c +138 -0

+
+     ret = blkio_check_dev_num(dev);
+     if (ret)
+             return ret;
+
+     newpn->dev = dev;
+
+     if (s[1] == NULL)
+             return -EINVAL;
+
+     ret = strict_strtoul(s[1], 10, &temp);
+     if (ret || (temp < BLKIO_WEIGHT_MIN && temp > 0) ||
+         temp > BLKIO_WEIGHT_MAX)
+             return -EINVAL;
+
+     newpn->weight =  temp;
+
+     return 0;
+}
+
+unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+                           dev_t dev)
+{
+     struct blkio_policy_node *pn;
+
+     pn = blkio_policy_search_node(blkcg, dev);
+     if (pn)
+             return pn->weight;
+     else
+             return blkcg->weight;
+}
+EXPORT_SYMBOL_GPL(blkcg_get_weight);
+
+static int blkiocg_weight_device_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;
+     struct blkio_group *blkg;
+     int keep_newpn = 0;
+     struct hlist_node *n;
+     struct blkio_policy_type *blkiop;
+
+     buf = kstrdup(buffer, GFP_KERNEL);
+     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);
+     if (ret)
+             goto free_newpn;
+
+     blkcg = cgroup_to_blkio_cgroup(cgrp);
+
+     spin_lock_irq(&blkcg->lock);
+
+     pn = blkio_policy_search_node(blkcg, newpn->dev);
+     if (!pn) {
+             if (newpn->weight != 0) {
+                     blkio_policy_insert_node(blkcg, newpn);
+                     keep_newpn = 1;
+             }
+             spin_unlock_irq(&blkcg->lock);
+             goto update_io_group;
+     }
+
+     if (newpn->weight == 0) {
+             /* weight == 0 means deleteing a specific weight */
+             blkio_policy_delete_node(pn);
+             spin_unlock_irq(&blkcg->lock);
+             goto update_io_group;
+     }
+     spin_unlock_irq(&blkcg->lock);
+
+     pn->weight = newpn->weight;
+
+update_io_group:
+     /* update weight for each cfqg */
+     spin_lock(&blkio_list_lock);
+     spin_lock_irq(&blkcg->lock);
+
+     hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
+             if (newpn->dev == blkg->dev) {
+                     list_for_each_entry(blkiop, &blkio_list, list)
+                             blkiop->ops.blkio_update_group_weight_fn(blkg,
+                                             newpn->weight ?
+                                             newpn->weight :
+                                             blkcg->weight);
+             }
+     }
+
+     spin_unlock_irq(&blkcg->lock);
+     spin_unlock(&blkio_list_lock);
+
+free_newpn:
+     if (!keep_newpn)
+             kfree(newpn);
+free_buf:
+     kfree(buf);
+     return ret;
+}
+
+static int blkiocg_weight_device_read(struct cgroup *cgrp, struct cftype *cft,
+                                   struct seq_file *m)
+{
+     struct blkio_cgroup *blkcg;
+     struct blkio_policy_node *pn;
+
+     seq_printf(m, "dev\tweight\n");
+
+     blkcg = cgroup_to_blkio_cgroup(cgrp);
+     if (list_empty(&blkcg->policy_list))
+             goto out;
+
+     spin_lock_irq(&blkcg->lock);
+     list_for_each_entry(pn, &blkcg->policy_list, node) {
+             seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
+                        MINOR(pn->dev), pn->weight);
+     }
+     spin_unlock_irq(&blkcg->lock);
+out:
+     return 0;
+}
+
  struct cftype blkio_files[] = {
       {
+             .name = "weight_device",
+             .read_seq_string = blkiocg_weight_device_read,
+             .write_string = blkiocg_weight_device_write,
+             .max_write_len = 256,
+     },
+     {
               .name = "weight",
               .read_u64 = blkiocg_weight_read,
               .write_u64 = blkiocg_weight_write,

@@ -220,6 +447,7 @@ static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
       struct blkio_group *blkg;
       void *key;
       struct blkio_policy_type *blkiop;
+     struct blkio_policy_node *pn, *pntmp;
 
       rcu_read_lock();

 remove_entry:

block/blk-cgroup.c +1 -0

@@ -250,7 +478,12 @@ remove_entry:
               blkiop->ops.blkio_unlink_group_fn(key, blkg);
       spin_unlock(&blkio_list_lock);
       goto remove_entry;
+

 done:
+     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();
      kfree(blkcg);

block/blk-cgroup.c +1 -0

@@ -280,6 +513,7 @@ done:
       spin_lock_init(&blkcg->lock);
       INIT_HLIST_HEAD(&blkcg->blkg_list);
 
+     INIT_LIST_HEAD(&blkcg->policy_list);
       return &blkcg->css;
  }
 

block/blk-cgroup.h +10 -0

index 84bf745..c8144a2 100644
@@ -22,6 +22,7 @@ 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 {

@@ -43,6 +44,15 @@ struct blkio_group {
       unsigned long sectors;
  };
 
+struct blkio_policy_node {
+     struct list_head node;
+     dev_t dev;
+     unsigned int weight;
+};
+
+extern unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
+                                  dev_t dev);
+
  typedef void (blkio_unlink_group_fn) (void *key, struct blkio_group *blkg);
  typedef void (blkio_update_group_weight_fn) (struct blkio_group *blkg,
                                               unsigned int weight);

block/cfq-iosched.c +1 -2

index dee9d93..6945e9b 100644
@@ -954,7 +954,6 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
       if (!cfqg)
               goto done;
 
-     cfqg->weight = blkcg->weight;
       for_each_cfqg_st(cfqg, i, j, st)
               *st = CFQ_RB_ROOT;
       RB_CLEAR_NODE(&cfqg->rb_node);

@@ -971,6 +970,7 @@ cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
       sscanf(dev_name(bdi->dev), "%u:%u", &major, &minor);
       blkiocg_add_blkio_group(blkcg, &cfqg->blkg, (void *)cfqd,
                                       MKDEV(major, minor));
+     cfqg->weight = blkcg_get_weight(blkcg, cfqg->blkg.dev);
 
       /* Add group on cfqd list */
       hlist_add_head(&cfqg->cfqd_node, &cfqd->cfqg_list);
--

1.5.4.rc3

Quoted 165 lines · Vivek Goyal

Quoted 19 lines · Gui Jianfeng

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.weight_device" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by "blkio.weight_device"

You can use the following format to assigned specific weight for a given device:

major:minor represents device number.

And you can remove a specific weight as following:

V1->V2 changes:
- use user interface "weight_device" instead of "policy" suggested by Vivek
- rename some struct suggested by Vivek
- rebase to 2.6-block "for-linus" branch
- remove an useless list_empty check pointed out by Li Zefan
- some trivial typo fix

Quoted 4 lines

V2->V3 changes:
- Move policy_*_node() functions up to get rid of forward declarations
- rename related functions by adding prefix "blkio_"

Thanks for the changes Gui. Looks good to me.

Acked-by Vivek Goyal <[email protected]>

Vivek

Quoted 134 lines

Signed-off-by Gui Jianfeng <[email protected]>

---
 block/blk-cgroup.c  |  236 ++++++++++++++++++++++++++++++++++++++++++++++++++- block/blk-cgroup.h  |   10 ++
 block/cfq-iosched.c |    2 +-

 3 files changed, 246 insertions(+), 2 deletions(-)

block/blk-cgroup.c +83 -1

index c85d74c..8825e49 100644
@@ -16,6 +16,7 @@
  #include <linux/module.h>
  #include <linux/err.h>
  #include "blk-cgroup.h"
+#include <linux/genhd.h>
 
  static DEFINE_SPINLOCK(blkio_list_lock);
  static LIST_HEAD(blkio_list);

@@ -23,6 +24,32 @@ static LIST_HEAD(blkio_list);
  struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT };
  EXPORT_SYMBOL_GPL(blkio_root_cgroup);
 
+static inline void blkio_policy_insert_node(struct blkio_cgroup *blkcg,
+                                         struct blkio_policy_node *pn)
+{
+     list_add(&pn->node, &blkcg->policy_list);
+}
+
+/* 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)
+{
+     struct blkio_policy_node *pn;
+
+     list_for_each_entry(pn, &blkcg->policy_list, node) {
+             if (pn->dev == dev)
+                     return pn;
+     }
+
+     return NULL;
+}
+
  struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
  {
       return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),

@@ -128,6 +155,7 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
       struct blkio_group *blkg;
       struct hlist_node *n;
       struct blkio_policy_type *blkiop;
+     struct blkio_policy_node *pn;
 
       if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
               return -EINVAL;

@@ -136,7 +164,13 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
       spin_lock(&blkio_list_lock);
       spin_lock_irq(&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);
+
+             if (pn)
+                     continue;
+
               list_for_each_entry(blkiop, &blkio_list, list)
                       blkiop->ops.blkio_update_group_weight_fn(blkg,
                                       blkcg->weight);

@@ -178,15 +212,208 @@ SHOW_FUNCTION_PER_GROUP(dequeue);
 
  #ifdef CONFIG_DEBUG_BLK_CGROUP
  void blkiocg_update_blkio_group_dequeue_stats(struct blkio_group *blkg,
-                     unsigned long dequeue)
+                                           unsigned long dequeue)
  {
       blkg->dequeue += dequeue;
  }
  EXPORT_SYMBOL_GPL(blkiocg_update_blkio_group_dequeue_stats);
  #endif
 
+static int blkio_check_dev_num(dev_t dev)
+{
+     int part = 0;
+     struct gendisk *disk;
+
+     disk = get_gendisk(dev, &part);
+     if (!disk || part)
+             return -ENODEV;
+
+     return 0;
+}
+
+static int blkio_policy_parse_and_set(char *buf,
+                                   struct blkio_policy_node *newpn)
+{
+     char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+     int ret;
+     unsigned long major, minor, temp;
+     int i = 0;
+     dev_t dev;
+
+     memset(s, 0, sizeof(s));
+
+     while ((p = strsep(&buf, " ")) != NULL) {
+             if (!*p)
+                     continue;
+
+             s[i++] = p;
+
+             /* Prevent from inputing too many things */
+             if (i == 3)
+                     break;
+     }
+
+     if (i != 2)
+             return -EINVAL;
+
+     p = strsep(&s[0], ":");
+     if (p != NULL)
+             major_s = p;
+     else
+             return -EINVAL;
+
+     minor_s = s[0];
+     if (!minor_s)
+             return -EINVAL;
+
+     ret = strict_strtoul(major_s, 10, &major);

Quoted 8 lines

block/blk-cgroup.c SHOW_FUNCTION_PER_GROUP(dequeue); · line 277

Quoted 8 lines

block/blk-cgroup.c +8 -0

+     if (ret)
+             return -EINVAL;
+
+     ret = strict_strtoul(minor_s, 10, &minor);
+     if (ret)
+             return -EINVAL;
+
+     dev = MKDEV(major, minor);

I am not quite sure if exposing a mojor,minor number is the best interface that can be exposed to user space. How about actual disk names like sda, sdb, .. etc? The only problem I see there is that it seems tricky to get to these disk names from within the block layer.

"struct request_queue" has a pointer to backing_dev which has a device from which we can get major,minor. But in order to get to disk name, we would have to call get_gendisk which can hold a semaphore. Is this the reason for us going with major,minor as a user interface to specify a disk? I bet there are good reasons for us not keeping a pointer to "struct gendisk" from "struct request_queue". If we could keep that pointer, our user interface could be very easily modified to be the disk name like sda, sdb, etc.

Quoted 177 lines · Nauman Rafique

Quoted 164 lines · Vivek Goyal

Quoted 19 lines · Gui Jianfeng

Currently, IO Controller makes use of blkio.weight to assign weight for all devices. Here a new user interface "blkio.weight_device" is introduced to assign different weights for different devices. blkio.weight becomes the default value for devices which are not configured by "blkio.weight_device"

You can use the following format to assigned specific weight for a given device:

major:minor represents device number.

And you can remove a specific weight as following:

V1->V2 changes:
- use user interface "weight_device" instead of "policy" suggested by Vivek
- rename some struct suggested by Vivek
- rebase to 2.6-block "for-linus" branch
- remove an useless list_empty check pointed out by Li Zefan
- some trivial typo fix

Quoted 4 lines

V2->V3 changes:
- Move policy_*_node() functions up to get rid of forward declarations
- rename related functions by adding prefix "blkio_"

Thanks for the changes Gui. Looks good to me.

Acked-by Vivek Goyal <[email protected]>

Vivek

Quoted 134 lines

Signed-off-by Gui Jianfeng <[email protected]>

---
 block/blk-cgroup.c  |  236 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 block/blk-cgroup.h  |   10 ++
 block/cfq-iosched.c |    2 +-
 3 files changed, 246 insertions(+), 2 deletions(-)

block/blk-cgroup.c +83 -1

index c85d74c..8825e49 100644
@@ -16,6 +16,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include "blk-cgroup.h"
+#include <linux/genhd.h>
 
 static DEFINE_SPINLOCK(blkio_list_lock);
 static LIST_HEAD(blkio_list);

@@ -23,6 +24,32 @@ static LIST_HEAD(blkio_list);
 struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT };
 EXPORT_SYMBOL_GPL(blkio_root_cgroup);
 
+static inline void blkio_policy_insert_node(struct blkio_cgroup *blkcg,
+                                         struct blkio_policy_node *pn)
+{
+     list_add(&pn->node, &blkcg->policy_list);
+}
+
+/* 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)
+{
+     struct blkio_policy_node *pn;
+
+     list_for_each_entry(pn, &blkcg->policy_list, node) {
+             if (pn->dev == dev)
+                     return pn;
+     }
+
+     return NULL;
+}
+
 struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
 {
      return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),

@@ -128,6 +155,7 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
      struct blkio_group *blkg;
      struct hlist_node *n;
      struct blkio_policy_type *blkiop;
+     struct blkio_policy_node *pn;
 
      if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
              return -EINVAL;

@@ -136,7 +164,13 @@ blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
      spin_lock(&blkio_list_lock);
      spin_lock_irq(&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);
+
+             if (pn)
+                     continue;
+
              list_for_each_entry(blkiop, &blkio_list, list)
                      blkiop->ops.blkio_update_group_weight_fn(blkg,
                                      blkcg->weight);

@@ -178,15 +212,208 @@ SHOW_FUNCTION_PER_GROUP(dequeue);
 
 #ifdef CONFIG_DEBUG_BLK_CGROUP
 void blkiocg_update_blkio_group_dequeue_stats(struct blkio_group *blkg,
-                     unsigned long dequeue)
+                                           unsigned long dequeue)
 {
      blkg->dequeue += dequeue;
 }
 EXPORT_SYMBOL_GPL(blkiocg_update_blkio_group_dequeue_stats);
 #endif
 
+static int blkio_check_dev_num(dev_t dev)
+{
+     int part = 0;
+     struct gendisk *disk;
+
+     disk = get_gendisk(dev, &part);
+     if (!disk || part)
+             return -ENODEV;
+
+     return 0;
+}
+
+static int blkio_policy_parse_and_set(char *buf,
+                                   struct blkio_policy_node *newpn)
+{
+     char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+     int ret;
+     unsigned long major, minor, temp;
+     int i = 0;
+     dev_t dev;
+
+     memset(s, 0, sizeof(s));
+
+     while ((p = strsep(&buf, " ")) != NULL) {
+             if (!*p)
+                     continue;
+
+             s[i++] = p;
+
+             /* Prevent from inputing too many things */
+             if (i == 3)
+                     break;
+     }
+
+     if (i != 2)
+             return -EINVAL;
+
+     p = strsep(&s[0], ":");
+     if (p != NULL)
+             major_s = p;
+     else
+             return -EINVAL;
+
+     minor_s = s[0];
+     if (!minor_s)
+             return -EINVAL;
+
+     ret = strict_strtoul(major_s, 10, &major);

Quoted 8 lines

block/blk-cgroup.c SHOW_FUNCTION_PER_GROUP(dequeue); · line 277

Quoted 8 lines

block/blk-cgroup.c +8 -0

+     if (ret)
+             return -EINVAL;
+
+     ret = strict_strtoul(minor_s, 10, &minor);
+     if (ret)
+             return -EINVAL;
+
+     dev = MKDEV(major, minor);

I am not quite sure if exposing a mojor,minor number is the best interface that can be exposed to user space. How about actual disk names like sda, sdb, .. etc? The only problem I see there is that it seems tricky to get to these disk names from within the block layer.

Quoted 8 lines

"struct request_queue" has a pointer to backing_dev which has a device from which we can get major,minor. But in order to get to disk name, we would have to call get_gendisk which can hold a semaphore. Is this the reason for us going with major,minor as a user interface to specify a disk? I bet there are good reasons for us not keeping a pointer to "struct gendisk" from "struct request_queue". If we could keep that pointer, our user interface could be very easily modified to be the disk name like sda, sdb, etc.

That's a good question. Why not use device names instead of device numbers? From user's perspective, device names will be more intutive to use.

At the same time, will it look odd to handle devices with their names as WWID.

/dev/mapper/3600508b400105df70000e000026f0000

Though I see that there is an alternate way to address the same device like /dev/dm-2 etc.

So from user's perspective I think it will be more intutive to handle disk names instead of numbers.

Gui, did you forsee issues in implementing disk names?

From the implementation of view, we need a device number as a key in blkio_policy_node,

Thanks
Vivek

Quoted 71 lines

Quoted 48 lines

Quoted 36 lines

Quoted 36 lines

block/blk-cgroup.c +36 -0

+static int blkio_policy_parse_and_set(char *buf,
+                                   struct blkio_policy_node *newpn)
+{
+     char *s[4], *p, *major_s = NULL, *minor_s = NULL;
+     int ret;
+     unsigned long major, minor, temp;
+     int i = 0;
+     dev_t dev;
+
+     memset(s, 0, sizeof(s));
+
+     while ((p = strsep(&buf, " ")) != NULL) {
+             if (!*p)
+                     continue;
+
+             s[i++] = p;
+
+             /* Prevent from inputing too many things */
+             if (i == 3)
+                     break;
+     }
+
+     if (i != 2)
+             return -EINVAL;
+
+     p = strsep(&s[0], ":");
+     if (p != NULL)
+             major_s = p;
+     else
+             return -EINVAL;
+
+     minor_s = s[0];
+     if (!minor_s)
+             return -EINVAL;
+
+     ret = strict_strtoul(major_s, 10, &major);

Quoted 8 lines

block/blk-cgroup.c SHOW_FUNCTION_PER_GROUP(dequeue); · line 277

Quoted 8 lines

block/blk-cgroup.c +8 -0

+     if (ret)
+             return -EINVAL;
+
+     ret = strict_strtoul(minor_s, 10, &minor);
+     if (ret)
+             return -EINVAL;
+
+     dev = MKDEV(major, minor);

I am not quite sure if exposing a mojor,minor number is the best interface that can be exposed to user space. How about actual disk names like sda, sdb, .. etc? The only problem I see there is that it seems tricky to get to these disk names from within the block layer.

Quoted 8 lines

"struct request_queue" has a pointer to backing_dev which has a device from which we can get major,minor. But in order to get to disk name, we would have to call get_gendisk which can hold a semaphore. Is this the reason for us going with major,minor as a user interface to specify a disk? I bet there are good reasons for us not keeping a pointer to "struct gendisk" from "struct request_queue". If we could keep that pointer, our user interface could be very easily modified to be the disk name like sda, sdb, etc.

That's a good question. Why not use device names instead of device numbers? From user's perspective, device names will be more intutive to use.

At the same time, will it look odd to handle devices with their names as WWID.

/dev/mapper/3600508b400105df70000e000026f0000

Though I see that there is an alternate way to address the same device like /dev/dm-2 etc.

So from user's perspective I think it will be more intutive to handle disk names instead of numbers.

Quoted 1 line

Gui, did you forsee issues in implementing disk names?

Hi Vivek,

Quoted 1 line

From the implementation of view, we need a device number as a key in blkio_policy_node,

if using device name as user interface, i can't figure out a way to retirve the corresponding device number by means of device name (like sda, not "/dev/sda").