* [PATCH 0/8] I/O bandwidth controller and BIO tracking
@ 2008-11-13 3:10 Ryo Tsuruta
2008-11-13 3:11 ` [PATCH 1/8] dm-ioband: Introduction Ryo Tsuruta
2008-11-13 6:30 ` [PATCH 0/8] I/O bandwidth controller and BIO tracking KAMEZAWA Hiroyuki
0 siblings, 2 replies; 19+ messages in thread
From: Ryo Tsuruta @ 2008-11-13 3:10 UTC (permalink / raw)
To: linux-kernel, dm-devel, containers, virtualization, xen-devel
Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando
Hi everyone,
This is a new release of dm-ioband and bio-cgroup. With this release,
the overhead of bio-cgroup is significantly reduced and the accuracy
of block I/O tracking is much improved. These patches are for
2.6.28-rc2-mm1.
Enjoy it!
dm-ioband
=========
Dm-ioband is an I/O bandwidth controller implemented as a
device-mapper driver, which gives specified bandwidth to each job
running on the same block device. A job is a group of processes
or a virtual machine such as KVM or Xen.
I/O throughput on dm-ioband is excellent not only on SATA storage
but on SDD, which as good as the one without dm-ioband.
Changes from the previous release:
- Fix a bug that create_workqueue() is called during spin lock
when creating a new ioband group.
- A new tunable parameter "carryover" is added, which specifies
how many tokens an ioband group can keep for the future use
when the group isn't so active.
TODO:
- Other policies to schedule BIOs.
- Policies which fits SSD.
e.g.)
- Guarantee response time.
- Guarantee throughput.
- Policies which fits Highend Storage or hardware raid storage.
- Some LUNs may share the same bandwidth.
- Support WRITE_BARRIER when the device-mapper layer supports it.
- Implement the algorithm of dm-ioband in the block I/O layer
experimentally.
bio-cgroup
==========
Bio-cgroup is a BIO tracking mechanism, which is implemented on the
cgroup memory subsystem. With the mechanism, it is able to determine
which cgroup each of bio belongs to, even when the bio is one of
delayed-write requests issued from a kernel thread such as pdflush.
Changes from the previous release:
- This release is a new implementation.
- This is based on the new design of the cgroup memory controller
framework, which pre-allocates all cgroup-page data structures to
reduce the overhead.
- The overhead to trace block I/O requests is much smaller than that
of the previous one. This is done by making every page have the id
of its corresponding bio-cgroup instead of the pointer to it and
most of spin-locks and atomic operations are gone.
- This implementation uses only 4 bytes per page for I/O tracking
while the previous version uses 12 bytes on a 32 bit machine and 24
bytes on a 64 bit machine.
- The accuracy of I/O tracking is improved that it can trace I/O
requests even when the processes which issued these requests get
moved into another bio-cgroup.
- Support bounce buffers tracking. They will have the same bio-cgroup
owners as the original I/O requests.
TODO:
- Support to track I/O requests that will be generated in Linux
kernel, such as those of RAID0 and RAID5.
A list of patches
=================
The following is a list of patches:
[PATCH 0/8] I/O bandwidth controller and BIO tracking
[PATCH 1/8] dm-ioband: Introduction
[PATCH 2/8] dm-ioband: Source code and patch
[PATCH 3/8] dm-ioband: Document
[PATCH 4/8] bio-cgroup: Introduction
[PATCH 5/8] bio-cgroup: The new page_cgroup framework
[PATCH 6/8] bio-cgroup: The body of bio-cgroup
[PATCH 7/8] bio-cgroup: Page tracking hooks
[PATCH 8/8] bio-cgroup: Add a cgroup support to dm-ioband
Please see the following site for more information:
Linux Block I/O Bandwidth Control Project
http://people.valinux.co.jp/~ryov/bwctl/
Thanks,
Ryo Tsuruta
^ permalink raw reply [flat|nested] 19+ messages in thread* [PATCH 1/8] dm-ioband: Introduction 2008-11-13 3:10 [PATCH 0/8] I/O bandwidth controller and BIO tracking Ryo Tsuruta @ 2008-11-13 3:11 ` Ryo Tsuruta 2008-11-13 3:12 ` [PATCH 2/8] dm-ioband: Source code and patch Ryo Tsuruta 2008-11-13 19:36 ` [dm-devel] [PATCH 1/8] dm-ioband: Introduction Phillip Susi 2008-11-13 6:30 ` [PATCH 0/8] I/O bandwidth controller and BIO tracking KAMEZAWA Hiroyuki 1 sibling, 2 replies; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-13 3:11 UTC (permalink / raw) To: linux-kernel, dm-devel, containers, virtualization, xen-devel Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando What's am-ioband all about? =========================== dm-ioband is an I/O bandwidth controller implemented as a device-mapper driver, which gives specified bandwidth to each job running on the same block device. A job is a group of processes with the same pid or pgrp or uid or a virtual machine such as KVM or Xen. A job can also be a cgroup by applying the bio-cgroup patch. Setup and Installation ====================== Build a kernel with these options enabled: CONFIG_MD CONFIG_BLK_DEV_DM CONFIG_DM_IOBAND If compiled as module, use modprobe to load dm-ioband. # make modules # make modules_install # depmod -a # modprobe dm-ioband "dmsetup targets" command shows all available device-mapper targets. "ioband" and the version number are displayed when dm-ioband has been loaded. # dmsetup targets | grep ioband ioband v1.9.0 Getting started =============== The following is a brief description how to control the I/O bandwidth of disks. In this description, we'll take one disk with two partitions as an example target. Create and map ioband devices ----------------------------- Create two ioband devices "ioband1" and "ioband2". "ioband1" is mapped to "/dev/sda1" and has a weight of 40. "ioband2" is mapped to "/dev/sda2" and has a weight of 10. "ioband1" can use 80% --- 40/(40+10)*100 --- of the bandwidth of the physical disk "/dev/sda" while "ioband2" can use 20%. # echo "0 $(blockdev --getsize /dev/sda1) ioband /dev/sda1 1 0 0 none" \ "weight 0 :40" | dmsetup create ioband1 # echo "0 $(blockdev --getsize /dev/sda2) ioband /dev/sda2 1 0 0 none" \ "weight 0 :10" | dmsetup create ioband2 If the commands are successful then the device files "/dev/mapper/ioband1" and "/dev/mapper/ioband2" will have been created. Additional bandwidth control ---------------------------- In this example two extra ioband groups are created on "ioband1". The first group consists of all the processes with user-id 1000 and the second group consists of all the processes with user-id 2000. Their weights are 30 and 20 respectively. # dmsetup message ioband1 0 type user # dmsetup message ioband1 0 attach 1000 # dmsetup message ioband1 0 attach 2000 # dmsetup message ioband1 0 weight 1000:30 # dmsetup message ioband1 0 weight 2000:20 Now the processes in the user-id 1000 group can use 30% --- 30/(30+20+40+10)*100 --- of the bandwidth of the physical disk. Table 1. Weight assignments ioband device ioband group ioband weight ioband1 user id 1000 30 ioband1 user id 2000 20 ioband1 default group 40 ioband2 default group 10 Remove the ioband devices ------------------------- Remove the ioband devices when no longer used. # dmsetup remove ioband1 # dmsetup remove ioband2 ^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 2/8] dm-ioband: Source code and patch 2008-11-13 3:11 ` [PATCH 1/8] dm-ioband: Introduction Ryo Tsuruta @ 2008-11-13 3:12 ` Ryo Tsuruta 2008-11-13 3:12 ` [PATCH 3/8] dm-ioband: Document Ryo Tsuruta 2008-11-13 19:36 ` [dm-devel] [PATCH 1/8] dm-ioband: Introduction Phillip Susi 1 sibling, 1 reply; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-13 3:12 UTC (permalink / raw) To: linux-kernel, dm-devel, containers, virtualization, xen-devel Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando This patch is the dm-ioband version 1.9.0 release. Signed-off-by: Ryo Tsuruta <ryov@valinux.co.jp> Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> diff -uprN linux-2.6.28-rc2-mm1.orig/drivers/md/Kconfig linux-2.6.28-rc2-mm1/drivers/md/Kconfig --- linux-2.6.28-rc2-mm1.orig/drivers/md/Kconfig 2008-10-30 17:34:30.000000000 +0900 +++ linux-2.6.28-rc2-mm1/drivers/md/Kconfig 2008-11-13 09:37:55.000000000 +0900 @@ -289,4 +289,17 @@ config DM_UEVENT ---help--- Generate udev events for DM events. +config DM_IOBAND + tristate "I/O bandwidth control (EXPERIMENTAL)" + depends on BLK_DEV_DM && EXPERIMENTAL + ---help--- + This device-mapper target allows to define how the + available bandwidth of a storage device should be + shared between processes, cgroups, the partitions or the LUNs. + + Information on how to use dm-ioband is available in: + <file:Documentation/device-mapper/ioband.txt>. + + If unsure, say N. + endif # MD diff -uprN linux-2.6.28-rc2-mm1.orig/drivers/md/Makefile linux-2.6.28-rc2-mm1/drivers/md/Makefile --- linux-2.6.28-rc2-mm1.orig/drivers/md/Makefile 2008-10-30 17:34:30.000000000 +0900 +++ linux-2.6.28-rc2-mm1/drivers/md/Makefile 2008-11-13 09:37:55.000000000 +0900 @@ -7,6 +7,7 @@ dm-mod-objs := dm.o dm-table.o dm-target dm-multipath-objs := dm-path-selector.o dm-mpath.o dm-snapshot-objs := dm-snap.o dm-exception-store.o dm-mirror-objs := dm-raid1.o +dm-ioband-objs := dm-ioband-ctl.o dm-ioband-policy.o dm-ioband-type.o md-mod-objs := md.o bitmap.o raid456-objs := raid5.o raid6algos.o raid6recov.o raid6tables.o \ raid6int1.o raid6int2.o raid6int4.o \ @@ -36,6 +37,7 @@ obj-$(CONFIG_DM_MULTIPATH) += dm-multipa obj-$(CONFIG_DM_SNAPSHOT) += dm-snapshot.o obj-$(CONFIG_DM_MIRROR) += dm-mirror.o dm-log.o dm-region-hash.o obj-$(CONFIG_DM_ZERO) += dm-zero.o +obj-$(CONFIG_DM_IOBAND) += dm-ioband.o quiet_cmd_unroll = UNROLL $@ cmd_unroll = $(PERL) $(srctree)/$(src)/unroll.pl $(UNROLL) \ diff -uprN linux-2.6.28-rc2-mm1.orig/drivers/md/dm-ioband-ctl.c linux-2.6.28-rc2-mm1/drivers/md/dm-ioband-ctl.c --- linux-2.6.28-rc2-mm1.orig/drivers/md/dm-ioband-ctl.c 1970-01-01 09:00:00.000000000 +0900 +++ linux-2.6.28-rc2-mm1/drivers/md/dm-ioband-ctl.c 2008-11-13 09:37:55.000000000 +0900 @@ -0,0 +1,1328 @@ +/* + * Copyright (C) 2008 VA Linux Systems Japan K.K. + * Authors: Hirokazu Takahashi <taka@valinux.co.jp> + * Ryo Tsuruta <ryov@valinux.co.jp> + * + * I/O bandwidth control + * + * This file is released under the GPL. + */ +#include <linux/module.h> +#include <linux/init.h> +#include <linux/bio.h> +#include <linux/slab.h> +#include <linux/workqueue.h> +#include <linux/raid/md.h> +#include <linux/rbtree.h> +#include "dm.h" +#include "dm-bio-list.h" +#include "dm-ioband.h" + +#define DM_MSG_PREFIX "ioband" +#define POLICY_PARAM_START 6 +#define POLICY_PARAM_DELIM "=:," + +static LIST_HEAD(ioband_device_list); +/* to protect ioband_device_list */ +static DEFINE_SPINLOCK(ioband_devicelist_lock); + +static void suspend_ioband_device(struct ioband_device *, unsigned long, int); +static void resume_ioband_device(struct ioband_device *); +static void ioband_conduct(struct work_struct *); +static void ioband_hold_bio(struct ioband_group *, struct bio *); +static struct bio *ioband_pop_bio(struct ioband_group *); +static int ioband_set_param(struct ioband_group *, char *, char *); +static int ioband_group_attach(struct ioband_group *, int, char *); +static int ioband_group_type_select(struct ioband_group *, char *); + +long ioband_debug; /* just for debugging */ + +static void do_nothing(void) {} + +static int policy_init(struct ioband_device *dp, char *name, + int argc, char **argv) +{ + struct policy_type *p; + struct ioband_group *gp; + unsigned long flags; + int r; + + for (p = dm_ioband_policy_type; p->p_name; p++) { + if (!strcmp(name, p->p_name)) + break; + } + if (!p->p_name) + return -EINVAL; + + spin_lock_irqsave(&dp->g_lock, flags); + if (dp->g_policy == p) { + /* do nothing if the same policy is already set */ + spin_unlock_irqrestore(&dp->g_lock, flags); + return 0; + } + + suspend_ioband_device(dp, flags, 1); + list_for_each_entry(gp, &dp->g_groups, c_list) + dp->g_group_dtr(gp); + + /* switch to the new policy */ + dp->g_policy = p; + r = p->p_policy_init(dp, argc, argv); + if (!dp->g_hold_bio) + dp->g_hold_bio = ioband_hold_bio; + if (!dp->g_pop_bio) + dp->g_pop_bio = ioband_pop_bio; + + list_for_each_entry(gp, &dp->g_groups, c_list) + dp->g_group_ctr(gp, NULL); + resume_ioband_device(dp); + spin_unlock_irqrestore(&dp->g_lock, flags); + return r; +} + +static struct ioband_device *alloc_ioband_device(char *name, + int io_throttle, int io_limit) + +{ + struct ioband_device *dp, *new; + unsigned long flags; + + new = kzalloc(sizeof(struct ioband_device), GFP_KERNEL); + if (!new) + return NULL; + + /* + * Prepare its own workqueue as generic_make_request() may + * potentially block the workqueue when submitting BIOs. + */ + new->g_ioband_wq = create_workqueue("kioband"); + if (!new->g_ioband_wq) { + kfree(new); + return NULL; + } + + spin_lock_irqsave(&ioband_devicelist_lock, flags); + list_for_each_entry(dp, &ioband_device_list, g_list) { + if (!strcmp(dp->g_name, name)) { + dp->g_ref++; + spin_unlock_irqrestore(&ioband_devicelist_lock, flags); + destroy_workqueue(new->g_ioband_wq); + kfree(new); + return dp; + } + } + + INIT_DELAYED_WORK(&new->g_conductor, ioband_conduct); + INIT_LIST_HEAD(&new->g_groups); + INIT_LIST_HEAD(&new->g_list); + spin_lock_init(&new->g_lock); + mutex_init(&new->g_lock_device); + bio_list_init(&new->g_urgent_bios); + new->g_io_throttle = io_throttle; + new->g_io_limit[0] = io_limit; + new->g_io_limit[1] = io_limit; + new->g_issued[0] = 0; + new->g_issued[1] = 0; + new->g_blocked = 0; + new->g_ref = 1; + new->g_flags = 0; + strlcpy(new->g_name, name, sizeof(new->g_name)); + new->g_policy = NULL; + new->g_hold_bio = NULL; + new->g_pop_bio = NULL; + init_waitqueue_head(&new->g_waitq); + init_waitqueue_head(&new->g_waitq_suspend); + init_waitqueue_head(&new->g_waitq_flush); + list_add_tail(&new->g_list, &ioband_device_list); + + spin_unlock_irqrestore(&ioband_devicelist_lock, flags); + return new; +} + +static void release_ioband_device(struct ioband_device *dp) +{ + unsigned long flags; + + spin_lock_irqsave(&ioband_devicelist_lock, flags); + dp->g_ref--; + if (dp->g_ref > 0) { + spin_unlock_irqrestore(&ioband_devicelist_lock, flags); + return; + } + list_del(&dp->g_list); + spin_unlock_irqrestore(&ioband_devicelist_lock, flags); + destroy_workqueue(dp->g_ioband_wq); + kfree(dp); +} + +static int is_ioband_device_flushed(struct ioband_device *dp, + int wait_completion) +{ + struct ioband_group *gp; + + if (wait_completion && dp->g_issued[0] + dp->g_issued[1] > 0) + return 0; + if (dp->g_blocked || waitqueue_active(&dp->g_waitq)) + return 0; + list_for_each_entry(gp, &dp->g_groups, c_list) + if (waitqueue_active(&gp->c_waitq)) + return 0; + return 1; +} + +static void suspend_ioband_device(struct ioband_device *dp, + unsigned long flags, int wait_completion) +{ + struct ioband_group *gp; + + /* block incoming bios */ + set_device_suspended(dp); + + /* wake up all blocked processes and go down all ioband groups */ + wake_up_all(&dp->g_waitq); + list_for_each_entry(gp, &dp->g_groups, c_list) { + if (!is_group_down(gp)) { + set_group_down(gp); + set_group_need_up(gp); + } + wake_up_all(&gp->c_waitq); + } + + /* flush the already mapped bios */ + spin_unlock_irqrestore(&dp->g_lock, flags); + queue_delayed_work(dp->g_ioband_wq, &dp->g_conductor, 0); + flush_workqueue(dp->g_ioband_wq); + + /* wait for all processes to wake up and bios to release */ + spin_lock_irqsave(&dp->g_lock, flags); + wait_event_lock_irq(dp->g_waitq_flush, + is_ioband_device_flushed(dp, wait_completion), + dp->g_lock, do_nothing()); +} + +static void resume_ioband_device(struct ioband_device *dp) +{ + struct ioband_group *gp; + + /* go up ioband groups */ + list_for_each_entry(gp, &dp->g_groups, c_list) { + if (group_need_up(gp)) { + clear_group_need_up(gp); + clear_group_down(gp); + } + } + + /* accept incoming bios */ + wake_up_all(&dp->g_waitq_suspend); + clear_device_suspended(dp); +} + +static struct ioband_group *ioband_group_find( + struct ioband_group *head, int id) +{ + struct rb_node *node = head->c_group_root.rb_node; + + while (node) { + struct ioband_group *p = + container_of(node, struct ioband_group, c_group_node); + + if (p->c_id == id || id == IOBAND_ID_ANY) + return p; + node = (id < p->c_id) ? node->rb_left : node->rb_right; + } + return NULL; +} + +static void ioband_group_add_node(struct rb_root *root, + struct ioband_group *gp) +{ + struct rb_node **new = &root->rb_node, *parent = NULL; + struct ioband_group *p; + + while (*new) { + p = container_of(*new, struct ioband_group, c_group_node); + parent = *new; + new = (gp->c_id < p->c_id) ? + &(*new)->rb_left : &(*new)->rb_right; + } + + rb_link_node(&gp->c_group_node, parent, new); + rb_insert_color(&gp->c_group_node, root); +} + +static int ioband_group_init(struct ioband_group *gp, + struct ioband_group *head, struct ioband_device *dp, int id, char *param) +{ + unsigned long flags; + int r; + + INIT_LIST_HEAD(&gp->c_list); + bio_list_init(&gp->c_blocked_bios); + bio_list_init(&gp->c_prio_bios); + gp->c_id = id; /* should be verified */ + gp->c_blocked = 0; + gp->c_prio_blocked = 0; + memset(gp->c_stat, 0, sizeof(gp->c_stat)); + init_waitqueue_head(&gp->c_waitq); + gp->c_flags = 0; + gp->c_group_root = RB_ROOT; + gp->c_banddev = dp; + + spin_lock_irqsave(&dp->g_lock, flags); + if (head && ioband_group_find(head, id)) { + spin_unlock_irqrestore(&dp->g_lock, flags); + DMWARN("ioband_group: id=%d already exists.", id); + return -EEXIST; + } + + list_add_tail(&gp->c_list, &dp->g_groups); + + r = dp->g_group_ctr(gp, param); + if (r) { + list_del(&gp->c_list); + spin_unlock_irqrestore(&dp->g_lock, flags); + return r; + } + + if (head) { + ioband_group_add_node(&head->c_group_root, gp); + gp->c_dev = head->c_dev; + gp->c_target = head->c_target; + } + + spin_unlock_irqrestore(&dp->g_lock, flags); + + return 0; +} + +static void ioband_group_release(struct ioband_group *head, + struct ioband_group *gp) +{ + struct ioband_device *dp = gp->c_banddev; + + list_del(&gp->c_list); + if (head) + rb_erase(&gp->c_group_node, &head->c_group_root); + dp->g_group_dtr(gp); + kfree(gp); +} + +static void ioband_group_destroy_all(struct ioband_group *gp) +{ + struct ioband_device *dp = gp->c_banddev; + struct ioband_group *group; + unsigned long flags; + + spin_lock_irqsave(&dp->g_lock, flags); + while ((group = ioband_group_find(gp, IOBAND_ID_ANY))) + ioband_group_release(gp, group); + ioband_group_release(NULL, gp); + spin_unlock_irqrestore(&dp->g_lock, flags); +} + +static void ioband_group_stop_all(struct ioband_group *head, int suspend) +{ + struct ioband_device *dp = head->c_banddev; + struct ioband_group *p; + struct rb_node *node; + unsigned long flags; + + spin_lock_irqsave(&dp->g_lock, flags); + for (node = rb_first(&head->c_group_root); node; node = rb_next(node)) { + p = rb_entry(node, struct ioband_group, c_group_node); + set_group_down(p); + if (suspend) { + set_group_suspended(p); + dprintk(KERN_ERR "ioband suspend: gp(%p)\n", p); + } + } + set_group_down(head); + if (suspend) { + set_group_suspended(head); + dprintk(KERN_ERR "ioband suspend: gp(%p)\n", head); + } + spin_unlock_irqrestore(&dp->g_lock, flags); + queue_delayed_work(dp->g_ioband_wq, &dp->g_conductor, 0); + flush_workqueue(dp->g_ioband_wq); +} + +static void ioband_group_resume_all(struct ioband_group *head) +{ + struct ioband_device *dp = head->c_banddev; + struct ioband_group *p; + struct rb_node *node; + unsigned long flags; + + spin_lock_irqsave(&dp->g_lock, flags); + for (node = rb_first(&head->c_group_root); node; + node = rb_next(node)) { + p = rb_entry(node, struct ioband_group, c_group_node); + clear_group_down(p); + clear_group_suspended(p); + dprintk(KERN_ERR "ioband resume: gp(%p)\n", p); + } + clear_group_down(head); + clear_group_suspended(head); + dprintk(KERN_ERR "ioband resume: gp(%p)\n", head); + spin_unlock_irqrestore(&dp->g_lock, flags); +} + +static int split_string(char *s, long *id, char **v) +{ + char *p, *q; + int r = 0; + + *id = IOBAND_ID_ANY; + p = strsep(&s, POLICY_PARAM_DELIM); + q = strsep(&s, POLICY_PARAM_DELIM); + if (!q) { + *v = p; + } else { + r = strict_strtol(p, 0, id); + *v = q; + } + return r; +} + +/* + * Create a new band device: + * parameters: <device> <device-group-id> <io_throttle> <io_limit> + * <type> <policy> <policy-param...> <group-id:group-param...> + */ +static int ioband_ctr(struct dm_target *ti, unsigned int argc, char **argv) +{ + struct ioband_group *gp; + struct ioband_device *dp; + struct dm_dev *dev; + int io_throttle; + int io_limit; + int i, r, start; + long val, id; + char *param; + + if (argc < POLICY_PARAM_START) { + ti->error = "Requires " __stringify(POLICY_PARAM_START) + " or more arguments"; + return -EINVAL; + } + + if (strlen(argv[1]) > IOBAND_NAME_MAX) { + ti->error = "Ioband device name is too long"; + return -EINVAL; + } + dprintk(KERN_ERR "ioband_ctr ioband device name:%s\n", argv[1]); + + r = strict_strtol(argv[2], 0, &val); + if (r || val < 0) { + ti->error = "Invalid io_throttle"; + return -EINVAL; + } + io_throttle = (val == 0) ? DEFAULT_IO_THROTTLE : val; + + r = strict_strtol(argv[3], 0, &val); + if (r || val < 0) { + ti->error = "Invalid io_limit"; + return -EINVAL; + } + io_limit = val; + + r = dm_get_device(ti, argv[0], 0, ti->len, + dm_table_get_mode(ti->table), &dev); + if (r) { + ti->error = "Device lookup failed"; + return r; + } + + if (io_limit == 0) { + struct request_queue *q; + + q = bdev_get_queue(dev->bdev); + if (!q) { + ti->error = "Can't get queue size"; + r = -ENXIO; + goto release_dm_device; + } + dprintk(KERN_ERR "ioband_ctr nr_requests:%lu\n", + q->nr_requests); + io_limit = q->nr_requests; + } + + if (io_limit < io_throttle) + io_limit = io_throttle; + dprintk(KERN_ERR "ioband_ctr io_throttle:%d io_limit:%d\n", + io_throttle, io_limit); + + dp = alloc_ioband_device(argv[1], io_throttle, io_limit); + if (!dp) { + ti->error = "Cannot create ioband device"; + r = -EINVAL; + goto release_dm_device; + } + + mutex_lock(&dp->g_lock_device); + r = policy_init(dp, argv[POLICY_PARAM_START - 1], + argc - POLICY_PARAM_START, &argv[POLICY_PARAM_START]); + if (r) { + ti->error = "Invalid policy parameter"; + goto release_ioband_device; + } + + gp = kzalloc(sizeof(struct ioband_group), GFP_KERNEL); + if (!gp) { + ti->error = "Cannot allocate memory for ioband group"; + r = -ENOMEM; + goto release_ioband_device; + } + + ti->private = gp; + gp->c_target = ti; + gp->c_dev = dev; + + /* Find a default group parameter */ + for (start = POLICY_PARAM_START; start < argc; start++) + if (argv[start][0] == ':') + break; + param = (start < argc) ? &argv[start][1] : NULL; + + /* Create a default ioband group */ + r = ioband_group_init(gp, NULL, dp, IOBAND_ID_ANY, param); + if (r) { + kfree(gp); + ti->error = "Cannot create default ioband group"; + goto release_ioband_device; + } + + r = ioband_group_type_select(gp, argv[4]); + if (r) { + ti->error = "Cannot set ioband group type"; + goto release_ioband_group; + } + + /* Create sub ioband groups */ + for (i = start + 1; i < argc; i++) { + r = split_string(argv[i], &id, ¶m); + if (r) { + ti->error = "Invalid ioband group parameter"; + goto release_ioband_group; + } + r = ioband_group_attach(gp, id, param); + if (r) { + ti->error = "Cannot create ioband group"; + goto release_ioband_group; + } + } + mutex_unlock(&dp->g_lock_device); + return 0; + +release_ioband_group: + ioband_group_destroy_all(gp); +release_ioband_device: + mutex_unlock(&dp->g_lock_device); + release_ioband_device(dp); +release_dm_device: + dm_put_device(ti, dev); + return r; +} + +static void ioband_dtr(struct dm_target *ti) +{ + struct ioband_group *gp = ti->private; + struct ioband_device *dp = gp->c_banddev; + + mutex_lock(&dp->g_lock_device); + ioband_group_stop_all(gp, 0); + cancel_delayed_work_sync(&dp->g_conductor); + dm_put_device(ti, gp->c_dev); + ioband_group_destroy_all(gp); + mutex_unlock(&dp->g_lock_device); + release_ioband_device(dp); +} + +static void ioband_hold_bio(struct ioband_group *gp, struct bio *bio) +{ + /* Todo: The list should be split into a read list and a write list */ + bio_list_add(&gp->c_blocked_bios, bio); +} + +static struct bio *ioband_pop_bio(struct ioband_group *gp) +{ + return bio_list_pop(&gp->c_blocked_bios); +} + +static int is_urgent_bio(struct bio *bio) +{ + struct page *page = bio_iovec_idx(bio, 0)->bv_page; + /* + * ToDo: A new flag should be added to struct bio, which indicates + * it contains urgent I/O requests. + */ + if (!PageReclaim(page)) + return 0; + if (PageSwapCache(page)) + return 2; + return 1; +} + +static inline int device_should_block(struct ioband_group *gp) +{ + struct ioband_device *dp = gp->c_banddev; + + if (is_group_down(gp)) + return 0; + if (is_device_blocked(dp)) + return 1; + if (dp->g_blocked >= dp->g_io_limit[0] + dp->g_io_limit[1]) { + set_device_blocked(dp); + return 1; + } + return 0; +} + +static inline int group_should_block(struct ioband_group *gp) +{ + struct ioband_device *dp = gp->c_banddev; + + if (is_group_down(gp)) + return 0; + if (is_group_blocked(gp)) + return 1; + if (dp->g_should_block(gp)) { + set_group_blocked(gp); + return 1; + } + return 0; +} + +static void prevent_burst_bios(struct ioband_group *gp, struct bio *bio) +{ + struct ioband_device *dp = gp->c_banddev; + + if (current->flags & PF_KTHREAD || is_urgent_bio(bio)) { + /* + * Kernel threads shouldn't be blocked easily since each of + * them may handle BIOs for several groups on several + * partitions. + */ + wait_event_lock_irq(dp->g_waitq, !device_should_block(gp), + dp->g_lock, do_nothing()); + } else { + wait_event_lock_irq(gp->c_waitq, !group_should_block(gp), + dp->g_lock, do_nothing()); + } +} + +static inline int should_pushback_bio(struct ioband_group *gp) +{ + return is_group_suspended(gp) && dm_noflush_suspending(gp->c_target); +} + +static inline int prepare_to_issue(struct ioband_group *gp, struct bio *bio) +{ + struct ioband_device *dp = gp->c_banddev; + + dp->g_issued[bio_data_dir(bio)]++; + return dp->g_prepare_bio(gp, bio, 0); +} + +static inline int room_for_bio(struct ioband_device *dp) +{ + return dp->g_issued[0] < dp->g_io_limit[0] + || dp->g_issued[1] < dp->g_io_limit[1]; +} + +static void hold_bio(struct ioband_group *gp, struct bio *bio) +{ + struct ioband_device *dp = gp->c_banddev; + + dp->g_blocked++; + if (is_urgent_bio(bio)) { + /* + * ToDo: + * When barrier mode is supported, write bios sharing the same + * file system with the currnt one would be all moved + * to g_urgent_bios list. + * You don't have to care about barrier handling if the bio + * is for swapping. + */ + dp->g_prepare_bio(gp, bio, IOBAND_URGENT); + bio_list_add(&dp->g_urgent_bios, bio); + } else { + gp->c_blocked++; + dp->g_hold_bio(gp, bio); + } +} + +static inline int room_for_bio_rw(struct ioband_device *dp, int direct) +{ + return dp->g_issued[direct] < dp->g_io_limit[direct]; +} + +static void push_prio_bio(struct ioband_group *gp, struct bio *bio, int direct) +{ + if (bio_list_empty(&gp->c_prio_bios)) + set_prio_queue(gp, direct); + bio_list_add(&gp->c_prio_bios, bio); + gp->c_prio_blocked++; +} + +static struct bio *pop_prio_bio(struct ioband_group *gp) +{ + struct bio *bio = bio_list_pop(&gp->c_prio_bios); + + if (bio_list_empty(&gp->c_prio_bios)) + clear_prio_queue(gp); + + if (bio) + gp->c_prio_blocked--; + return bio; +} + +static int make_issue_list(struct ioband_group *gp, struct bio *bio, + struct bio_list *issue_list, struct bio_list *pushback_list) +{ + struct ioband_device *dp = gp->c_banddev; + + dp->g_blocked--; + gp->c_blocked--; + if (!gp->c_blocked && is_group_blocked(gp)) { + clear_group_blocked(gp); + wake_up_all(&gp->c_waitq); + } + if (should_pushback_bio(gp)) + bio_list_add(pushback_list, bio); + else { + int rw = bio_data_dir(bio); + + gp->c_stat[rw].deferred++; + gp->c_stat[rw].sectors += bio_sectors(bio); + bio_list_add(issue_list, bio); + } + return prepare_to_issue(gp, bio); +} + +static void release_urgent_bios(struct ioband_device *dp, + struct bio_list *issue_list, struct bio_list *pushback_list) +{ + struct bio *bio; + + if (bio_list_empty(&dp->g_urgent_bios)) + return; + while (room_for_bio_rw(dp, 1)) { + bio = bio_list_pop(&dp->g_urgent_bios); + if (!bio) + return; + dp->g_blocked--; + dp->g_issued[bio_data_dir(bio)]++; + bio_list_add(issue_list, bio); + } +} + +static int release_prio_bios(struct ioband_group *gp, + struct bio_list *issue_list, struct bio_list *pushback_list) +{ + struct ioband_device *dp = gp->c_banddev; + struct bio *bio; + int direct; + int ret; + + if (bio_list_empty(&gp->c_prio_bios)) + return R_OK; + direct = prio_queue_direct(gp); + while (gp->c_prio_blocked) { + if (!dp->g_can_submit(gp)) + return R_BLOCK; + if (!room_for_bio_rw(dp, direct)) + return R_OK; + bio = pop_prio_bio(gp); + if (!bio) + return R_OK; + ret = make_issue_list(gp, bio, issue_list, pushback_list); + if (ret) + return ret; + } + return R_OK; +} + +static int release_norm_bios(struct ioband_group *gp, + struct bio_list *issue_list, struct bio_list *pushback_list) +{ + struct ioband_device *dp = gp->c_banddev; + struct bio *bio; + int direct; + int ret; + + while (gp->c_blocked - gp->c_prio_blocked) { + if (!dp->g_can_submit(gp)) + return R_BLOCK; + if (!room_for_bio(dp)) + return R_OK; + bio = dp->g_pop_bio(gp); + if (!bio) + return R_OK; + + direct = bio_data_dir(bio); + if (!room_for_bio_rw(dp, direct)) { + push_prio_bio(gp, bio, direct); + continue; + } + ret = make_issue_list(gp, bio, issue_list, pushback_list); + if (ret) + return ret; + } + return R_OK; +} + +static inline int release_bios(struct ioband_group *gp, + struct bio_list *issue_list, struct bio_list *pushback_list) +{ + int ret = release_prio_bios(gp, issue_list, pushback_list); + if (ret) + return ret; + return release_norm_bios(gp, issue_list, pushback_list); +} + +static struct ioband_group *ioband_group_get(struct ioband_group *head, + struct bio *bio) +{ + struct ioband_group *gp; + + if (!head->c_type->t_getid) + return head; + + gp = ioband_group_find(head, head->c_type->t_getid(bio)); + + if (!gp) + gp = head; + return gp; +} + +/* + * Start to control the bandwidth once the number of uncompleted BIOs + * exceeds the value of "io_throttle". + */ +static int ioband_map(struct dm_target *ti, struct bio *bio, + union map_info *map_context) +{ + struct ioband_group *gp = ti->private; + struct ioband_device *dp = gp->c_banddev; + unsigned long flags; + int rw; + + spin_lock_irqsave(&dp->g_lock, flags); + + /* + * The device is suspended while some of the ioband device + * configurations are being changed. + */ + if (is_device_suspended(dp)) + wait_event_lock_irq(dp->g_waitq_suspend, + !is_device_suspended(dp), dp->g_lock, do_nothing()); + + gp = ioband_group_get(gp, bio); + prevent_burst_bios(gp, bio); + if (should_pushback_bio(gp)) { + spin_unlock_irqrestore(&dp->g_lock, flags); + return DM_MAPIO_REQUEUE; + } + + bio->bi_bdev = gp->c_dev->bdev; + bio->bi_sector -= ti->begin; + rw = bio_data_dir(bio); + + if (!gp->c_blocked && room_for_bio_rw(dp, rw)) { + if (dp->g_can_submit(gp)) { + prepare_to_issue(gp, bio); + gp->c_stat[rw].immediate++; + gp->c_stat[rw].sectors += bio_sectors(bio); + spin_unlock_irqrestore(&dp->g_lock, flags); + return DM_MAPIO_REMAPPED; + } else if (!dp->g_blocked + && dp->g_issued[0] + dp->g_issued[1] == 0) { + dprintk(KERN_ERR "ioband_map: token expired " + "gp:%p bio:%p\n", gp, bio); + queue_delayed_work(dp->g_ioband_wq, + &dp->g_conductor, 1); + } + } + hold_bio(gp, bio); + spin_unlock_irqrestore(&dp->g_lock, flags); + + return DM_MAPIO_SUBMITTED; +} + +/* + * Select the best group to resubmit its BIOs. + */ +static struct ioband_group *choose_best_group(struct ioband_device *dp) +{ + struct ioband_group *gp; + struct ioband_group *best = NULL; + int highest = 0; + int pri; + + /* Todo: The algorithm should be optimized. + * It would be better to use rbtree. + */ + list_for_each_entry(gp, &dp->g_groups, c_list) { + if (!gp->c_blocked || !room_for_bio(dp)) + continue; + if (gp->c_blocked == gp->c_prio_blocked + && !room_for_bio_rw(dp, prio_queue_direct(gp))) { + continue; + } + pri = dp->g_can_submit(gp); + if (pri > highest) { + highest = pri; + best = gp; + } + } + + return best; +} + +/* + * This function is called right after it becomes able to resubmit BIOs. + * It selects the best BIOs and passes them to the underlying layer. + */ +static void ioband_conduct(struct work_struct *work) +{ + struct ioband_device *dp = + container_of(work, struct ioband_device, g_conductor.work); + struct ioband_group *gp = NULL; + struct bio *bio; + unsigned long flags; + struct bio_list issue_list, pushback_list; + + bio_list_init(&issue_list); + bio_list_init(&pushback_list); + + spin_lock_irqsave(&dp->g_lock, flags); + release_urgent_bios(dp, &issue_list, &pushback_list); + if (dp->g_blocked) { + gp = choose_best_group(dp); + if (gp && release_bios(gp, &issue_list, &pushback_list) + == R_YIELD) + queue_delayed_work(dp->g_ioband_wq, + &dp->g_conductor, 0); + } + + if (is_device_blocked(dp) + && dp->g_blocked < dp->g_io_limit[0]+dp->g_io_limit[1]) { + clear_device_blocked(dp); + wake_up_all(&dp->g_waitq); + } + + if (dp->g_blocked && room_for_bio_rw(dp, 0) && room_for_bio_rw(dp, 1) && + bio_list_empty(&issue_list) && bio_list_empty(&pushback_list) && + dp->g_restart_bios(dp)) { + dprintk(KERN_ERR "ioband_conduct: token expired dp:%p " + "issued(%d,%d) g_blocked(%d)\n", dp, + dp->g_issued[0], dp->g_issued[1], dp->g_blocked); + queue_delayed_work(dp->g_ioband_wq, &dp->g_conductor, 0); + } + + + spin_unlock_irqrestore(&dp->g_lock, flags); + + while ((bio = bio_list_pop(&issue_list))) + generic_make_request(bio); + while ((bio = bio_list_pop(&pushback_list))) + bio_endio(bio, -EIO); +} + +static int ioband_end_io(struct dm_target *ti, struct bio *bio, + int error, union map_info *map_context) +{ + struct ioband_group *gp = ti->private; + struct ioband_device *dp = gp->c_banddev; + unsigned long flags; + int r = error; + + /* + * XXX: A new error code for device mapper devices should be used + * rather than EIO. + */ + if (error == -EIO && should_pushback_bio(gp)) { + /* This ioband device is suspending */ + r = DM_ENDIO_REQUEUE; + } + /* + * Todo: The algorithm should be optimized to eliminate the spinlock. + */ + spin_lock_irqsave(&dp->g_lock, flags); + dp->g_issued[bio_data_dir(bio)]--; + + /* + * Todo: It would be better to introduce high/low water marks here + * not to kick the workqueues so often. + */ + if (dp->g_blocked) + queue_delayed_work(dp->g_ioband_wq, &dp->g_conductor, 0); + else if (is_device_suspended(dp) + && dp->g_issued[0] + dp->g_issued[1] == 0) + wake_up_all(&dp->g_waitq_flush); + spin_unlock_irqrestore(&dp->g_lock, flags); + return r; +} + +static void ioband_presuspend(struct dm_target *ti) +{ + struct ioband_group *gp = ti->private; + struct ioband_device *dp = gp->c_banddev; + + mutex_lock(&dp->g_lock_device); + ioband_group_stop_all(gp, 1); + mutex_unlock(&dp->g_lock_device); +} + +static void ioband_resume(struct dm_target *ti) +{ + struct ioband_group *gp = ti->private; + struct ioband_device *dp = gp->c_banddev; + + mutex_lock(&dp->g_lock_device); + ioband_group_resume_all(gp); + mutex_unlock(&dp->g_lock_device); +} + + +static void ioband_group_status(struct ioband_group *gp, int *szp, + char *result, unsigned int maxlen) +{ + struct ioband_group_stat *stat; + int i, sz = *szp; /* used in DMEMIT() */ + + DMEMIT(" %d", gp->c_id); + for (i = 0; i < 2; i++) { + stat = &gp->c_stat[i]; + DMEMIT(" %lu %lu %lu", + stat->immediate + stat->deferred, stat->deferred, + stat->sectors); + } + *szp = sz; +} + +static int ioband_status(struct dm_target *ti, status_type_t type, + char *result, unsigned int maxlen) +{ + struct ioband_group *gp = ti->private, *p; + struct ioband_device *dp = gp->c_banddev; + struct rb_node *node; + int sz = 0; /* used in DMEMIT() */ + unsigned long flags; + + mutex_lock(&dp->g_lock_device); + + switch (type) { + case STATUSTYPE_INFO: + spin_lock_irqsave(&dp->g_lock, flags); + DMEMIT("%s", dp->g_name); + ioband_group_status(gp, &sz, result, maxlen); + for (node = rb_first(&gp->c_group_root); node; + node = rb_next(node)) { + p = rb_entry(node, struct ioband_group, c_group_node); + ioband_group_status(p, &sz, result, maxlen); + } + spin_unlock_irqrestore(&dp->g_lock, flags); + break; + + case STATUSTYPE_TABLE: + spin_lock_irqsave(&dp->g_lock, flags); + DMEMIT("%s %s %d %d %s %s", + gp->c_dev->name, dp->g_name, + dp->g_io_throttle, dp->g_io_limit[0], + gp->c_type->t_name, dp->g_policy->p_name); + dp->g_show(gp, &sz, result, maxlen); + spin_unlock_irqrestore(&dp->g_lock, flags); + break; + } + + mutex_unlock(&dp->g_lock_device); + return 0; +} + +static int ioband_group_type_select(struct ioband_group *gp, char *name) +{ + struct ioband_device *dp = gp->c_banddev; + struct group_type *t; + unsigned long flags; + + for (t = dm_ioband_group_type; (t->t_name); t++) { + if (!strcmp(name, t->t_name)) + break; + } + if (!t->t_name) { + DMWARN("ioband type select: %s isn't supported.", name); + return -EINVAL; + } + spin_lock_irqsave(&dp->g_lock, flags); + if (!RB_EMPTY_ROOT(&gp->c_group_root)) { + spin_unlock_irqrestore(&dp->g_lock, flags); + return -EBUSY; + } + gp->c_type = t; + spin_unlock_irqrestore(&dp->g_lock, flags); + + return 0; +} + +static int ioband_set_param(struct ioband_group *gp, char *cmd, char *value) +{ + struct ioband_device *dp = gp->c_banddev; + char *val_str; + long id; + unsigned long flags; + int r; + + r = split_string(value, &id, &val_str); + if (r) + return r; + + spin_lock_irqsave(&dp->g_lock, flags); + if (id != IOBAND_ID_ANY) { + gp = ioband_group_find(gp, id); + if (!gp) { + spin_unlock_irqrestore(&dp->g_lock, flags); + DMWARN("ioband_set_param: id=%ld not found.", id); + return -EINVAL; + } + } + r = dp->g_set_param(gp, cmd, val_str); + spin_unlock_irqrestore(&dp->g_lock, flags); + return r; +} + +static int ioband_group_attach(struct ioband_group *gp, int id, char *param) +{ + struct ioband_device *dp = gp->c_banddev; + struct ioband_group *sub_gp; + int r; + + if (id < 0) { + DMWARN("ioband_group_attach: invalid id:%d", id); + return -EINVAL; + } + if (!gp->c_type->t_getid) { + DMWARN("ioband_group_attach: " + "no ioband group type is specified"); + return -EINVAL; + } + + sub_gp = kzalloc(sizeof(struct ioband_group), GFP_KERNEL); + if (!sub_gp) + return -ENOMEM; + + r = ioband_group_init(sub_gp, gp, dp, id, param); + if (r < 0) { + kfree(sub_gp); + return r; + } + return 0; +} + +static int ioband_group_detach(struct ioband_group *gp, int id) +{ + struct ioband_device *dp = gp->c_banddev; + struct ioband_group *sub_gp; + unsigned long flags; + + if (id < 0) { + DMWARN("ioband_group_detach: invalid id:%d", id); + return -EINVAL; + } + spin_lock_irqsave(&dp->g_lock, flags); + sub_gp = ioband_group_find(gp, id); + if (!sub_gp) { + spin_unlock_irqrestore(&dp->g_lock, flags); + DMWARN("ioband_group_detach: invalid id:%d", id); + return -EINVAL; + } + + /* + * Todo: Calling suspend_ioband_device() before releasing the + * ioband group has a large overhead. Need improvement. + */ + suspend_ioband_device(dp, flags, 0); + ioband_group_release(gp, sub_gp); + resume_ioband_device(dp); + spin_unlock_irqrestore(&dp->g_lock, flags); + return 0; +} + +/* + * Message parameters: + * "policy" <name> + * ex) + * "policy" "weight" + * "type" "none"|"pid"|"pgrp"|"node"|"cpuset"|"cgroup"|"user"|"gid" + * "io_throttle" <value> + * "io_limit" <value> + * "attach" <group id> + * "detach" <group id> + * "any-command" <group id>:<value> + * ex) + * "weight" 0:<value> + * "token" 24:<value> + */ +static int __ioband_message(struct dm_target *ti, + unsigned int argc, char **argv) +{ + struct ioband_group *gp = ti->private, *p; + struct ioband_device *dp = gp->c_banddev; + struct rb_node *node; + long val; + int r = 0; + unsigned long flags; + + if (argc == 1 && !strcmp(argv[0], "reset")) { + spin_lock_irqsave(&dp->g_lock, flags); + memset(gp->c_stat, 0, sizeof(gp->c_stat)); + for (node = rb_first(&gp->c_group_root); node; + node = rb_next(node)) { + p = rb_entry(node, struct ioband_group, c_group_node); + memset(p->c_stat, 0, sizeof(p->c_stat)); + } + spin_unlock_irqrestore(&dp->g_lock, flags); + return 0; + } + + if (argc != 2) { + DMWARN("Unrecognised band message received."); + return -EINVAL; + } + if (!strcmp(argv[0], "debug")) { + r = strict_strtol(argv[1], 0, &val); + if (r || val < 0) + return -EINVAL; + ioband_debug = val; + return 0; + } else if (!strcmp(argv[0], "io_throttle")) { + r = strict_strtol(argv[1], 0, &val); + spin_lock_irqsave(&dp->g_lock, flags); + if (r || val < 0 || + val > dp->g_io_limit[0] || val > dp->g_io_limit[1]) { + spin_unlock_irqrestore(&dp->g_lock, flags); + return -EINVAL; + } + dp->g_io_throttle = (val == 0) ? DEFAULT_IO_THROTTLE : val; + spin_unlock_irqrestore(&dp->g_lock, flags); + ioband_set_param(gp, argv[0], argv[1]); + return 0; + } else if (!strcmp(argv[0], "io_limit")) { + r = strict_strtol(argv[1], 0, &val); + if (r || val < 0) + return -EINVAL; + spin_lock_irqsave(&dp->g_lock, flags); + if (val == 0) { + struct request_queue *q; + + q = bdev_get_queue(gp->c_dev->bdev); + if (!q) { + spin_unlock_irqrestore(&dp->g_lock, flags); + return -ENXIO; + } + val = q->nr_requests; + } + if (val < dp->g_io_throttle) { + spin_unlock_irqrestore(&dp->g_lock, flags); + return -EINVAL; + } + dp->g_io_limit[0] = dp->g_io_limit[1] = val; + spin_unlock_irqrestore(&dp->g_lock, flags); + ioband_set_param(gp, argv[0], argv[1]); + return 0; + } else if (!strcmp(argv[0], "type")) { + return ioband_group_type_select(gp, argv[1]); + } else if (!strcmp(argv[0], "attach")) { + r = strict_strtol(argv[1], 0, &val); + if (r) + return r; + return ioband_group_attach(gp, val, NULL); + } else if (!strcmp(argv[0], "detach")) { + r = strict_strtol(argv[1], 0, &val); + if (r) + return r; + return ioband_group_detach(gp, val); + } else if (!strcmp(argv[0], "policy")) { + r = policy_init(dp, argv[1], 0, &argv[2]); + return r; + } else { + /* message anycommand <group-id>:<value> */ + r = ioband_set_param(gp, argv[0], argv[1]); + if (r < 0) + DMWARN("Unrecognised band message received."); + return r; + } + return 0; +} + +static int ioband_message(struct dm_target *ti, unsigned int argc, char **argv) +{ + struct ioband_group *gp = ti->private; + struct ioband_device *dp = gp->c_banddev; + int r; + + mutex_lock(&dp->g_lock_device); + r = __ioband_message(ti, argc, argv); + mutex_unlock(&dp->g_lock_device); + return r; +} + +static int ioband_merge(struct dm_target *ti, struct bvec_merge_data *bvm, + struct bio_vec *biovec, int max_size) +{ + struct ioband_group *gp = ti->private; + struct request_queue *q = bdev_get_queue(gp->c_dev->bdev); + + if (!q->merge_bvec_fn) + return max_size; + + bvm->bi_bdev = gp->c_dev->bdev; + bvm->bi_sector -= ti->begin; + + return min(max_size, q->merge_bvec_fn(q, bvm, biovec)); +} + +static struct target_type ioband_target = { + .name = "ioband", + .module = THIS_MODULE, + .version = {1, 9, 0}, + .ctr = ioband_ctr, + .dtr = ioband_dtr, + .map = ioband_map, + .end_io = ioband_end_io, + .presuspend = ioband_presuspend, + .resume = ioband_resume, + .status = ioband_status, + .message = ioband_message, + .merge = ioband_merge, +}; + +static int __init dm_ioband_init(void) +{ + int r; + + r = dm_register_target(&ioband_target); + if (r < 0) { + DMERR("register failed %d", r); + return r; + } + return r; +} + +static void __exit dm_ioband_exit(void) +{ + int r; + + r = dm_unregister_target(&ioband_target); + if (r < 0) + DMERR("unregister failed %d", r); +} + +module_init(dm_ioband_init); +module_exit(dm_ioband_exit); + +MODULE_DESCRIPTION(DM_NAME " I/O bandwidth control"); +MODULE_AUTHOR("Hirokazu Takahashi <taka@valinux.co.jp>, " + "Ryo Tsuruta <ryov@valinux.co.jp"); +MODULE_LICENSE("GPL"); diff -uprN linux-2.6.28-rc2-mm1.orig/drivers/md/dm-ioband-policy.c linux-2.6.28-rc2-mm1/drivers/md/dm-ioband-policy.c --- linux-2.6.28-rc2-mm1.orig/drivers/md/dm-ioband-policy.c 1970-01-01 09:00:00.000000000 +0900 +++ linux-2.6.28-rc2-mm1/drivers/md/dm-ioband-policy.c 2008-11-13 09:37:55.000000000 +0900 @@ -0,0 +1,458 @@ +/* + * Copyright (C) 2008 VA Linux Systems Japan K.K. + * + * I/O bandwidth control + * + * This file is released under the GPL. + */ +#include <linux/bio.h> +#include <linux/workqueue.h> +#include <linux/rbtree.h> +#include "dm.h" +#include "dm-bio-list.h" +#include "dm-ioband.h" + +/* + * The following functions determine when and which BIOs should + * be submitted to control the I/O flow. + * It is possible to add a new BIO scheduling policy with it. + */ + + +/* + * Functions for weight balancing policy based on the number of I/Os. + */ +#define DEFAULT_WEIGHT 100 +#define DEFAULT_TOKENPOOL 2048 +#define DEFAULT_BUCKET 2 +#define IOBAND_IOPRIO_BASE 100 +#define TOKEN_BATCH_UNIT 20 +#define PROCEED_THRESHOLD 8 +#define LOCAL_ACTIVE_RATIO 8 +#define GLOBAL_ACTIVE_RATIO 16 +#define OVERCOMMIT_RATE 4 + +/* + * Calculate the effective number of tokens this group has. + */ +static int get_token(struct ioband_group *gp) +{ + struct ioband_device *dp = gp->c_banddev; + int token = gp->c_token; + int allowance = dp->g_epoch - gp->c_my_epoch; + + if (allowance) { + if (allowance > dp->g_carryover) + allowance = dp->g_carryover; + token += gp->c_token_initial * allowance; + } + if (is_group_down(gp)) + token += gp->c_token_initial * dp->g_carryover * 2; + + return token; +} + +/* + * Calculate the priority of a given group. + */ +static int iopriority(struct ioband_group *gp) +{ + return get_token(gp) * IOBAND_IOPRIO_BASE / gp->c_token_initial + 1; +} + +/* + * This function is called when all the active group on the same ioband + * device has used up their tokens. It makes a new global epoch so that + * all groups on this device will get freshly assigned tokens. + */ +static int make_global_epoch(struct ioband_device *dp) +{ + struct ioband_group *gp = dp->g_dominant; + + /* + * Don't make a new epoch if the dominant group still has a lot of + * tokens, except when the I/O load is low. + */ + if (gp) { + int iopri = iopriority(gp); + if (iopri * PROCEED_THRESHOLD > IOBAND_IOPRIO_BASE && + dp->g_issued[0] + dp->g_issued[1] >= dp->g_io_throttle) + return 0; + } + + dp->g_epoch++; + dprintk(KERN_ERR "make_epoch %d --> %d\n", + dp->g_epoch-1, dp->g_epoch); + + /* The leftover tokens will be used in the next epoch. */ + dp->g_token_extra = dp->g_token_left; + if (dp->g_token_extra < 0) + dp->g_token_extra = 0; + dp->g_token_left = dp->g_token_bucket; + + dp->g_expired = NULL; + dp->g_dominant = NULL; + + return 1; +} + +/* + * This function is called when this group has used up its own tokens. + * It will check whether it's possible to make a new epoch of this group. + */ +static inline int make_epoch(struct ioband_group *gp) +{ + struct ioband_device *dp = gp->c_banddev; + int allowance = dp->g_epoch - gp->c_my_epoch; + + if (!allowance) + return 0; + if (allowance > dp->g_carryover) + allowance = dp->g_carryover; + gp->c_my_epoch = dp->g_epoch; + return allowance; +} + +/* + * Check whether this group has tokens to issue an I/O. Return 0 if it + * doesn't have any, otherwise return the priority of this group. + */ +static int is_token_left(struct ioband_group *gp) +{ + struct ioband_device *dp = gp->c_banddev; + int allowance; + int delta; + int extra; + + if (gp->c_token > 0) + return iopriority(gp); + + if (is_group_down(gp)) { + gp->c_token = gp->c_token_initial; + return iopriority(gp); + } + allowance = make_epoch(gp); + if (!allowance) + return 0; + /* + * If this group has the right to get tokens for several epochs, + * give all of them to the group here. + */ + delta = gp->c_token_initial * allowance; + dp->g_token_left -= delta; + /* + * Give some extra tokens to this group when there have left unused + * tokens on this ioband device from the previous epoch. + */ + extra = dp->g_token_extra * gp->c_token_initial / + (dp->g_token_bucket - dp->g_token_extra/2); + delta += extra; + gp->c_token += delta; + gp->c_consumed = 0; + + if (gp == dp->g_current) + dp->g_yield_mark += delta; + dprintk(KERN_ERR "refill token: " + "gp:%p token:%d->%d extra(%d) allowance(%d)\n", + gp, gp->c_token - delta, gp->c_token, extra, allowance); + if (gp->c_token > 0) + return iopriority(gp); + dprintk(KERN_ERR "refill token: yet empty gp:%p token:%d\n", + gp, gp->c_token); + return 0; +} + +/* + * Use tokens to issue an I/O. After the operation, the number of tokens left + * on this group may become negative value, which will be treated as debt. + */ +static int consume_token(struct ioband_group *gp, int count, int flag) +{ + struct ioband_device *dp = gp->c_banddev; + + if (gp->c_consumed * LOCAL_ACTIVE_RATIO < gp->c_token_initial && + gp->c_consumed * GLOBAL_ACTIVE_RATIO < dp->g_token_bucket) { + ; /* Do nothing unless this group is really active. */ + } else if (!dp->g_dominant || + get_token(gp) > get_token(dp->g_dominant)) { + /* + * Regard this group as the dominant group on this + * ioband device when it has larger number of tokens + * than those of the previous one. + */ + dp->g_dominant = gp; + } + if (dp->g_epoch == gp->c_my_epoch && + gp->c_token > 0 && gp->c_token - count <= 0) { + /* Remember the last group which used up its own tokens. */ + dp->g_expired = gp; + if (dp->g_dominant == gp) + dp->g_dominant = NULL; + } + + if (gp != dp->g_current) { + /* This group is the current already. */ + dp->g_current = gp; + dp->g_yield_mark = + gp->c_token - (TOKEN_BATCH_UNIT << dp->g_token_unit); + } + gp->c_token -= count; + gp->c_consumed += count; + if (gp->c_token <= dp->g_yield_mark && !(flag & IOBAND_URGENT)) { + /* + * Return-value 1 means that this policy requests dm-ioband + * to give a chance to another group to be selected since + * this group has already issued enough amount of I/Os. + */ + dp->g_current = NULL; + return R_YIELD; + } + /* + * Return-value 0 means that this policy allows dm-ioband to select + * this group to issue I/Os without a break. + */ + return R_OK; +} + +/* + * Consume one token on each I/O. + */ +static int prepare_token(struct ioband_group *gp, struct bio *bio, int flag) +{ + return consume_token(gp, 1, flag); +} + +/* + * Check if this group is able to receive a new bio. + */ +static int is_queue_full(struct ioband_group *gp) +{ + return gp->c_blocked >= gp->c_limit; +} + +static void set_weight(struct ioband_group *gp, int new) +{ + struct ioband_device *dp = gp->c_banddev; + struct ioband_group *p; + + dp->g_weight_total += (new - gp->c_weight); + gp->c_weight = new; + + if (dp->g_weight_total == 0) { + list_for_each_entry(p, &dp->g_groups, c_list) + p->c_token = p->c_token_initial = p->c_limit = 1; + } else { + list_for_each_entry(p, &dp->g_groups, c_list) { + p->c_token = p->c_token_initial = + dp->g_token_bucket * p->c_weight / + dp->g_weight_total + 1; + p->c_limit = (dp->g_io_limit[0] + dp->g_io_limit[1]) * + p->c_weight / dp->g_weight_total / + OVERCOMMIT_RATE + 1; + } + } +} + +static void init_token_bucket(struct ioband_device *dp, + int token_bucket, int carryover) +{ + if (!token_bucket) + dp->g_token_bucket = ((dp->g_io_limit[0] + dp->g_io_limit[1]) * + DEFAULT_BUCKET) << dp->g_token_unit; + else + dp->g_token_bucket = token_bucket; + if (!carryover) + dp->g_carryover = (DEFAULT_TOKENPOOL << dp->g_token_unit) / + dp->g_token_bucket; + else + dp->g_carryover = carryover; + dp->g_token_left = 0; +} + +static int policy_weight_param(struct ioband_group *gp, char *cmd, char *value) +{ + struct ioband_device *dp = gp->c_banddev; + long val; + int r = 0, err; + + err = strict_strtol(value, 0, &val); + if (!strcmp(cmd, "weight")) { + if (!err && 0 < val && val <= SHORT_MAX) + set_weight(gp, val); + else + r = -EINVAL; + } else if (!strcmp(cmd, "token")) { + if (!err && val >= 0) { + init_token_bucket(dp, val, 0); + set_weight(gp, gp->c_weight); + dp->g_token_extra = 0; + } else + r = -EINVAL; + } else if (!strcmp(cmd, "carryover")) { + if (!err && val >= 0) { + init_token_bucket(dp, dp->g_token_bucket, val); + set_weight(gp, gp->c_weight); + dp->g_token_extra = 0; + } else + r = -EINVAL; + } else if (!strcmp(cmd, "io_limit")) { + init_token_bucket(dp, 0, 0); + set_weight(gp, gp->c_weight); + } else { + r = -EINVAL; + } + return r; +} + +static int policy_weight_ctr(struct ioband_group *gp, char *arg) +{ + struct ioband_device *dp = gp->c_banddev; + + if (!arg) + arg = __stringify(DEFAULT_WEIGHT); + gp->c_my_epoch = dp->g_epoch; + gp->c_weight = 0; + gp->c_consumed = 0; + return policy_weight_param(gp, "weight", arg); +} + +static void policy_weight_dtr(struct ioband_group *gp) +{ + struct ioband_device *dp = gp->c_banddev; + set_weight(gp, 0); + dp->g_dominant = NULL; + dp->g_expired = NULL; +} + +static void policy_weight_show(struct ioband_group *gp, int *szp, + char *result, unsigned int maxlen) +{ + struct ioband_group *p; + struct ioband_device *dp = gp->c_banddev; + struct rb_node *node; + int sz = *szp; /* used in DMEMIT() */ + + DMEMIT(" %d :%d", dp->g_token_bucket, gp->c_weight); + + for (node = rb_first(&gp->c_group_root); node; node = rb_next(node)) { + p = rb_entry(node, struct ioband_group, c_group_node); + DMEMIT(" %d:%d", p->c_id, p->c_weight); + } + *szp = sz; +} + +/* + * <Method> <description> + * g_can_submit : To determine whether a given group has the right to + * submit BIOs. The larger the return value the higher the + * priority to submit. Zero means it has no right. + * g_prepare_bio : Called right before submitting each BIO. + * g_restart_bios : Called if this ioband device has some BIOs blocked but none + * of them can be submitted now. This method has to + * reinitialize the data to restart to submit BIOs and return + * 0 or 1. + * The return value 0 means that it has become able to submit + * them now so that this ioband device will continue its work. + * The return value 1 means that it is still unable to submit + * them so that this device will stop its work. And this + * policy module has to reactivate the device when it gets + * to be able to submit BIOs. + * g_hold_bio : To hold a given BIO until it is submitted. + * The default function is used when this method is undefined. + * g_pop_bio : To select and get the best BIO to submit. + * g_group_ctr : To initalize the policy own members of struct ioband_group. + * g_group_dtr : Called when struct ioband_group is removed. + * g_set_param : To update the policy own date. + * The parameters can be passed through "dmsetup message" + * command. + * g_should_block : Called every time this ioband device receive a BIO. + * Return 1 if a given group can't receive any more BIOs, + * otherwise return 0. + * g_show : Show the configuration. + */ +static int policy_weight_init(struct ioband_device *dp, int argc, char **argv) +{ + long val; + int r = 0; + + if (argc < 1) + val = 0; + else { + r = strict_strtol(argv[0], 0, &val); + if (r || val < 0) + return -EINVAL; + } + + dp->g_can_submit = is_token_left; + dp->g_prepare_bio = prepare_token; + dp->g_restart_bios = make_global_epoch; + dp->g_group_ctr = policy_weight_ctr; + dp->g_group_dtr = policy_weight_dtr; + dp->g_set_param = policy_weight_param; + dp->g_should_block = is_queue_full; + dp->g_show = policy_weight_show; + + dp->g_epoch = 0; + dp->g_weight_total = 0; + dp->g_current = NULL; + dp->g_dominant = NULL; + dp->g_expired = NULL; + dp->g_token_extra = 0; + dp->g_token_unit = 0; + init_token_bucket(dp, val, 0); + dp->g_token_left = dp->g_token_bucket; + + return 0; +} +/* weight balancing policy based on the number of I/Os. --- End --- */ + + +/* + * Functions for weight balancing policy based on I/O size. + * It just borrows a lot of functions from the regular weight balancing policy. + */ +static int w2_prepare_token(struct ioband_group *gp, struct bio *bio, int flag) +{ + /* Consume tokens depending on the size of a given bio. */ + return consume_token(gp, bio_sectors(bio), flag); +} + +static int w2_policy_weight_init(struct ioband_device *dp, + int argc, char **argv) +{ + long val; + int r = 0; + + if (argc < 1) + val = 0; + else { + r = strict_strtol(argv[0], 0, &val); + if (r || val < 0) + return -EINVAL; + } + + r = policy_weight_init(dp, argc, argv); + if (r < 0) + return r; + + dp->g_prepare_bio = w2_prepare_token; + dp->g_token_unit = PAGE_SHIFT - 9; + init_token_bucket(dp, val, 0); + dp->g_token_left = dp->g_token_bucket; + return 0; +} +/* weight balancing policy based on I/O size. --- End --- */ + + +static int policy_default_init(struct ioband_device *dp, + int argc, char **argv) +{ + return policy_weight_init(dp, argc, argv); +} + +struct policy_type dm_ioband_policy_type[] = { + {"default", policy_default_init}, + {"weight", policy_weight_init}, + {"weight-iosize", w2_policy_weight_init}, + {NULL, policy_default_init} +}; diff -uprN linux-2.6.28-rc2-mm1.orig/drivers/md/dm-ioband-type.c linux-2.6.28-rc2-mm1/drivers/md/dm-ioband-type.c --- linux-2.6.28-rc2-mm1.orig/drivers/md/dm-ioband-type.c 1970-01-01 09:00:00.000000000 +0900 +++ linux-2.6.28-rc2-mm1/drivers/md/dm-ioband-type.c 2008-11-13 09:37:55.000000000 +0900 @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2008 VA Linux Systems Japan K.K. + * + * I/O bandwidth control + * + * This file is released under the GPL. + */ +#include <linux/bio.h> +#include "dm.h" +#include "dm-bio-list.h" +#include "dm-ioband.h" + +/* + * Any I/O bandwidth can be divided into several bandwidth groups, each of which + * has its own unique ID. The following functions are called to determine + * which group a given BIO belongs to and return the ID of the group. + */ + +/* ToDo: unsigned long value would be better for group ID */ + +static int ioband_process_id(struct bio *bio) +{ + /* + * This function will work for KVM and Xen. + */ + return (int)current->tgid; +} + +static int ioband_process_group(struct bio *bio) +{ + return (int)task_pgrp_nr(current); +} + +static int ioband_uid(struct bio *bio) +{ + return (int)current_uid(); +} + +static int ioband_gid(struct bio *bio) +{ + return (int)current_gid(); +} + +static int ioband_cpuset(struct bio *bio) +{ + return 0; /* not implemented yet */ +} + +static int ioband_node(struct bio *bio) +{ + return 0; /* not implemented yet */ +} + +static int ioband_cgroup(struct bio *bio) +{ + /* + * This function should return the ID of the cgroup which issued "bio". + * The ID of the cgroup which the current process belongs to won't be + * suitable ID for this purpose, since some BIOs will be handled by kernel + * threads like aio or pdflush on behalf of the process requesting the BIOs. + */ + return 0; /* not implemented yet */ +} + +struct group_type dm_ioband_group_type[] = { + {"none", NULL}, + {"pgrp", ioband_process_group}, + {"pid", ioband_process_id}, + {"node", ioband_node}, + {"cpuset", ioband_cpuset}, + {"cgroup", ioband_cgroup}, + {"user", ioband_uid}, + {"uid", ioband_uid}, + {"gid", ioband_gid}, + {NULL, NULL} +}; diff -uprN linux-2.6.28-rc2-mm1.orig/drivers/md/dm-ioband.h linux-2.6.28-rc2-mm1/drivers/md/dm-ioband.h --- linux-2.6.28-rc2-mm1.orig/drivers/md/dm-ioband.h 1970-01-01 09:00:00.000000000 +0900 +++ linux-2.6.28-rc2-mm1/drivers/md/dm-ioband.h 2008-11-13 09:37:55.000000000 +0900 @@ -0,0 +1,190 @@ +/* + * Copyright (C) 2008 VA Linux Systems Japan K.K. + * + * I/O bandwidth control + * + * This file is released under the GPL. + */ + +#include <linux/version.h> +#include <linux/wait.h> + +#define DEFAULT_IO_THROTTLE 4 +#define DEFAULT_IO_LIMIT 128 +#define IOBAND_NAME_MAX 31 +#define IOBAND_ID_ANY (-1) + +struct ioband_group; + +struct ioband_device { + struct list_head g_groups; + struct delayed_work g_conductor; + struct workqueue_struct *g_ioband_wq; + struct bio_list g_urgent_bios; + int g_io_throttle; + int g_io_limit[2]; + int g_issued[2]; + int g_blocked; + spinlock_t g_lock; + struct mutex g_lock_device; + wait_queue_head_t g_waitq; + wait_queue_head_t g_waitq_suspend; + wait_queue_head_t g_waitq_flush; + + int g_ref; + struct list_head g_list; + int g_flags; + char g_name[IOBAND_NAME_MAX + 1]; + struct policy_type *g_policy; + + /* policy dependent */ + int (*g_can_submit)(struct ioband_group *); + int (*g_prepare_bio)(struct ioband_group *, struct bio *, int); + int (*g_restart_bios)(struct ioband_device *); + void (*g_hold_bio)(struct ioband_group *, struct bio *); + struct bio * (*g_pop_bio)(struct ioband_group *); + int (*g_group_ctr)(struct ioband_group *, char *); + void (*g_group_dtr)(struct ioband_group *); + int (*g_set_param)(struct ioband_group *, char *cmd, char *value); + int (*g_should_block)(struct ioband_group *); + void (*g_show)(struct ioband_group *, int *, char *, unsigned int); + + /* members for weight balancing policy */ + int g_epoch; + int g_weight_total; + /* the number of tokens which can be used in every epoch */ + int g_token_bucket; + /* how many epochs tokens can be carried over */ + int g_carryover; + /* how many tokens should be used for one page-sized I/O */ + int g_token_unit; + /* the last group which used a token */ + struct ioband_group *g_current; + /* give another group a chance to be scheduled when the rest + of tokens of the current group reaches this mark */ + int g_yield_mark; + /* the latest group which used up its tokens */ + struct ioband_group *g_expired; + /* the group which has the largest number of tokens in the + active groups */ + struct ioband_group *g_dominant; + /* the number of unused tokens in this epoch */ + int g_token_left; + /* left-over tokens from the previous epoch */ + int g_token_extra; +}; + +struct ioband_group_stat { + unsigned long sectors; + unsigned long immediate; + unsigned long deferred; +}; + +struct ioband_group { + struct list_head c_list; + struct ioband_device *c_banddev; + struct dm_dev *c_dev; + struct dm_target *c_target; + struct bio_list c_blocked_bios; + struct bio_list c_prio_bios; + struct rb_root c_group_root; + struct rb_node c_group_node; + int c_id; /* should be unsigned long or unsigned long long */ + char c_name[IOBAND_NAME_MAX + 1]; /* rfu */ + int c_blocked; + int c_prio_blocked; + wait_queue_head_t c_waitq; + int c_flags; + struct ioband_group_stat c_stat[2]; /* hold rd/wr status */ + struct group_type *c_type; + + /* members for weight balancing policy */ + int c_weight; + int c_my_epoch; + int c_token; + int c_token_initial; + int c_limit; + int c_consumed; + + /* rfu */ + /* struct bio_list c_ordered_tag_bios; */ +}; + +#define IOBAND_URGENT 1 + +#define DEV_BIO_BLOCKED 1 +#define DEV_SUSPENDED 2 + +#define set_device_blocked(dp) ((dp)->g_flags |= DEV_BIO_BLOCKED) +#define clear_device_blocked(dp) ((dp)->g_flags &= ~DEV_BIO_BLOCKED) +#define is_device_blocked(dp) ((dp)->g_flags & DEV_BIO_BLOCKED) + +#define set_device_suspended(dp) ((dp)->g_flags |= DEV_SUSPENDED) +#define clear_device_suspended(dp) ((dp)->g_flags &= ~DEV_SUSPENDED) +#define is_device_suspended(dp) ((dp)->g_flags & DEV_SUSPENDED) + +#define IOG_PRIO_BIO_WRITE 1 +#define IOG_PRIO_QUEUE 2 +#define IOG_BIO_BLOCKED 4 +#define IOG_GOING_DOWN 8 +#define IOG_SUSPENDED 16 +#define IOG_NEED_UP 32 + +#define R_OK 0 +#define R_BLOCK 1 +#define R_YIELD 2 + +#define set_group_blocked(gp) ((gp)->c_flags |= IOG_BIO_BLOCKED) +#define clear_group_blocked(gp) ((gp)->c_flags &= ~IOG_BIO_BLOCKED) +#define is_group_blocked(gp) ((gp)->c_flags & IOG_BIO_BLOCKED) + +#define set_group_down(gp) ((gp)->c_flags |= IOG_GOING_DOWN) +#define clear_group_down(gp) ((gp)->c_flags &= ~IOG_GOING_DOWN) +#define is_group_down(gp) ((gp)->c_flags & IOG_GOING_DOWN) + +#define set_group_suspended(gp) ((gp)->c_flags |= IOG_SUSPENDED) +#define clear_group_suspended(gp) ((gp)->c_flags &= ~IOG_SUSPENDED) +#define is_group_suspended(gp) ((gp)->c_flags & IOG_SUSPENDED) + +#define set_group_need_up(gp) ((gp)->c_flags |= IOG_NEED_UP) +#define clear_group_need_up(gp) ((gp)->c_flags &= ~IOG_NEED_UP) +#define group_need_up(gp) ((gp)->c_flags & IOG_NEED_UP) + +#define set_prio_read(gp) ((gp)->c_flags |= IOG_PRIO_QUEUE) +#define clear_prio_read(gp) ((gp)->c_flags &= ~IOG_PRIO_QUEUE) +#define is_prio_read(gp) \ + ((gp)->c_flags & (IOG_PRIO_QUEUE|IOG_PRIO_BIO_WRITE) == IOG_PRIO_QUEUE) + +#define set_prio_write(gp) \ + ((gp)->c_flags |= (IOG_PRIO_QUEUE|IOG_PRIO_BIO_WRITE)) +#define clear_prio_write(gp) \ + ((gp)->c_flags &= ~(IOG_PRIO_QUEUE|IOG_PRIO_BIO_WRITE)) +#define is_prio_write(gp) \ + ((gp)->c_flags & (IOG_PRIO_QUEUE|IOG_PRIO_BIO_WRITE) == \ + (IOG_PRIO_QUEUE|IOG_PRIO_BIO_WRITE)) + +#define set_prio_queue(gp, direct) \ + ((gp)->c_flags |= (IOG_PRIO_QUEUE|direct)) +#define clear_prio_queue(gp) clear_prio_write(gp) +#define is_prio_queue(gp) ((gp)->c_flags & IOG_PRIO_QUEUE) +#define prio_queue_direct(gp) ((gp)->c_flags & IOG_PRIO_BIO_WRITE) + + +struct policy_type { + const char *p_name; + int (*p_policy_init)(struct ioband_device *, int, char **); +}; + +extern struct policy_type dm_ioband_policy_type[]; + +struct group_type { + const char *t_name; + int (*t_getid)(struct bio *); +}; + +extern struct group_type dm_ioband_group_type[]; + +/* Just for debugging */ +extern long ioband_debug; +#define dprintk(format, a...) \ + if (ioband_debug > 0) ioband_debug--, printk(format, ##a) ^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 3/8] dm-ioband: Document 2008-11-13 3:12 ` [PATCH 2/8] dm-ioband: Source code and patch Ryo Tsuruta @ 2008-11-13 3:12 ` Ryo Tsuruta 2008-11-13 3:13 ` [PATCH 4/8] bio-cgroup: Introduction Ryo Tsuruta 0 siblings, 1 reply; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-13 3:12 UTC (permalink / raw) To: linux-kernel, dm-devel, containers, virtualization, xen-devel Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando This patch is the documentation of dm-ioband, design overview, installation, command, reference and examples. Signed-off-by: Ryo Tsuruta <ryov@valinux.co.jp> Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> diff -uprN linux-2.6.28-rc2-mm1.orig/Documentation/device-mapper/ioband.txt linux-2.6.28-rc2-mm1/Documentation/device-mapper/ioband.txt --- linux-2.6.28-rc2-mm1.orig/Documentation/device-mapper/ioband.txt 1970-01-01 09:00:00.000000000 +0900 +++ linux-2.6.28-rc2-mm1/Documentation/device-mapper/ioband.txt 2008-11-13 09:37:55.000000000 +0900 @@ -0,0 +1,961 @@ + Block I/O bandwidth control: dm-ioband + + ------------------------------------------------------- + + Table of Contents + + [1]What's dm-ioband all about? + + [2]Differences from the CFQ I/O scheduler + + [3]How dm-ioband works. + + [4]Setup and Installation + + [5]Getting started + + [6]Command Reference + + [7]Examples + +What's dm-ioband all about? + + dm-ioband is an I/O bandwidth controller implemented as a device-mapper + driver. Several jobs using the same physical device have to share the + bandwidth of the device. dm-ioband gives bandwidth to each job according + to its weight, which each job can set its own value to. + + A job is a group of processes with the same pid or pgrp or uid or a + virtual machine such as KVM or Xen. A job can also be a cgroup by applying + the bio-cgroup patch, which can be found at + [8]http://people.valinux.co.jp/~ryov/bio-cgroup/. + + +------+ +------+ +------+ +------+ +------+ +------+ + |cgroup| |cgroup| | the | | pid | | pid | | the | jobs + | A | | B | |others| | X | | Y | |others| + +--|---+ +--|---+ +--|---+ +--|---+ +--|---+ +--|---+ + +--V----+---V---+----V---+ +--V----+---V---+----V---+ + | group | group | default| | group | group | default| ioband groups + | | | group | | | | group | + +-------+-------+--------+ +-------+-------+--------+ + | ioband1 | | ioband2 | ioband devices + +-----------|------------+ +-----------|------------+ + +-----------V--------------+-------------V------------+ + | | | + | sdb1 | sdb2 | physical devices + +--------------------------+--------------------------+ + + + -------------------------------------------------------------------------- + +Differences from the CFQ I/O scheduler + + Dm-ioband is flexible to configure the bandwidth settings. + + Dm-ioband can work with any type of I/O scheduler such as the NOOP + scheduler, which is often chosen for high-end storages, since it is + implemented outside the I/O scheduling layer. It allows both of partition + based bandwidth control and job --- a group of processes --- based + control. In addition, it can set different configuration on each physical + device to control its bandwidth. + + Meanwhile the current implementation of the CFQ scheduler has 8 IO + priority levels and all jobs whose processes have the same IO priority + share the bandwidth assigned to this level between them. And IO priority + is an attribute of a process so that it equally effects to all block + devices. + + -------------------------------------------------------------------------- + +How dm-ioband works. + + Every ioband device has one ioband group, which by default is called the + default group. + + Ioband devices can also have extra ioband groups in them. Each ioband + group has a job to support and a weight. Proportional to the weight, + dm-ioband gives tokens to the group. + + A group passes on I/O requests that its job issues to the underlying + layer so long as it has tokens left, while requests are blocked if there + aren't any tokens left in the group. Tokens are refilled once all of + groups that have requests on a given physical device use up their tokens. + + There are two policies for token consumption. One is that a token is + consumed for each I/O request. The other is that a token is consumed for + each I/O sector, for example, one I/O request which consists of + 4Kbytes(512bytes * 8 sectors) read consumes 8 tokens. A user can choose + either policy. + + With this approach, a job running on an ioband group with large weight + is guaranteed a wide I/O bandwidth. + + -------------------------------------------------------------------------- + +Setup and Installation + + Build a kernel with these options enabled: + + CONFIG_MD + CONFIG_BLK_DEV_DM + CONFIG_DM_IOBAND + + + If compiled as module, use modprobe to load dm-ioband. + + # make modules + # make modules_install + # depmod -a + # modprobe dm-ioband + + + "dmsetup targets" command shows all available device-mapper targets. + "ioband" and the version number are displayed when dm-ioband has been + loaded. + + # dmsetup targets | grep ioband + ioband v1.9.0 + + + -------------------------------------------------------------------------- + +Getting started + + The following is a brief description how to control the I/O bandwidth of + disks. In this description, we'll take one disk with two partitions as an + example target. + + -------------------------------------------------------------------------- + + Create and map ioband devices + + Create two ioband devices "ioband1" and "ioband2". "ioband1" is mapped + to "/dev/sda1" and has a weight of 40. "ioband2" is mapped to "/dev/sda2" + and has a weight of 10. "ioband1" can use 80% --- 40/(40+10)*100 --- of + the bandwidth of the physical disk "/dev/sda" while "ioband2" can use 20%. + + # echo "0 $(blockdev --getsize /dev/sda1) ioband /dev/sda1 1 0 0 none" \ + "weight 0 :40" | dmsetup create ioband1 + # echo "0 $(blockdev --getsize /dev/sda2) ioband /dev/sda2 1 0 0 none" \ + "weight 0 :10" | dmsetup create ioband2 + + + If the commands are successful then the device files + "/dev/mapper/ioband1" and "/dev/mapper/ioband2" will have been created. + + -------------------------------------------------------------------------- + + Additional bandwidth control + + In this example two extra ioband groups are created on "ioband1". The + first group consists of all the processes with user-id 1000 and the second + group consists of all the processes with user-id 2000. Their weights are + 30 and 20 respectively. + + # dmsetup message ioband1 0 type user + # dmsetup message ioband1 0 attach 1000 + # dmsetup message ioband1 0 attach 2000 + # dmsetup message ioband1 0 weight 1000:30 + # dmsetup message ioband1 0 weight 2000:20 + + + Now the processes in the user-id 1000 group can use 30% --- + 30/(30+20+40+10)*100 --- of the bandwidth of the physical disk. + + Table 1. Weight assignments + + +----------------------------------------------------------------+ + | ioband device | ioband group | ioband weight | + |---------------+--------------------------------+---------------| + | ioband1 | user id 1000 | 30 | + |---------------+--------------------------------+---------------| + | ioband1 | user id 2000 | 20 | + |---------------+--------------------------------+---------------| + | ioband1 | default group(the other users) | 40 | + |---------------+--------------------------------+---------------| + | ioband2 | default group | 10 | + +----------------------------------------------------------------+ + + -------------------------------------------------------------------------- + + Remove the ioband devices + + Remove the ioband devices when no longer used. + + # dmsetup remove ioband1 + # dmsetup remove ioband2 + + + -------------------------------------------------------------------------- + +Command Reference + + Create an ioband device + + SYNOPSIS + + dmsetup create IOBAND_DEVICE + + DESCRIPTION + + Create an ioband device with the given name IOBAND_DEVICE. + Generally, dmsetup reads a table from standard input. Each line of + the table specifies a single target and is of the form: + + start_sector num_sectors "ioband" device_file ioband_device_id \ + io_throttle io_limit ioband_group_type policy token_base \ + :weight [ioband_group_id:weight...] + + + start_sector, num_sectors + + The sector range of the underlying device where + dm-ioband maps. + + ioband + + Specify the string "ioband" as a target type. + + device_file + + Underlying device name. + + ioband_device_id + + The ID number for an ioband device. The same ID + must be set among the ioband devices that share the + same bandwidth, which means they work on the same + physical disk. + + io_throttle + + Dm-ioband starts to control the bandwidth when the + number of BIOs in progress exceeds this value. If 0 + is specified, dm-ioband uses the default value. + + io_limit + + Dm-ioband blocks all I/O requests for the + IOBAND_DEVICE when the number of BIOs in progress + exceeds this value. If 0 is specified, dm-ioband uses + the default value. + + ioband_group_type + + Specify how to evaluate the ioband group ID. The + type must be one of "none", "user", "gid", "pid" or + "pgrp." The type "cgroup" is enabled by applying the + bio-cgroup patch. Specify "none" if you don't need + any ioband groups other than the default ioband + group. + + policy + + Specify bandwidth control policy. A user can choose + either policy "weight" or "weight-iosize." + + weight + + This policy controls bandwidth + according to the proportional to the + weight of each ioband group based on the + number of I/O requests. + + weight-iosize + + This policy controls bandwidth + according to the proportional to the + weight of each ioband group based on the + number of I/O sectors. + + token_base + + The number of tokens which specified by token_base + will be distributed to all ioband groups according to + the proportional to the weight of each ioband group. + If 0 is specified, dm-ioband uses the default value. + + ioband_group_id:weight + + Set the weight of the ioband group specified by + ioband_group_id. If ioband_group_id is omitted, the + weight is assigned to the default ioband group. + + EXAMPLE + + Create an ioband device with the following parameters: + + * Starting sector = "0" + + * The number of sectors = "$(blockdev --getsize /dev/sda1)" + + * Target type = "ioband" + + * Underlying device name = "/dev/sda1" + + * Ioband device ID = "128" + + * I/O throttle = "10" + + * I/O limit = "400" + + * Ioband group type = "user" + + * Bandwidth control policy = "weight" + + * Token base = "2048" + + * Weight for the default ioband group = "100" + + * Weight for the ioband group 1000 = "80" + + * Weight for the ioband group 2000 = "20" + + * Ioband device name = "ioband1" + + # echo "0 $(blockdev --getsize /dev/sda1) ioband" \ + "/dev/sda1 128 10 400 user weight 2048 :100 1000:80 2000:20" \ + | dmsetup create ioband1 + + + Create two device groups (ID=1,2). The bandwidths of these + device groups will be individually controlled. + + # echo "0 $(blockdev --getsize /dev/sda1) ioband /dev/sda1 1" \ + "0 0 none weight 0 :80" | dmsetup create ioband1 + # echo "0 $(blockdev --getsize /dev/sda2) ioband /dev/sda2 1" \ + "0 0 none weight 0 :20" | dmsetup create ioband2 + # echo "0 $(blockdev --getsize /dev/sdb3) ioband /dev/sdb3 2" \ + "0 0 none weight 0 :60" | dmsetup create ioband3 + # echo "0 $(blockdev --getsize /dev/sdb4) ioband /dev/sdb4 2" \ + "0 0 none weight 0 :40" | dmsetup create ioband4 + + + -------------------------------------------------------------------------- + + Remove the ioband device + + SYNOPSIS + + dmsetup remove IOBAND_DEVICE + + DESCRIPTION + + Remove the specified ioband device IOBAND_DEVICE. All the band + groups attached to the ioband device are also removed + automatically. + + EXAMPLE + + Remove ioband device "ioband1." + + # dmsetup remove ioband1 + + + -------------------------------------------------------------------------- + + Set an ioband group type + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 type TYPE + + DESCRIPTION + + Set the ioband group type of the specified ioband device + IOBAND_DEVICE. TYPE must be one of "none", "user", "gid", "pid" or + "pgrp." The type "cgroup" is enabled by applying the bio-cgroup + patch. Once the type is set, new ioband groups can be created on + IOBAND_DEVICE. + + EXAMPLE + + Set the ioband group type of ioband device "ioband1" to "user." + + # dmsetup message ioband1 0 type user + + + -------------------------------------------------------------------------- + + Create an ioband group + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 attach ID + + DESCRIPTION + + Create an ioband group and attach it to IOBAND_DEVICE. ID + specifies user-id, group-id, process-id or process-group-id + depending the ioband group type of IOBAND_DEVICE. + + EXAMPLE + + Create an ioband group which consists of all processes with + user-id 1000 and attach it to ioband device "ioband1." + + # dmsetup message ioband1 0 type user + # dmsetup message ioband1 0 attach 1000 + + + -------------------------------------------------------------------------- + + Detach the ioband group + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 detach ID + + DESCRIPTION + + Detach the ioband group specified by ID from ioband device + IOBAND_DEVICE. + + EXAMPLE + + Detach the ioband group with ID "2000" from ioband device + "ioband2." + + # dmsetup message ioband2 0 detach 1000 + + + -------------------------------------------------------------------------- + + Set bandwidth control policy + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 policy policy + + DESCRIPTION + + Set bandwidth control policy. This command applies to all ioband + devices which have the same ioband device ID as IOBAND_DEVICE. A + user can choose either policy "weight" or "weight-iosize." + + weight + + This policy controls bandwidth according to the + proportional to the weight of each ioband group based + on the number of I/O requests. + + weight-iosize + + This policy controls bandwidth according to the + proportional to the weight of each ioband group based + on the number of I/O sectors. + + EXAMPLE + + Set bandwidth control policy of ioband devices which have the + same ioband device ID as "ioband1" to "weight-iosize." + + # dmsetup message ioband1 0 policy weight-iosize + + + -------------------------------------------------------------------------- + + Set the weight of an ioband group + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 weight VAL + + dmsetup message IOBAND_DEVICE 0 weight ID:VAL + + DESCRIPTION + + Set the weight of the ioband group specified by ID. Set the + weight of the default ioband group of IOBAND_DEVICE if ID isn't + specified. + + The following example means that "ioband1" can use 80% --- + 40/(40+10)*100 --- of the bandwidth of the physical disk while + "ioband2" can use 20%. + + # dmsetup message ioband1 0 weight 40 + # dmsetup message ioband2 0 weight 10 + + + The following lines have the same effect as the above: + + # dmsetup message ioband1 0 weight 4 + # dmsetup message ioband2 0 weight 1 + + + VAL must be an integer larger than 0. The default value, which + is assigned to newly created ioband groups, is 100. + + EXAMPLE + + Set the weight of the default ioband group of "ioband1" to 40. + + # dmsetup message ioband1 0 weight 40 + + + Set the weight of the ioband group of "ioband1" with ID "1000" + to 10. + + # dmsetup message ioband1 0 weight 1000:10 + + + -------------------------------------------------------------------------- + + Set the number of tokens + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 token VAL + + DESCRIPTION + + Set the number of tokens to VAL. According to their weight, this + number of tokens will be distributed to all the ioband groups on + the physical device to which ioband device IOBAND_DEVICE belongs + when they use up their tokens. If 0 is specified, the default + value is used. + + EXAMPLE + + Set the number of tokens of the physical device to which + "ioband1" belongs to 256. + + # dmsetup message ioband1 0 token 256 + + + -------------------------------------------------------------------------- + + Set a limit of how many tokens are carried over + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 carryover VAL + + DESCRIPTION + + When dm-ioband tries to refill an ioband group with tokens after + another ioband group is already refilled several times, dm-ioband + determines the number of tokens to refill by multiplying the + number of tokens refilled once by the smaller of how many times + the other group is already refilled or this limit. If 0 is + specified, the default value is used. + + EXAMPLE + + Set a limit for "ioband1" to 2. + + # dmsetup message ioband1 0 carryover 2 + + + -------------------------------------------------------------------------- + + Set I/O throttling + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 io_throttle VAL + + DESCRIPTION + + Set the I/O throttling value of the physical disk to which + ioband device IOBAND_DEVICE belongs to VAL. Dm-ioband start to + control the bandwidth when the number of BIOs in progress on the + physical disk exceeds this value. + + EXAMPLE + + Set the I/O throttling value of "ioband1" to 16. + + # dmsetup message ioband1 0 io_throttle 16 + + + -------------------------------------------------------------------------- + + Set I/O limiting + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 io_limit VAL + + DESCRIPTION + + Set the I/O limiting value of the physical disk to which ioband + device IOBAND_DEVICE belongs to VAL. Dm-ioband will block all I/O + requests for the physical device if the number of BIOs in progress + on the physical disk exceeds this value. + + EXAMPLE + + Set the I/O limiting value of "ioband1" to 128. + + # dmsetup message ioband1 0 io_limit 128 + + + -------------------------------------------------------------------------- + + Display settings + + SYNOPSIS + + dmsetup table --target ioband + + DESCRIPTION + + Display the current table for the ioband device in a format. See + "dmsetup create" command for information on the table format. + + EXAMPLE + + The following output shows the current table of "ioband1." + + # dmsetup table --target ioband + ioband: 0 32129937 ioband1 8:29 128 10 400 user weight \ + 2048 :100 1000:80 2000:20 + + + -------------------------------------------------------------------------- + + Display Statistics + + SYNOPSIS + + dmsetup status --target ioband + + DESCRIPTION + + Display the statistics of all the ioband devices whose target + type is "ioband." + + The output format is as below. the first five columns shows: + + * ioband device name + + * logical start sector of the device (must be 0) + + * device size in sectors + + * target type (must be "ioband") + + * device group ID + + The remaining columns show the statistics of each ioband group + on the band device. Each group uses seven columns for its + statistics. + + * ioband group ID (-1 means default) + + * total read requests + + * delayed read requests + + * total read sectors + + * total write requests + + * delayed write requests + + * total write sectors + + EXAMPLE + + The following output shows the statistics of two ioband devices. + Ioband2 only has the default ioband group and ioband1 has three + (default, 1001, 1002) ioband groups. + + # dmsetup status + ioband2: 0 44371467 ioband 128 -1 143 90 424 122 78 352 + ioband1: 0 44371467 ioband 128 -1 223 172 408 211 136 600 1001 \ + 166 107 472 139 95 352 1002 211 146 520 210 147 504 + + + -------------------------------------------------------------------------- + + Reset status counter + + SYNOPSIS + + dmsetup message IOBAND_DEVICE 0 reset + + DESCRIPTION + + Reset the statistics of ioband device IOBAND_DEVICE. + + EXAMPLE + + Reset the statistics of "ioband1." + + # dmsetup message ioband1 0 reset + + + -------------------------------------------------------------------------- + +Examples + + Example #1: Bandwidth control on Partitions + + This example describes how to control the bandwidth with disk + partitions. The following diagram illustrates the configuration of this + example. You may want to run a database on /dev/mapper/ioband1 and web + applications on /dev/mapper/ioband2. + + /mnt1 /mnt2 mount points + | | + +-------------V------------+ +-------------V------------+ + | /dev/mapper/ioband1 | | /dev/mapper/ioband2 | ioband devices + +--------------------------+ +--------------------------+ + | default group | | default group | ioband groups + | (80) | | (40) | (weight) + +-------------|------------+ +-------------|------------+ + | | + +-------------V-------------+--------------V------------+ + | /dev/sda1 | /dev/sda2 | physical devices + +---------------------------+---------------------------+ + + + To setup the above configuration, follow these steps: + + 1. Create ioband devices with the same device group ID and assign + weights of 80 and 40 to the default ioband groups respectively. + + # echo "0 $(blockdev --getsize /dev/sda1) ioband /dev/sda1 1 0 0" \ + "none weight 0 :80" | dmsetup create ioband1 + # echo "0 $(blockdev --getsize /dev/sda2) ioband /dev/sda2 1 0 0" \ + "none weight 0 :40" | dmsetup create ioband2 + + + 2. Create filesystems on the ioband devices and mount them. + + # mkfs.ext3 /dev/mapper/ioband1 + # mount /dev/mapper/ioband1 /mnt1 + + # mkfs.ext3 /dev/mapper/ioband2 + # mount /dev/mapper/ioband2 /mnt2 + + + -------------------------------------------------------------------------- + + Example #2: Bandwidth control on Logical Volumes + + This example is similar to the example #1 but it uses LVM logical + volumes instead of disk partitions. This example shows how to configure + ioband devices on two striped logical volumes. + + /mnt1 /mnt2 mount points + | | + +-------------V------------+ +-------------V------------+ + | /dev/mapper/ioband1 | | /dev/mapper/ioband2 | ioband devices + +--------------------------+ +--------------------------+ + | default group | | default group | ioband groups + | (80) | | (40) | (weight) + +-------------|------------+ +-------------|------------+ + | | + +-------------V------------+ +-------------V------------+ + | /dev/mapper/lv0 | | /dev/mapper/lv1 | striped logical + | | | | volumes + +-------------------------------------------------------+ + | vg0 | volume group + +-------------|----------------------------|------------+ + | | + +-------------V------------+ +-------------V------------+ + | /dev/sdb | | /dev/sdc | physical devices + +--------------------------+ +--------------------------+ + + + To setup the above configuration, follow these steps: + + 1. Initialize the partitions for use by LVM. + + # pvcreate /dev/sdb + # pvcreate /dev/sdc + + + 2. Create a new volume group named "vg0" with /dev/sdb and /dev/sdc. + + # vgcreate vg0 /dev/sdb /dev/sdc + + + 3. Create two logical volumes in "vg0." The volumes have to be striped. + + # lvcreate -n lv0 -i 2 -I 64 vg0 -L 1024M + # lvcreate -n lv1 -i 2 -I 64 vg0 -L 1024M + + + The rest is the same as the example #1. + + 4. Create ioband devices corresponding to each logical volume and + assign weights of 80 and 40 to the default ioband groups respectively. + + # echo "0 $(blockdev --getsize /dev/mapper/vg0-lv0)" \ + "ioband /dev/mapper/vg0-lv0 1 0 0 none weight 0 :80" | \ + dmsetup create ioband1 + # echo "0 $(blockdev --getsize /dev/mapper/vg0-lv1)" \ + "ioband /dev/mapper/vg0-lv1 1 0 0 none weight 0 :40" | \ + dmsetup create ioband2 + + + 5. Create filesystems on the ioband devices and mount them. + + # mkfs.ext3 /dev/mapper/ioband1 + # mount /dev/mapper/ioband1 /mnt1 + + # mkfs.ext3 /dev/mapper/ioband2 + # mount /dev/mapper/ioband2 /mnt2 + + + -------------------------------------------------------------------------- + + Example #3: Bandwidth control on processes + + This example describes how to control the bandwidth with groups of + processes. You may also want to run an additional application on the same + machine described in the example #1. This example shows how to add a new + ioband group for this application. + + /mnt1 /mnt2 mount points + | | + +-------------V------------+ +-------------V------------+ + | /dev/mapper/ioband1 | | /dev/mapper/ioband2 | ioband devices + +-------------+------------+ +-------------+------------+ + | default | | user=1000 | default | ioband groups + | (80) | | (20) | (40) | (weight) + +-------------+------------+ +-------------+------------+ + | | + +-------------V-------------+--------------V------------+ + | /dev/sda1 | /dev/sda2 | physical device + +---------------------------+---------------------------+ + + + The following shows to set up a new ioband group on the machine that is + already configured as the example #1. The application will have a weight + of 20 and run with user-id 1000 on /dev/mapper/ioband2. + + 1. Set the type of ioband2 to "user." + + # dmsetup message ioband2 0 type user. + + + 2. Create a new ioband group on ioband2. + + # dmsetup message ioband2 0 attach 1000 + + + 3. Assign weight of 10 to this newly created ioband group. + + # dmsetup message ioband2 0 weight 1000:20 + + + -------------------------------------------------------------------------- + + Example #4: Bandwidth control for Xen virtual block devices + + This example describes how to control the bandwidth for Xen virtual + block devices. The following diagram illustrates the configuration of this + example. + + Virtual Machine 1 Virtual Machine 2 virtual machines + | | + +-------------V------------+ +-------------V------------+ + | /dev/xvda1 | | /dev/xvda1 | virtual block + +-------------|------------+ +-------------|------------+ devices + | | + +-------------V------------+ +-------------V------------+ + | /dev/mapper/ioband1 | | /dev/mapper/ioband2 | ioband devices + +--------------------------+ +--------------------------+ + | default group | | default group | ioband groups + | (80) | | (40) | (weight) + +-------------|------------+ +-------------|------------+ + | | + +-------------V-------------+--------------V------------+ + | /dev/sda1 | /dev/sda2 | physical device + +---------------------------+---------------------------+ + + + The followings shows how to map ioband device "ioband1" and "ioband2" to + virtual block device "/dev/xvda1 on Virtual Machine 1" and "/dev/xvda1 on + Virtual Machine 2" respectively on the machine configured as the example + #1. Add the following lines to the configuration files that are referenced + when creating "Virtual Machine 1" and "Virtual Machine 2." + + For "Virtual Machine 1" + disk = [ 'phy:/dev/mapper/ioband1,xvda,w' ] + + For "Virtual Machine 2" + disk = [ 'phy:/dev/mapper/ioband2,xvda,w' ] + + + -------------------------------------------------------------------------- + + Example #5: Bandwidth control for Xen blktap devices + + This example describes how to control the bandwidth for Xen virtual + block devices when Xen blktap devices are used. The following diagram + illustrates the configuration of this example. + + Virtual Machine 1 Virtual Machine 2 virtual machines + | | + +-------------V------------+ +-------------V------------+ + | /dev/xvda1 | | /dev/xvda1 | virtual block + +-------------|------------+ +-------------|------------+ devices + | | + +-------------V----------------------------V------------+ + | /dev/mapper/ioband1 | ioband device + +---------------------------+---------------------------+ + | default group | default group | ioband groups + | (80) | (40) | (weight) + +-------------|-------------+--------------|------------+ + | | + +-------------|----------------------------|------------+ + | +----------V----------+ +----------V---------+ | + | | vm1.img | | vm2.img | | disk image files + | +---------------------+ +--------------------+ | + | /vmdisk | mount point + +---------------------------|---------------------------+ + | + +---------------------------V---------------------------+ + | /dev/sda1 | physical device + +-------------------------------------------------------+ + + + To setup the above configuration, follow these steps: + + 1. Create an ioband device. + + # echo "0 $(blockdev --getsize /dev/sda1) ioband /dev/sda1" \ + "1 0 0 none weight 0 :100" | dmsetup create ioband1 + + + 2. Add the following lines to the configuration files that are + referenced when creating "Virtual Machine 1" and "Virtual Machine 2." + Disk image files "/vmdisk/vm1.img" and "/vmdisk/vm2.img" will be used. + + For "Virtual Machine 1" + disk = [ 'tap:aio:/vmdisk/vm1.img,xvda,w', ] + + For "Virtual Machine 1" + disk = [ 'tap:aio:/vmdisk/vm2.img,xvda,w', ] + + + 3. Run the virtual machines. + + # xm create vm1 + # xm create vm2 + + + 4. Find out the process IDs of the daemons which control the blktap + devices. + + # lsof /vmdisk/disk[12].img + COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME + tapdisk 15011 root 11u REG 253,0 2147483648 48961 /vmdisk/vm1.img + tapdisk 15276 root 13u REG 253,0 2147483648 48962 /vmdisk/vm2.img + + + 5. Create new ioband groups of pid 15011 and pid 15276, which are + process IDs of the tapdisks, and assign weight of 80 and 40 to the + groups respectively. + + # dmsetup message ioband1 0 type pid + # dmsetup message ioband1 0 attach 15011 + # dmsetup message ioband1 0 weight 15011:80 + # dmsetup message ioband1 0 attach 15276 + # dmsetup message ioband1 0 weight 15276:40 ^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 4/8] bio-cgroup: Introduction 2008-11-13 3:12 ` [PATCH 3/8] dm-ioband: Document Ryo Tsuruta @ 2008-11-13 3:13 ` Ryo Tsuruta 2008-11-13 3:13 ` [PATCH 5/8] bio-cgroup: The new page_cgroup framework Ryo Tsuruta 0 siblings, 1 reply; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-13 3:13 UTC (permalink / raw) To: linux-kernel, dm-devel, containers, virtualization, xen-devel Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando What's bio-cgroup all about? ============================ With this feature, you can determine the owners of any type of I/Os. This makes dm-ioband_--_I/O_bandwidth_controller_-- be able to control the Block I/O bandwidths even when it accepts delayed write requests. Dm-ioband can find the owner cgroup of each request. It is also possible that the other people who work on the i/o bandwidth throttling use this functionality to control asynchronous I/Os with a little enhancement. Setting up bio-cgroup ===================== You have to apply the patch dm-ioband_v1.9.0 before applying this series of bio-cgroup patches. And you have to select the following config options when compiling kernel. CONFIG_CGROUPS=y CONFIG_CGROUP_BIO=y And I recommend you should also select the options for cgroup memory subsystem, because it makes it possible to give some I/O bandwidth and some memory to a certain cgroup to control delayed write requests and the processes in the cgroup will be able to make pages dirty only inside the cgroup even when the given bandwidth is narrow. CONFIG_RESOURCE_COUNTERS=y CONFIG_CGROUP_MEM_RES_CTLR=y Using bio-cgroup ================ The following shows how to use dm-ioband with cgroups. Please assume that you want make two cgroups, which we call "bio cgroup" here, to track down block I/Os and assign them to ioband device "ioband1". First, mount the bio cgroup filesystem. # mount -t cgroup -o bio none /cgroup/bio Then, make new bio cgroups and put some processes in them. # mkdir /cgroup/bio/bgroup1 # mkdir /cgroup/bio/bgroup2 # echo 1234 > /cgroup/bio/bgroup1/tasks # echo 5678 > /cgroup/bio/bgroup1/tasks Now, check the ID of each bio cgroup which is just created. # cat /cgroup/bio/bgroup1/bio.id 1 # cat /cgroup/bio/bgroup2/bio.id 2 Finally, attach the cgroups to "ioband1" and assign them weights. # dmsetup message ioband1 0 type cgroup # dmsetup message ioband1 0 attach 1 # dmsetup message ioband1 0 attach 2 # dmsetup message ioband1 0 weight 1:30 # dmsetup message ioband1 0 weight 2:60 You can also make use of the dm-ioband administration tool iobandctl.py. You can set up the device with the tool as follows. In this case, you don't need to know the IDs of the cgroups. # iobandctl.py group /dev/mapper/ioband1 cgroup \ /cgroup/bio/bgroup1:30 /cgroup/bio/bgroup2:60 ^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 5/8] bio-cgroup: The new page_cgroup framework 2008-11-13 3:13 ` [PATCH 4/8] bio-cgroup: Introduction Ryo Tsuruta @ 2008-11-13 3:13 ` Ryo Tsuruta 2008-11-13 3:14 ` [PATCH 6/8] bio-cgroup: The body of bio-cgroup Ryo Tsuruta 0 siblings, 1 reply; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-13 3:13 UTC (permalink / raw) To: linux-kernel, dm-devel, containers, virtualization, xen-devel Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando This patch makes the page_cgroup framework be able to be used even if the compile option of the cgroup memory controller is off. So bio-cgroup can use this framework without the memory controller. Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> diff -dupr linux-2.6.28-rc2.bc0/include/linux/memcontrol.h linux-2.6.28-rc2/include/linux/memcontrol.h --- linux-2.6.28-rc2.bc0/include/linux/memcontrol.h 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/memcontrol.h 2008-11-11 13:51:42.000000000 +0900 @@ -27,6 +27,9 @@ struct mm_struct; #ifdef CONFIG_CGROUP_MEM_RES_CTLR +extern void __init_mem_page_cgroup(struct page_cgroup *pc); +#define mem_cgroup_disabled() mem_cgroup_subsys.disabled + extern int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm, gfp_t gfp_mask); /* for swap handling */ @@ -81,6 +84,15 @@ extern long mem_cgroup_calc_reclaim(stru #else /* CONFIG_CGROUP_MEM_RES_CTLR */ struct mem_cgroup; +static inline void __init_mem_page_cgroup(struct page_cgroup *pc) +{ +} + +static inline int mem_cgroup_disabled(void) +{ + return 1; +} + static inline int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm, gfp_t gfp_mask) { diff -dupr linux-2.6.28-rc2.bc0/include/linux/mmzone.h linux-2.6.28-rc2/include/linux/mmzone.h --- linux-2.6.28-rc2.bc0/include/linux/mmzone.h 2008-11-10 18:50:50.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/mmzone.h 2008-11-11 13:51:42.000000000 +0900 @@ -603,7 +603,7 @@ typedef struct pglist_data { int nr_zones; #ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */ struct page *node_mem_map; -#ifdef CONFIG_CGROUP_MEM_RES_CTLR +#ifdef CONFIG_CGROUP_PAGE struct page_cgroup *node_page_cgroup; #endif #endif @@ -952,7 +952,7 @@ struct mem_section { /* See declaration of similar field in struct zone */ unsigned long *pageblock_flags; -#ifdef CONFIG_CGROUP_MEM_RES_CTLR +#ifdef CONFIG_CGROUP_PAGE /* * If !SPARSEMEM, pgdat doesn't have page_cgroup pointer. We use * section. (see memcontrol.h/page_cgroup.h about this.) diff -dupr linux-2.6.28-rc2.bc0/include/linux/page_cgroup.h linux-2.6.28-rc2/include/linux/page_cgroup.h --- linux-2.6.28-rc2.bc0/include/linux/page_cgroup.h 2008-11-10 19:29:00.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/page_cgroup.h 2008-11-11 14:46:47.000000000 +0900 @@ -1,7 +1,7 @@ #ifndef __LINUX_PAGE_CGROUP_H #define __LINUX_PAGE_CGROUP_H -#ifdef CONFIG_CGROUP_MEM_RES_CTLR +#ifdef CONFIG_CGROUP_PAGE #include <linux/bit_spinlock.h> /* * Page Cgroup can be considered as an extended mem_map. @@ -12,9 +12,11 @@ */ struct page_cgroup { unsigned long flags; - struct mem_cgroup *mem_cgroup; struct page *page; +#ifdef CONFIG_CGROUP_MEM_RES_CTLR + struct mem_cgroup *mem_cgroup; struct list_head lru; /* per cgroup LRU list */ +#endif }; void __init pgdat_page_cgroup_init(struct pglist_data *pgdat); @@ -88,7 +90,7 @@ static inline void unlock_page_cgroup(st bit_spin_unlock(PCG_LOCK, &pc->flags); } -#else /* CONFIG_CGROUP_MEM_RES_CTLR */ +#else /* CONFIG_CGROUP_PAGE */ struct page_cgroup; static inline void pgdat_page_cgroup_init(struct pglist_data *pgdat) diff -dupr linux-2.6.28-rc2.bc0/init/Kconfig linux-2.6.28-rc2/init/Kconfig --- linux-2.6.28-rc2.bc0/init/Kconfig 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/init/Kconfig 2008-11-11 14:46:47.000000000 +0900 @@ -425,6 +425,10 @@ config CGROUP_MEM_RES_CTLR This config option also selects MM_OWNER config option, which could in turn add some fork/exit overhead. +config CGROUP_PAGE + def_bool y + depends on CGROUP_MEM_RES_CTLR + config MM_OWNER bool diff -dupr linux-2.6.28-rc2.bc0/mm/Makefile linux-2.6.28-rc2/mm/Makefile --- linux-2.6.28-rc2.bc0/mm/Makefile 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/mm/Makefile 2008-11-11 14:46:47.000000000 +0900 @@ -34,5 +34,6 @@ obj-$(CONFIG_FS_XIP) += filemap_xip.o obj-$(CONFIG_MIGRATION) += migrate.o obj-$(CONFIG_SMP) += allocpercpu.o cpu_alloc.o obj-$(CONFIG_QUICKLIST) += quicklist.o -obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o page_cgroup.o +obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o +obj-$(CONFIG_CGROUP_PAGE) += page_cgroup.o obj-$(CONFIG_KMEMTRACE) += kmemtrace.o diff -dupr linux-2.6.28-rc2.bc0/mm/memcontrol.c linux-2.6.28-rc2/mm/memcontrol.c --- linux-2.6.28-rc2.bc0/mm/memcontrol.c 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/mm/memcontrol.c 2008-11-11 14:48:17.000000000 +0900 @@ -157,6 +157,11 @@ pcg_default_flags[NR_CHARGE_TYPE] = { 0, /* FORCE */ }; +void __meminit __init_mem_page_cgroup(struct page_cgroup *pc) +{ + pc->mem_cgroup = NULL; +} + /* * Always modified under lru lock. Then, not necessary to preempt_disable() */ diff -dupr linux-2.6.28-rc2.bc0/mm/page_cgroup.c linux-2.6.28-rc2/mm/page_cgroup.c --- linux-2.6.28-rc2.bc0/mm/page_cgroup.c 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/mm/page_cgroup.c 2008-11-11 14:46:47.000000000 +0900 @@ -8,13 +8,14 @@ #include <linux/memory.h> #include <linux/vmalloc.h> #include <linux/cgroup.h> +#include <linux/memcontrol.h> static void __meminit __init_page_cgroup(struct page_cgroup *pc, unsigned long pfn) { pc->flags = 0; - pc->mem_cgroup = NULL; pc->page = pfn_to_page(pfn); + __init_mem_page_cgroup(pc); } static unsigned long total_usage; @@ -69,7 +70,7 @@ void __init page_cgroup_init(void) int nid, fail; - if (mem_cgroup_subsys.disabled) + if (mem_cgroup_disabled()) return; for_each_online_node(nid) { @@ -229,7 +230,7 @@ void __init page_cgroup_init(void) unsigned long pfn; int fail = 0; - if (mem_cgroup_subsys.disabled) + if (mem_cgroup_disabled()) return; for (pfn = 0; !fail && pfn < max_pfn; pfn += PAGES_PER_SECTION) { ^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 6/8] bio-cgroup: The body of bio-cgroup 2008-11-13 3:13 ` [PATCH 5/8] bio-cgroup: The new page_cgroup framework Ryo Tsuruta @ 2008-11-13 3:14 ` Ryo Tsuruta 2008-11-13 3:15 ` [PATCH 7/8] bio-cgroup: Page tracking hooks Ryo Tsuruta 2008-11-14 7:01 ` [PATCH 6/8] bio-cgroup: The body of bio-cgroup Takuya Yoshikawa 0 siblings, 2 replies; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-13 3:14 UTC (permalink / raw) To: linux-kernel, dm-devel, containers, virtualization, xen-devel Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando This is the body of bio-cgroup. Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> diff -dupr linux-2.6.28-rc2.bc1/block/blk-ioc.c linux-2.6.28-rc2/block/blk-ioc.c --- linux-2.6.28-rc2.bc1/block/blk-ioc.c 2008-11-11 14:53:41.000000000 +0900 +++ linux-2.6.28-rc2/block/blk-ioc.c 2008-11-12 11:20:33.000000000 +0900 @@ -84,24 +84,28 @@ void exit_io_context(void) } } +void init_io_context(struct io_context *ioc) +{ + atomic_set(&ioc->refcount, 1); + atomic_set(&ioc->nr_tasks, 1); + spin_lock_init(&ioc->lock); + ioc->ioprio_changed = 0; + ioc->ioprio = 0; + ioc->last_waited = jiffies; /* doesn't matter... */ + ioc->nr_batch_requests = 0; /* because this is 0 */ + ioc->aic = NULL; + INIT_RADIX_TREE(&ioc->radix_root, GFP_ATOMIC | __GFP_HIGH); + INIT_HLIST_HEAD(&ioc->cic_list); + ioc->ioc_data = NULL; +} + struct io_context *alloc_io_context(gfp_t gfp_flags, int node) { struct io_context *ret; ret = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node); - if (ret) { - atomic_set(&ret->refcount, 1); - atomic_set(&ret->nr_tasks, 1); - spin_lock_init(&ret->lock); - ret->ioprio_changed = 0; - ret->ioprio = 0; - ret->last_waited = jiffies; /* doesn't matter... */ - ret->nr_batch_requests = 0; /* because this is 0 */ - ret->aic = NULL; - INIT_RADIX_TREE(&ret->radix_root, GFP_ATOMIC | __GFP_HIGH); - INIT_HLIST_HEAD(&ret->cic_list); - ret->ioc_data = NULL; - } + if (ret) + init_io_context(ret); return ret; } diff -dupr linux-2.6.28-rc2.bc1/include/linux/biotrack.h linux-2.6.28-rc2/include/linux/biotrack.h --- linux-2.6.28-rc2.bc1/include/linux/biotrack.h 2008-11-11 14:53:41.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/biotrack.h 2008-11-12 21:22:20.000000000 +0900 @@ -0,0 +1,82 @@ +#include <linux/cgroup.h> +#include <linux/mm.h> +#include <linux/page_cgroup.h> + +#ifndef _LINUX_BIOTRACK_H +#define _LINUX_BIOTRACK_H + +#ifdef CONFIG_CGROUP_BIO + +struct io_context; +struct block_device; + +struct bio_cgroup { + struct cgroup_subsys_state css; + int id; + struct io_context *io_context; /* default io_context */ +/* struct radix_tree_root io_context_root; per device io_context */ +}; + +static inline void __init_bio_page_cgroup(struct page_cgroup *pc) +{ + pc->bio_cgroup_id = 0; +} + +static inline int bio_cgroup_disabled(void) +{ + return bio_cgroup_subsys.disabled; +} + +extern void bio_cgroup_set_owner(struct page *page, struct mm_struct *mm); +extern void bio_cgroup_reset_owner(struct page *page, struct mm_struct *mm); +extern void bio_cgroup_reset_owner_pagedirty(struct page *page, + struct mm_struct *mm); +extern void bio_cgroup_copy_owner(struct page *page, struct page *opage); + +extern struct io_context *get_bio_cgroup_iocontext(struct bio *bio); +extern int get_bio_cgroup_id(struct bio *bio); + +#else /* CONFIG_CGROUP_BIO */ + +struct bio_cgroup; + +static inline void __init_bio_page_cgroup(struct page_cgroup *pc) +{ +} + +static inline int bio_cgroup_disabled(void) +{ + return 1; +} + +static inline void bio_cgroup_set_owner(struct page *page, struct mm_struct *mm) +{ +} + +static inline void bio_cgroup_reset_owner(struct page *page, + struct mm_struct *mm) +{ +} + +static inline void bio_cgroup_reset_owner_pagedirty(struct page *page, + struct mm_struct *mm) +{ +} + +static inline void bio_cgroup_copy_owner(struct page *page, struct page *opage) +{ +} + +static inline struct io_context *get_bio_cgroup_iocontext(struct bio *bio) +{ + return NULL; +} + +static inline int get_bio_cgroup_id(struct bio *bio) +{ + return 0; +} + +#endif /* CONFIG_CGROUP_BIO */ + +#endif /* _LINUX_BIOTRACK_H */ diff -dupr linux-2.6.28-rc2.bc1/include/linux/cgroup_subsys.h linux-2.6.28-rc2/include/linux/cgroup_subsys.h --- linux-2.6.28-rc2.bc1/include/linux/cgroup_subsys.h 2008-11-11 14:53:41.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/cgroup_subsys.h 2008-11-12 11:20:33.000000000 +0900 @@ -43,6 +43,12 @@ SUBSYS(mem_cgroup) /* */ +#ifdef CONFIG_CGROUP_BIO +SUBSYS(bio_cgroup) +#endif + +/* */ + #ifdef CONFIG_CGROUP_DEVICE SUBSYS(devices) #endif diff -dupr linux-2.6.28-rc2.bc1/include/linux/iocontext.h linux-2.6.28-rc2/include/linux/iocontext.h --- linux-2.6.28-rc2.bc1/include/linux/iocontext.h 2008-11-11 14:53:41.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/iocontext.h 2008-11-12 11:20:33.000000000 +0900 @@ -104,6 +104,7 @@ int put_io_context(struct io_context *io void exit_io_context(void); struct io_context *get_io_context(gfp_t gfp_flags, int node); struct io_context *alloc_io_context(gfp_t gfp_flags, int node); +void init_io_context(struct io_context *ioc); void copy_io_context(struct io_context **pdst, struct io_context **psrc); #else static inline void exit_io_context(void) diff -dupr linux-2.6.28-rc2.bc1/include/linux/page_cgroup.h linux-2.6.28-rc2/include/linux/page_cgroup.h --- linux-2.6.28-rc2.bc1/include/linux/page_cgroup.h 2008-11-11 14:53:41.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/page_cgroup.h 2008-11-12 11:20:33.000000000 +0900 @@ -17,6 +17,9 @@ struct page_cgroup { struct mem_cgroup *mem_cgroup; struct list_head lru; /* per cgroup LRU list */ #endif +#ifdef CONFIG_CGROUP_BIO + int bio_cgroup_id; +#endif }; void __init pgdat_page_cgroup_init(struct pglist_data *pgdat); diff -dupr linux-2.6.28-rc2.bc1/init/Kconfig linux-2.6.28-rc2/init/Kconfig --- linux-2.6.28-rc2.bc1/init/Kconfig 2008-11-11 14:53:41.000000000 +0900 +++ linux-2.6.28-rc2/init/Kconfig 2008-11-12 11:20:33.000000000 +0900 @@ -425,9 +425,20 @@ config CGROUP_MEM_RES_CTLR This config option also selects MM_OWNER config option, which could in turn add some fork/exit overhead. +config CGROUP_BIO + bool "Block I/O cgroup subsystem" + depends on CGROUPS && BLOCK + select MM_OWNER + help + Provides a Resource Controller which enables to track the onwner + of every Block I/O requests. + The information this subsystem provides can be used from any + kind of module such as dm-ioband device mapper modules or + the cfq-scheduler. + config CGROUP_PAGE def_bool y - depends on CGROUP_MEM_RES_CTLR + depends on CGROUP_MEM_RES_CTLR || CGROUP_BIO config MM_OWNER bool diff -dupr linux-2.6.28-rc2.bc1/mm/biotrack.c linux-2.6.28-rc2/mm/biotrack.c --- linux-2.6.28-rc2.bc1/mm/biotrack.c 2008-11-11 14:53:41.000000000 +0900 +++ linux-2.6.28-rc2/mm/biotrack.c 2008-11-12 11:20:33.000000000 +0900 @@ -0,0 +1,274 @@ +/* biotrack.c - Block I/O Tracking + * + * Copyright (C) VA Linux Systems Japan, 2008 + * Developed by Hirokazu Takahashi <taka@valinux.co.jp> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include <linux/module.h> +#include <linux/smp.h> +#include <linux/bit_spinlock.h> +#include <linux/idr.h> +#include <linux/blkdev.h> +#include <linux/biotrack.h> + +/* + * The block I/O tracking mechanism is implemented on the cgroup memory + * controller framework. It helps to find the the owner of an I/O request + * because every I/O request has a target page and the owner of the page + * can be easily determined on the framework. + */ + +/* Return the bio_cgroup that associates with a cgroup. */ +static inline struct bio_cgroup *cgroup_bio(struct cgroup *cgrp) +{ + return container_of(cgroup_subsys_state(cgrp, bio_cgroup_subsys_id), + struct bio_cgroup, css); +} + +/* Return the bio_cgroup that associates with a process. */ +static inline struct bio_cgroup *bio_cgroup_from_task(struct task_struct *p) +{ + return container_of(task_subsys_state(p, bio_cgroup_subsys_id), + struct bio_cgroup, css); +} + +static struct idr bio_cgroup_id; +static DEFINE_SPINLOCK(bio_cgroup_idr_lock); +static struct io_context default_bio_io_context; +static struct bio_cgroup default_bio_cgroup = { + .id = 0, + .io_context = &default_bio_io_context, +}; + +/* + * This function is used to make a given page have the bio-cgroup id of + * the owner of this page. + */ +void bio_cgroup_set_owner(struct page *page, struct mm_struct *mm) +{ + struct bio_cgroup *biog; + struct page_cgroup *pc; + + if (bio_cgroup_disabled()) + return; + pc = lookup_page_cgroup(page); + if (unlikely(!pc)) + return; + + pc->bio_cgroup_id = 0; /* 0: default bio_cgroup id */ + if (!mm) + return; + /* + * Locking "pc" isn't necessary here since the current process is + * the only one that can access the members related to bio_cgroup. + */ + rcu_read_lock(); + biog = bio_cgroup_from_task(rcu_dereference(mm->owner)); + if (unlikely(!biog)) + goto out; + /* + * css_get(&bio->css) isn't called to increment the reference + * count of this bio_cgroup "biog" so pc->bio_cgroup_id might turn + * invalid even if this page is still active. + * This approach is chosen to minimize the overhead. + */ + pc->bio_cgroup_id = biog->id; +out: + rcu_read_unlock(); +} + +/* + * Change the owner of a given page if necessary. + */ +void bio_cgroup_reset_owner(struct page *page, struct mm_struct *mm) +{ + /* + * A little trick: + * Just call bio_cgroup_set_owner() for pages which are already + * active since the bio_cgroup_id member of page_cgroup can be + * updated without any locks. This is because an integer type of + * variable can be set a new value at once on modern cpus. + */ + bio_cgroup_set_owner(page, mm); +} + +/* + * Change the owner of a given page. This function is only effective for + * pages in the pagecache. + */ +void bio_cgroup_reset_owner_pagedirty(struct page *page, struct mm_struct *mm) +{ + if (PageSwapCache(page) || PageAnon(page)) + return; + if (current->flags & PF_MEMALLOC) + return; + + bio_cgroup_reset_owner(page, mm); +} + +/* + * Assign "page" the same owner as "opage." + */ +void bio_cgroup_copy_owner(struct page *npage, struct page *opage) +{ + struct page_cgroup *npc, *opc; + + if (bio_cgroup_disabled()) + return; + npc = lookup_page_cgroup(npage); + if (unlikely(!npc)) + return; + opc = lookup_page_cgroup(opage); + if (unlikely(!opc)) + return; + + /* + * Do this without any locks. The reason is the same as + * bio_cgroup_reset_owner(). + */ + npc->bio_cgroup_id = opc->bio_cgroup_id; +} + +/* Create a new bio-cgroup. */ +static struct cgroup_subsys_state * +bio_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp) +{ + struct bio_cgroup *biog; + struct io_context *ioc; + int ret; + + if (!cgrp->parent) { + biog = &default_bio_cgroup; + init_io_context(biog->io_context); + /* Increment the referrence count not to be released ever. */ + atomic_inc(&biog->io_context->refcount); + idr_init(&bio_cgroup_id); + return &biog->css; + } + + biog = kzalloc(sizeof(*biog), GFP_KERNEL); + ioc = alloc_io_context(GFP_KERNEL, -1); + if (!ioc || !biog) { + ret = -ENOMEM; + goto out_err; + } + biog->io_context = ioc; +retry: + if (!idr_pre_get(&bio_cgroup_id, GFP_KERNEL)) { + ret = -EAGAIN; + goto out_err; + } + spin_lock_irq(&bio_cgroup_idr_lock); + ret = idr_get_new_above(&bio_cgroup_id, (void *)biog, 1, &biog->id); + spin_unlock_irq(&bio_cgroup_idr_lock); + if (ret == -EAGAIN) + goto retry; + else if (ret) + goto out_err; + + return &biog->css; +out_err: + if (biog) + kfree(biog); + if (ioc) + put_io_context(ioc); + return ERR_PTR(ret); +} + +/* Delete the bio-cgroup. */ +static void bio_cgroup_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp) +{ + struct bio_cgroup *biog = cgroup_bio(cgrp); + + put_io_context(biog->io_context); + + spin_lock_irq(&bio_cgroup_idr_lock); + idr_remove(&bio_cgroup_id, biog->id); + spin_unlock_irq(&bio_cgroup_idr_lock); + + kfree(biog); +} + +static struct bio_cgroup *find_bio_cgroup(int id) +{ + struct bio_cgroup *biog; + spin_lock_irq(&bio_cgroup_idr_lock); + /* + * It might fail to find A bio-group associated with "id" since it + * is allowed to remove the bio-cgroup even when some of I/O requests + * this group issued haven't completed yet. + */ + biog = (struct bio_cgroup *)idr_find(&bio_cgroup_id, id); + spin_unlock_irq(&bio_cgroup_idr_lock); + return biog; +} + +/* Determine the bio-cgroup id of a given bio. */ +int get_bio_cgroup_id(struct bio *bio) +{ + struct page_cgroup *pc; + struct page *page = bio_iovec_idx(bio, 0)->bv_page; + int id = 0; + + pc = lookup_page_cgroup(page); + if (pc) + id = pc->bio_cgroup_id; + return id; +} + +/* Determine the iocontext of the bio-cgroup that issued a given bio. */ +struct io_context *get_bio_cgroup_iocontext(struct bio *bio) +{ + struct bio_cgroup *biog = NULL; + struct io_context *ioc; + int id = 0; + + id = get_bio_cgroup_id(bio); + if (id) + biog = find_bio_cgroup(id); + if (!biog) + biog = &default_bio_cgroup; + ioc = biog->io_context; /* default io_context for this cgroup */ + atomic_inc(&ioc->refcount); + return ioc; +} +EXPORT_SYMBOL(get_bio_cgroup_iocontext); +EXPORT_SYMBOL(get_bio_cgroup_id); + +static u64 bio_id_read(struct cgroup *cgrp, struct cftype *cft) +{ + struct bio_cgroup *biog = cgroup_bio(cgrp); + return (u64) biog->id; +} + + +static struct cftype bio_files[] = { + { + .name = "id", + .read_u64 = bio_id_read, + }, +}; + +static int bio_cgroup_populate(struct cgroup_subsys *ss, struct cgroup *cgrp) +{ + return cgroup_add_files(cgrp, ss, bio_files, ARRAY_SIZE(bio_files)); +} + +struct cgroup_subsys bio_cgroup_subsys = { + .name = "bio", + .create = bio_cgroup_create, + .destroy = bio_cgroup_destroy, + .populate = bio_cgroup_populate, + .subsys_id = bio_cgroup_subsys_id, +}; + diff -dupr linux-2.6.28-rc2.bc1/mm/page_cgroup.c linux-2.6.28-rc2/mm/page_cgroup.c --- linux-2.6.28-rc2.bc1/mm/page_cgroup.c 2008-11-11 14:53:41.000000000 +0900 +++ linux-2.6.28-rc2/mm/page_cgroup.c 2008-11-12 11:20:33.000000000 +0900 @@ -9,6 +9,7 @@ #include <linux/vmalloc.h> #include <linux/cgroup.h> #include <linux/memcontrol.h> +#include <linux/biotrack.h> static void __meminit __init_page_cgroup(struct page_cgroup *pc, unsigned long pfn) @@ -16,6 +17,7 @@ __init_page_cgroup(struct page_cgroup *p pc->flags = 0; pc->page = pfn_to_page(pfn); __init_mem_page_cgroup(pc); + __init_bio_page_cgroup(pc); } static unsigned long total_usage; @@ -70,7 +72,7 @@ void __init page_cgroup_init(void) int nid, fail; - if (mem_cgroup_disabled()) + if (mem_cgroup_disabled() && bio_cgroup_disabled()) return; for_each_online_node(nid) { @@ -79,12 +81,12 @@ void __init page_cgroup_init(void) goto fail; } printk(KERN_INFO "allocated %ld bytes of page_cgroup\n", total_usage); - printk(KERN_INFO "please try cgroup_disable=memory option if you" + printk(KERN_INFO "please try cgroup_disable=memory,bio option if you" " don't want\n"); return; fail: printk(KERN_CRIT "allocation of page_cgroup was failed.\n"); - printk(KERN_CRIT "please try cgroup_disable=memory boot option\n"); + printk(KERN_CRIT "please try cgroup_disable=memory,bio boot options\n"); panic("Out of memory"); } @@ -230,7 +232,7 @@ void __init page_cgroup_init(void) unsigned long pfn; int fail = 0; - if (mem_cgroup_disabled()) + if (mem_cgroup_disabled() && bio_cgroup_disabled()) return; for (pfn = 0; !fail && pfn < max_pfn; pfn += PAGES_PER_SECTION) { @@ -245,7 +247,7 @@ void __init page_cgroup_init(void) hotplug_memory_notifier(page_cgroup_callback, 0); } printk(KERN_INFO "allocated %ld bytes of page_cgroup\n", total_usage); - printk(KERN_INFO "please try cgroup_disable=memory option if you don't" + printk(KERN_INFO "please try cgroup_disable=memory,bio option if you don't" " want\n"); } ^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 7/8] bio-cgroup: Page tracking hooks 2008-11-13 3:14 ` [PATCH 6/8] bio-cgroup: The body of bio-cgroup Ryo Tsuruta @ 2008-11-13 3:15 ` Ryo Tsuruta 2008-11-13 3:15 ` [PATCH 8/8] bio-cgroup: Add a cgroup support to dm-ioband Ryo Tsuruta 2008-11-14 7:01 ` [PATCH 6/8] bio-cgroup: The body of bio-cgroup Takuya Yoshikawa 1 sibling, 1 reply; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-13 3:15 UTC (permalink / raw) To: linux-kernel, dm-devel, containers, virtualization, xen-devel Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando This patch contains several hooks that let the bio-cgroup framework to know which bio-group is the owner of a page before starting I/O against the page. Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> diff -dupr linux-2.6.28-rc2.bc2/fs/buffer.c linux-2.6.28-rc2/fs/buffer.c --- linux-2.6.28-rc2.bc2/fs/buffer.c 2008-11-12 11:20:52.000000000 +0900 +++ linux-2.6.28-rc2/fs/buffer.c 2008-11-12 11:22:00.000000000 +0900 @@ -36,6 +36,7 @@ #include <linux/buffer_head.h> #include <linux/task_io_accounting_ops.h> #include <linux/bio.h> +#include <linux/biotrack.h> #include <linux/notifier.h> #include <linux/cpu.h> #include <linux/bitops.h> @@ -779,6 +780,7 @@ static int __set_page_dirty(struct page BDI_RECLAIMABLE); task_io_account_write(PAGE_CACHE_SIZE); } + bio_cgroup_reset_owner_pagedirty(page, current->mm); radix_tree_tag_set(&mapping->page_tree, page_index(page), PAGECACHE_TAG_DIRTY); } diff -dupr linux-2.6.28-rc2.bc2/fs/direct-io.c linux-2.6.28-rc2/fs/direct-io.c --- linux-2.6.28-rc2.bc2/fs/direct-io.c 2008-11-12 11:20:53.000000000 +0900 +++ linux-2.6.28-rc2/fs/direct-io.c 2008-11-12 11:22:00.000000000 +0900 @@ -33,6 +33,7 @@ #include <linux/err.h> #include <linux/blkdev.h> #include <linux/buffer_head.h> +#include <linux/biotrack.h> #include <linux/rwsem.h> #include <linux/uio.h> #include <asm/atomic.h> @@ -799,6 +800,7 @@ static int do_direct_IO(struct dio *dio) ret = PTR_ERR(page); goto out; } + bio_cgroup_reset_owner(page, current->mm); while (block_in_page < blocks_per_page) { unsigned offset_in_page = block_in_page << blkbits; diff -dupr linux-2.6.28-rc2.bc2/mm/bounce.c linux-2.6.28-rc2/mm/bounce.c --- linux-2.6.28-rc2.bc2/mm/bounce.c 2008-11-12 11:20:53.000000000 +0900 +++ linux-2.6.28-rc2/mm/bounce.c 2008-11-12 11:22:00.000000000 +0900 @@ -14,6 +14,7 @@ #include <linux/hash.h> #include <linux/highmem.h> #include <linux/blktrace_api.h> +#include <linux/biotrack.h> #include <asm/tlbflush.h> #define POOL_SIZE 64 @@ -204,6 +205,7 @@ static void __blk_queue_bounce(struct re to->bv_len = from->bv_len; to->bv_offset = from->bv_offset; inc_zone_page_state(to->bv_page, NR_BOUNCE); + bio_cgroup_copy_owner(to->bv_page, page); if (rw == WRITE) { char *vto, *vfrom; diff -dupr linux-2.6.28-rc2.bc2/mm/filemap.c linux-2.6.28-rc2/mm/filemap.c --- linux-2.6.28-rc2.bc2/mm/filemap.c 2008-11-12 11:20:53.000000000 +0900 +++ linux-2.6.28-rc2/mm/filemap.c 2008-11-12 11:22:00.000000000 +0900 @@ -33,6 +33,7 @@ #include <linux/cpuset.h> #include <linux/hardirq.h> /* for BUG_ON(!in_atomic()) only */ #include <linux/memcontrol.h> +#include <linux/biotrack.h> #include <linux/mm_inline.h> /* for page_is_file_cache() */ #include "internal.h" @@ -464,6 +465,7 @@ int add_to_page_cache_locked(struct page gfp_mask & ~__GFP_HIGHMEM); if (error) goto out; + bio_cgroup_set_owner(page, current->mm); error = radix_tree_preload(gfp_mask & ~__GFP_HIGHMEM); if (error == 0) { diff -dupr linux-2.6.28-rc2.bc2/mm/Makefile linux-2.6.28-rc2/mm/Makefile --- linux-2.6.28-rc2.bc2/mm/Makefile 2008-11-12 11:20:51.000000000 +0900 +++ linux-2.6.28-rc2/mm/Makefile 2008-11-12 11:22:00.000000000 +0900 @@ -36,4 +36,5 @@ obj-$(CONFIG_SMP) += allocpercpu.o cpu_a obj-$(CONFIG_QUICKLIST) += quicklist.o obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o obj-$(CONFIG_CGROUP_PAGE) += page_cgroup.o +obj-$(CONFIG_CGROUP_BIO) += biotrack.o obj-$(CONFIG_KMEMTRACE) += kmemtrace.o diff -dupr linux-2.6.28-rc2.bc2/mm/memory.c linux-2.6.28-rc2/mm/memory.c --- linux-2.6.28-rc2.bc2/mm/memory.c 2008-11-12 11:20:53.000000000 +0900 +++ linux-2.6.28-rc2/mm/memory.c 2008-11-12 11:22:00.000000000 +0900 @@ -51,6 +51,7 @@ #include <linux/init.h> #include <linux/writeback.h> #include <linux/memcontrol.h> +#include <linux/biotrack.h> #include <linux/mmu_notifier.h> #include <asm/pgalloc.h> @@ -1915,6 +1916,7 @@ gotten: */ ptep_clear_flush_notify(vma, address, page_table); SetPageSwapBacked(new_page); + bio_cgroup_set_owner(new_page, mm); lru_cache_add_active_or_unevictable(new_page, vma); page_add_new_anon_rmap(new_page, vma, address); @@ -2354,6 +2356,7 @@ static int do_swap_page(struct mm_struct flush_icache_page(vma, page); set_pte_at(mm, address, page_table, pte); page_add_anon_rmap(page, vma, address); + bio_cgroup_reset_owner(page, mm); mem_cgroup_commit_charge_swapin(page, ptr); swap_free(entry); @@ -2416,6 +2419,7 @@ static int do_anonymous_page(struct mm_s goto release; inc_mm_counter(mm, anon_rss); SetPageSwapBacked(page); + bio_cgroup_set_owner(page, mm); lru_cache_add_active_or_unevictable(page, vma); page_add_new_anon_rmap(page, vma, address); set_pte_at(mm, address, page_table, entry); @@ -2566,6 +2570,7 @@ static int __do_fault(struct mm_struct * if (anon) { inc_mm_counter(mm, anon_rss); SetPageSwapBacked(page); + bio_cgroup_set_owner(page, mm); lru_cache_add_active_or_unevictable(page, vma); page_add_new_anon_rmap(page, vma, address); } else { diff -dupr linux-2.6.28-rc2.bc2/mm/page-writeback.c linux-2.6.28-rc2/mm/page-writeback.c --- linux-2.6.28-rc2.bc2/mm/page-writeback.c 2008-11-12 11:20:53.000000000 +0900 +++ linux-2.6.28-rc2/mm/page-writeback.c 2008-11-12 11:22:00.000000000 +0900 @@ -23,6 +23,7 @@ #include <linux/init.h> #include <linux/backing-dev.h> #include <linux/task_io_accounting_ops.h> +#include <linux/biotrack.h> #include <linux/blkdev.h> #include <linux/mpage.h> #include <linux/rmap.h> @@ -1100,6 +1101,7 @@ int __set_page_dirty_nobuffers(struct pa BDI_RECLAIMABLE); task_io_account_write(PAGE_CACHE_SIZE); } + bio_cgroup_reset_owner_pagedirty(page, current->mm); radix_tree_tag_set(&mapping->page_tree, page_index(page), PAGECACHE_TAG_DIRTY); } diff -dupr linux-2.6.28-rc2.bc2/mm/swap_state.c linux-2.6.28-rc2/mm/swap_state.c --- linux-2.6.28-rc2.bc2/mm/swap_state.c 2008-11-12 11:20:53.000000000 +0900 +++ linux-2.6.28-rc2/mm/swap_state.c 2008-11-12 11:22:00.000000000 +0900 @@ -17,6 +17,7 @@ #include <linux/backing-dev.h> #include <linux/pagevec.h> #include <linux/migrate.h> +#include <linux/biotrack.h> #include <asm/pgtable.h> @@ -305,6 +306,7 @@ struct page *read_swap_cache_async(swp_e */ __set_page_locked(new_page); SetPageSwapBacked(new_page); + bio_cgroup_set_owner(new_page, current->mm); err = add_to_swap_cache(new_page, entry, gfp_mask & GFP_KERNEL); if (likely(!err)) { /* ^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 8/8] bio-cgroup: Add a cgroup support to dm-ioband 2008-11-13 3:15 ` [PATCH 7/8] bio-cgroup: Page tracking hooks Ryo Tsuruta @ 2008-11-13 3:15 ` Ryo Tsuruta 0 siblings, 0 replies; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-13 3:15 UTC (permalink / raw) To: linux-kernel, dm-devel, containers, virtualization, xen-devel Cc: agk, balbir, xemul, kamezawa.hiroyu, fernando With this patch, dm-ioband can work with the bio cgroup. Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> diff -dupr linux-2.6.28-rc2.bc3/drivers/md/dm-ioband-type.c linux-2.6.28-rc2/drivers/md/dm-ioband-type.c --- linux-2.6.28-rc2.bc3/drivers/md/dm-ioband-type.c 2008-11-12 11:22:19.000000000 +0900 +++ linux-2.6.28-rc2/drivers/md/dm-ioband-type.c 2008-11-12 11:23:18.000000000 +0900 @@ -6,6 +6,7 @@ * This file is released under the GPL. */ #include <linux/bio.h> +#include <linux/biotrack.h> #include "dm.h" #include "dm-bio-list.h" #include "dm-ioband.h" @@ -53,13 +54,7 @@ static int ioband_node(struct bio *bio) static int ioband_cgroup(struct bio *bio) { - /* - * This function should return the ID of the cgroup which issued "bio". - * The ID of the cgroup which the current process belongs to won't be - * suitable ID for this purpose, since some BIOs will be handled by kernel - * threads like aio or pdflush on behalf of the process requesting the BIOs. - */ - return 0; /* not implemented yet */ + return get_bio_cgroup_id(bio); } struct group_type dm_ioband_group_type[] = { ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 6/8] bio-cgroup: The body of bio-cgroup 2008-11-13 3:14 ` [PATCH 6/8] bio-cgroup: The body of bio-cgroup Ryo Tsuruta 2008-11-13 3:15 ` [PATCH 7/8] bio-cgroup: Page tracking hooks Ryo Tsuruta @ 2008-11-14 7:01 ` Takuya Yoshikawa 2008-11-16 11:46 ` Hirokazu Takahashi 1 sibling, 1 reply; 19+ messages in thread From: Takuya Yoshikawa @ 2008-11-14 7:01 UTC (permalink / raw) To: Ryo Tsuruta Cc: linux-kernel, dm-devel, containers, virtualization, xen-devel, fernando, balbir, xemul, agk Hi, Ryo Tsuruta wrote: > > +void init_io_context(struct io_context *ioc) > +{ > + atomic_set(&ioc->refcount, 1); > + atomic_set(&ioc->nr_tasks, 1); > + spin_lock_init(&ioc->lock); > + ioc->ioprio_changed = 0; > + ioc->ioprio = 0; > + ioc->last_waited = jiffies; /* doesn't matter... */ > + ioc->nr_batch_requests = 0; /* because this is 0 */ > + ioc->aic = NULL; > + INIT_RADIX_TREE(&ioc->radix_root, GFP_ATOMIC | __GFP_HIGH); > + INIT_HLIST_HEAD(&ioc->cic_list); > + ioc->ioc_data = NULL; > +} > + > struct io_context *alloc_io_context(gfp_t gfp_flags, int node) > { > struct io_context *ret; > > ret = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node); > - if (ret) { > - atomic_set(&ret->refcount, 1); > - atomic_set(&ret->nr_tasks, 1); > - spin_lock_init(&ret->lock); > - ret->ioprio_changed = 0; > - ret->ioprio = 0; > - ret->last_waited = jiffies; /* doesn't matter... */ > - ret->nr_batch_requests = 0; /* because this is 0 */ > - ret->aic = NULL; > - INIT_RADIX_TREE(&ret->radix_root, GFP_ATOMIC | __GFP_HIGH); > - INIT_HLIST_HEAD(&ret->cic_list); > - ret->ioc_data = NULL; > - } > + if (ret) > + init_io_context(ret); > > return ret; > } > + > +/* Create a new bio-cgroup. */ > +static struct cgroup_subsys_state * > +bio_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp) > +{ > + struct bio_cgroup *biog; > + struct io_context *ioc; > + int ret; > + > + if (!cgrp->parent) { > + biog = &default_bio_cgroup; > + init_io_context(biog->io_context); > + /* Increment the referrence count not to be released ever. */ > + atomic_inc(&biog->io_context->refcount); > + idr_init(&bio_cgroup_id); > + return &biog->css; > + } > + > + biog = kzalloc(sizeof(*biog), GFP_KERNEL); > + ioc = alloc_io_context(GFP_KERNEL, -1); > + if (!ioc || !biog) { > + ret = -ENOMEM; > + goto out_err; > + } > + biog->io_context = ioc; If I understand correctly io_contexts allocated by alloc_io_context() should be owned by some tasks. In this case, the newly created io_context has no owner though biog->io_context->nr_tasks == 1. With the cfq scheduler this may cause some problems especially when cic_free_func() is called because cfq_exit_io_context() would never be called. Am I wrong? > +retry: > + if (!idr_pre_get(&bio_cgroup_id, GFP_KERNEL)) { > + ret = -EAGAIN; > + goto out_err; > + } > + spin_lock_irq(&bio_cgroup_idr_lock); > + ret = idr_get_new_above(&bio_cgroup_id, (void *)biog, 1, &biog->id); > + spin_unlock_irq(&bio_cgroup_idr_lock); > + if (ret == -EAGAIN) > + goto retry; > + else if (ret) > + goto out_err; > + > + return &biog->css; > +out_err: > + if (biog) > + kfree(biog); > + if (ioc) > + put_io_context(ioc); > + return ERR_PTR(ret); > +} > + > +/* Delete the bio-cgroup. */ > +static void bio_cgroup_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp) > +{ > + struct bio_cgroup *biog = cgroup_bio(cgrp); > + > + put_io_context(biog->io_context); Here, I suspects what will happen under the following condition: biog->io_context->refcount: 1 --> 0 biog->io_context->nr_tasks: 1 --> 1 ==> cfq_dtor() will be called but cfq_exit() has not be called yet. > + > + spin_lock_irq(&bio_cgroup_idr_lock); > + idr_remove(&bio_cgroup_id, biog->id); > + spin_unlock_irq(&bio_cgroup_idr_lock); > + > + kfree(biog); > +} > + > + > +/* Determine the iocontext of the bio-cgroup that issued a given bio. */ > +struct io_context *get_bio_cgroup_iocontext(struct bio *bio) > +{ > + struct bio_cgroup *biog = NULL; > + struct io_context *ioc; > + int id = 0; > + > + id = get_bio_cgroup_id(bio); > + if (id) > + biog = find_bio_cgroup(id); > + if (!biog) > + biog = &default_bio_cgroup; > + ioc = biog->io_context; /* default io_context for this cgroup */ > + atomic_inc(&ioc->refcount); > + return ioc; > +} > +EXPORT_SYMBOL(get_bio_cgroup_iocontext); Thanks, Takuya Yoshikawa ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 6/8] bio-cgroup: The body of bio-cgroup 2008-11-14 7:01 ` [PATCH 6/8] bio-cgroup: The body of bio-cgroup Takuya Yoshikawa @ 2008-11-16 11:46 ` Hirokazu Takahashi 2008-11-17 7:50 ` [PATCH 6/8]Re: " Takuya Yoshikawa 0 siblings, 1 reply; 19+ messages in thread From: Hirokazu Takahashi @ 2008-11-16 11:46 UTC (permalink / raw) To: yoshikawa.takuya Cc: ryov, xen-devel, containers, linux-kernel, virtualization, dm-devel, agk, xemul, fernando, balbir Hi, As you pointed out, cgroup iocontext stuff isn't well designed yet since the current implementation of dm-iband doesn't need it. I'd like to leave the iocontext stuff to you I/O scheduler guys if you want to implement the bio-cgroup infrastructure to handle iocotexts as the I/O schedulers expect. > Hi, > > Ryo Tsuruta wrote: > > > > +void init_io_context(struct io_context *ioc) > > +{ > > + atomic_set(&ioc->refcount, 1); > > + atomic_set(&ioc->nr_tasks, 1); > > + spin_lock_init(&ioc->lock); > > + ioc->ioprio_changed = 0; > > + ioc->ioprio = 0; > > + ioc->last_waited = jiffies; /* doesn't matter... */ > > + ioc->nr_batch_requests = 0; /* because this is 0 */ > > + ioc->aic = NULL; > > + INIT_RADIX_TREE(&ioc->radix_root, GFP_ATOMIC | __GFP_HIGH); > > + INIT_HLIST_HEAD(&ioc->cic_list); > > + ioc->ioc_data = NULL; > > +} > > + > > struct io_context *alloc_io_context(gfp_t gfp_flags, int node) > > { > > struct io_context *ret; > > > > ret = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node); > > - if (ret) { > > - atomic_set(&ret->refcount, 1); > > - atomic_set(&ret->nr_tasks, 1); > > - spin_lock_init(&ret->lock); > > - ret->ioprio_changed = 0; > > - ret->ioprio = 0; > > - ret->last_waited = jiffies; /* doesn't matter... */ > > - ret->nr_batch_requests = 0; /* because this is 0 */ > > - ret->aic = NULL; > > - INIT_RADIX_TREE(&ret->radix_root, GFP_ATOMIC | __GFP_HIGH); > > - INIT_HLIST_HEAD(&ret->cic_list); > > - ret->ioc_data = NULL; > > - } > > + if (ret) > > + init_io_context(ret); > > > > return ret; > > } > > > > + > > +/* Create a new bio-cgroup. */ > > +static struct cgroup_subsys_state * > > +bio_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp) > > +{ > > + struct bio_cgroup *biog; > > + struct io_context *ioc; > > + int ret; > > + > > + if (!cgrp->parent) { > > + biog = &default_bio_cgroup; > > + init_io_context(biog->io_context); > > + /* Increment the referrence count not to be released ever. */ > > + atomic_inc(&biog->io_context->refcount); > > + idr_init(&bio_cgroup_id); > > + return &biog->css; > > + } > > + > > + biog = kzalloc(sizeof(*biog), GFP_KERNEL); > > + ioc = alloc_io_context(GFP_KERNEL, -1); > > + if (!ioc || !biog) { > > + ret = -ENOMEM; > > + goto out_err; > > + } > > + biog->io_context = ioc; > > If I understand correctly io_contexts allocated by alloc_io_context() should > be owned by some tasks. In this case, the newly created io_context has no > owner though biog->io_context->nr_tasks == 1. With the cfq scheduler this may > cause some problems especially when cic_free_func() is called because > cfq_exit_io_context() would never be called. Am I wrong? I think iocontext allocated for a certain cgroup should be owned by the cgroup itself, whose code isn't implemented yet. I think you need to enhance it a bit if the owner is a cgroup. > > +retry: > > + if (!idr_pre_get(&bio_cgroup_id, GFP_KERNEL)) { > > + ret = -EAGAIN; > > + goto out_err; > > + } > > + spin_lock_irq(&bio_cgroup_idr_lock); > > + ret = idr_get_new_above(&bio_cgroup_id, (void *)biog, 1, &biog->id); > > + spin_unlock_irq(&bio_cgroup_idr_lock); > > + if (ret == -EAGAIN) > > + goto retry; > > + else if (ret) > > + goto out_err; > > + > > + return &biog->css; > > +out_err: > > + if (biog) > > + kfree(biog); > > + if (ioc) > > + put_io_context(ioc); > > + return ERR_PTR(ret); > > +} > > + > > +/* Delete the bio-cgroup. */ > > +static void bio_cgroup_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp) > > +{ > > + struct bio_cgroup *biog = cgroup_bio(cgrp); > > + > > + put_io_context(biog->io_context); > > Here, I suspects what will happen under the following condition: > biog->io_context->refcount: 1 --> 0 > biog->io_context->nr_tasks: 1 --> 1 > ==> cfq_dtor() will be called but cfq_exit() has not be called yet. > > > + > > + spin_lock_irq(&bio_cgroup_idr_lock); > > + idr_remove(&bio_cgroup_id, biog->id); > > + spin_unlock_irq(&bio_cgroup_idr_lock); > > + > > + kfree(biog); > > +} > > + > > > + > > +/* Determine the iocontext of the bio-cgroup that issued a given bio. */ > > +struct io_context *get_bio_cgroup_iocontext(struct bio *bio) > > +{ > > + struct bio_cgroup *biog = NULL; > > + struct io_context *ioc; > > + int id = 0; > > + > > + id = get_bio_cgroup_id(bio); > > + if (id) > > + biog = find_bio_cgroup(id); > > + if (!biog) > > + biog = &default_bio_cgroup; > > + ioc = biog->io_context; /* default io_context for this cgroup */ > > + atomic_inc(&ioc->refcount); > > + return ioc; > > +} > > +EXPORT_SYMBOL(get_bio_cgroup_iocontext); > > > Thanks, > Takuya Yoshikawa Thank you, Hirokazu Takahashi. ^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 6/8]Re: bio-cgroup: The body of bio-cgroup 2008-11-16 11:46 ` Hirokazu Takahashi @ 2008-11-17 7:50 ` Takuya Yoshikawa 0 siblings, 0 replies; 19+ messages in thread From: Takuya Yoshikawa @ 2008-11-17 7:50 UTC (permalink / raw) To: Hirokazu Takahashi Cc: ryov, xen-devel, containers, linux-kernel, virtualization, dm-devel, agk, xemul, fernando, balbir, s-uchida, ngupta, vgoyal Hi i/o controller/scheduler developers, Hirokazu Takahashi wrote: > Hi, > > As you pointed out, cgroup iocontext stuff isn't well designed yet > since the current implementation of dm-iband doesn't need it. > I'd like to leave the iocontext stuff to you I/O scheduler guys > if you want to implement the bio-cgroup infrastructure to handle iocotexts > as the I/O schedulers expect. Yes, I want to contribute to this because I think the io context tracking part can be used for a lot of other things. So it would be nice if we can talk about "the most useful desing for everyone." > >> Hi, >> >> Ryo Tsuruta wrote: >>> >>> +void init_io_context(struct io_context *ioc) >>> +{ >>> + atomic_set(&ioc->refcount, 1); >>> + atomic_set(&ioc->nr_tasks, 1); >>> + spin_lock_init(&ioc->lock); >>> + ioc->ioprio_changed = 0; >>> + ioc->ioprio = 0; >>> + ioc->last_waited = jiffies; /* doesn't matter... */ >>> + ioc->nr_batch_requests = 0; /* because this is 0 */ >>> + ioc->aic = NULL; >>> + INIT_RADIX_TREE(&ioc->radix_root, GFP_ATOMIC | __GFP_HIGH); >>> + INIT_HLIST_HEAD(&ioc->cic_list); >>> + ioc->ioc_data = NULL; >>> +} >>> + >>> struct io_context *alloc_io_context(gfp_t gfp_flags, int node) >>> { >>> struct io_context *ret; >>> >>> ret = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node); >>> - if (ret) { >>> - atomic_set(&ret->refcount, 1); >>> - atomic_set(&ret->nr_tasks, 1); >>> - spin_lock_init(&ret->lock); >>> - ret->ioprio_changed = 0; >>> - ret->ioprio = 0; >>> - ret->last_waited = jiffies; /* doesn't matter... */ >>> - ret->nr_batch_requests = 0; /* because this is 0 */ >>> - ret->aic = NULL; >>> - INIT_RADIX_TREE(&ret->radix_root, GFP_ATOMIC | __GFP_HIGH); >>> - INIT_HLIST_HEAD(&ret->cic_list); >>> - ret->ioc_data = NULL; >>> - } >>> + if (ret) >>> + init_io_context(ret); >>> >>> return ret; >>> } >> >>> + >>> +/* Create a new bio-cgroup. */ >>> +static struct cgroup_subsys_state * >>> +bio_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp) >>> +{ >>> + struct bio_cgroup *biog; >>> + struct io_context *ioc; >>> + int ret; >>> + >>> + if (!cgrp->parent) { >>> + biog = &default_bio_cgroup; >>> + init_io_context(biog->io_context); >>> + /* Increment the referrence count not to be released ever. */ >>> + atomic_inc(&biog->io_context->refcount); >>> + idr_init(&bio_cgroup_id); >>> + return &biog->css; >>> + } >>> + >>> + biog = kzalloc(sizeof(*biog), GFP_KERNEL); >>> + ioc = alloc_io_context(GFP_KERNEL, -1); >>> + if (!ioc || !biog) { >>> + ret = -ENOMEM; >>> + goto out_err; >>> + } >>> + biog->io_context = ioc; >> If I understand correctly io_contexts allocated by alloc_io_context() should >> be owned by some tasks. In this case, the newly created io_context has no >> owner though biog->io_context->nr_tasks == 1. With the cfq scheduler this may >> cause some problems especially when cic_free_func() is called because >> cfq_exit_io_context() would never be called. Am I wrong? > > I think iocontext allocated for a certain cgroup should be owned by the > cgroup itself, whose code isn't implemented yet. I think you need to > enhance it a bit if the owner is a cgroup. > >>> +retry: >>> + if (!idr_pre_get(&bio_cgroup_id, GFP_KERNEL)) { >>> + ret = -EAGAIN; >>> + goto out_err; >>> + } >>> + spin_lock_irq(&bio_cgroup_idr_lock); >>> + ret = idr_get_new_above(&bio_cgroup_id, (void *)biog, 1, &biog->id); >>> + spin_unlock_irq(&bio_cgroup_idr_lock); >>> + if (ret == -EAGAIN) >>> + goto retry; >>> + else if (ret) >>> + goto out_err; >>> + >>> + return &biog->css; >>> +out_err: >>> + if (biog) >>> + kfree(biog); >>> + if (ioc) >>> + put_io_context(ioc); >>> + return ERR_PTR(ret); >>> +} >>> + >>> +/* Delete the bio-cgroup. */ >>> +static void bio_cgroup_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp) >>> +{ >>> + struct bio_cgroup *biog = cgroup_bio(cgrp); >>> + >>> + put_io_context(biog->io_context); >> Here, I suspects what will happen under the following condition: >> biog->io_context->refcount: 1 --> 0 >> biog->io_context->nr_tasks: 1 --> 1 >> ==> cfq_dtor() will be called but cfq_exit() has not be called yet. >> >>> + >>> + spin_lock_irq(&bio_cgroup_idr_lock); >>> + idr_remove(&bio_cgroup_id, biog->id); >>> + spin_unlock_irq(&bio_cgroup_idr_lock); >>> + >>> + kfree(biog); >>> +} >>> + >>> + >>> +/* Determine the iocontext of the bio-cgroup that issued a given bio. */ >>> +struct io_context *get_bio_cgroup_iocontext(struct bio *bio) >>> +{ >>> + struct bio_cgroup *biog = NULL; >>> + struct io_context *ioc; >>> + int id = 0; >>> + >>> + id = get_bio_cgroup_id(bio); >>> + if (id) >>> + biog = find_bio_cgroup(id); >>> + if (!biog) >>> + biog = &default_bio_cgroup; >>> + ioc = biog->io_context; /* default io_context for this cgroup */ >>> + atomic_inc(&ioc->refcount); >>> + return ioc; >>> +} >>> +EXPORT_SYMBOL(get_bio_cgroup_iocontext); >> >> Thanks, >> Takuya Yoshikawa > > Thank you, > Hirokazu Takahashi. > ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [dm-devel] [PATCH 1/8] dm-ioband: Introduction 2008-11-13 3:11 ` [PATCH 1/8] dm-ioband: Introduction Ryo Tsuruta 2008-11-13 3:12 ` [PATCH 2/8] dm-ioband: Source code and patch Ryo Tsuruta @ 2008-11-13 19:36 ` Phillip Susi 2008-11-13 23:18 ` Hirokazu Takahashi 1 sibling, 1 reply; 19+ messages in thread From: Phillip Susi @ 2008-11-13 19:36 UTC (permalink / raw) To: device-mapper development Cc: linux-kernel, containers, virtualization, xen-devel, fernando, balbir, xemul, kamezawa.hiroyu, agk Ryo Tsuruta wrote: > Create two ioband devices "ioband1" and "ioband2". "ioband1" is mapped > to "/dev/sda1" and has a weight of 40. "ioband2" is mapped to "/dev/sda2" > and has a weight of 10. "ioband1" can use 80% --- 40/(40+10)*100 --- > of the bandwidth of the physical disk "/dev/sda" while "ioband2" can use 20%. Just to clarify, when you say ioband1 can use 80% of the bandwidh, you mean that is how much it will get if both io bands are loaded right? If there is no activity on ioband2, then ioband1 will get the full disk bandwidth right? ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [dm-devel] [PATCH 1/8] dm-ioband: Introduction 2008-11-13 19:36 ` [dm-devel] [PATCH 1/8] dm-ioband: Introduction Phillip Susi @ 2008-11-13 23:18 ` Hirokazu Takahashi 2008-11-14 1:38 ` Ryo Tsuruta 0 siblings, 1 reply; 19+ messages in thread From: Hirokazu Takahashi @ 2008-11-13 23:18 UTC (permalink / raw) To: psusi Cc: dm-devel, linux-kernel, containers, virtualization, xen-devel, fernando, balbir, xemul, kamezawa.hiroyu, agk Hi, > Ryo Tsuruta wrote: > > Create two ioband devices "ioband1" and "ioband2". "ioband1" is mapped > > to "/dev/sda1" and has a weight of 40. "ioband2" is mapped to "/dev/sda2" > > and has a weight of 10. "ioband1" can use 80% --- 40/(40+10)*100 --- > > of the bandwidth of the physical disk "/dev/sda" while "ioband2" can use 20%. > > Just to clarify, when you say ioband1 can use 80% of the bandwidh, you > mean that is how much it will get if both io bands are loaded right? If > there is no activity on ioband2, then ioband1 will get the full disk > bandwidth right? Absolutely, you are right! Thank you, Hirokazu Takahashi. ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [dm-devel] [PATCH 1/8] dm-ioband: Introduction 2008-11-13 23:18 ` Hirokazu Takahashi @ 2008-11-14 1:38 ` Ryo Tsuruta 0 siblings, 0 replies; 19+ messages in thread From: Ryo Tsuruta @ 2008-11-14 1:38 UTC (permalink / raw) To: dm-devel, taka Cc: psusi, xen-devel, containers, linux-kernel, virtualization, agk, xemul, fernando, kamezawa.hiroyu, balbir Hi Phillip, > > Ryo Tsuruta wrote: > > > Create two ioband devices "ioband1" and "ioband2". "ioband1" is mapped > > > to "/dev/sda1" and has a weight of 40. "ioband2" is mapped to "/dev/sda2" > > > and has a weight of 10. "ioband1" can use 80% --- 40/(40+10)*100 --- > > > of the bandwidth of the physical disk "/dev/sda" while "ioband2" can use 20%. > > > > Just to clarify, when you say ioband1 can use 80% of the bandwidh, you > > mean that is how much it will get if both io bands are loaded right? If > > there is no activity on ioband2, then ioband1 will get the full disk > > bandwidth right? > > Absolutely, you are right! Here is a benchmark result of sharing bandwidth between three ioband devices. When there is no activity on ioband2, the total bandwidth of the disk is shared only between ioband1 and ioband3 according to their weights. http://people.valinux.co.jp/~ryov/dm-ioband/benchmark/partition1.html -- Ryo Tsuruta <ryov@valinux.co.jp> ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 0/8] I/O bandwidth controller and BIO tracking 2008-11-13 3:10 [PATCH 0/8] I/O bandwidth controller and BIO tracking Ryo Tsuruta 2008-11-13 3:11 ` [PATCH 1/8] dm-ioband: Introduction Ryo Tsuruta @ 2008-11-13 6:30 ` KAMEZAWA Hiroyuki 2008-11-13 7:26 ` [dm-devel] " Hirokazu Takahashi 1 sibling, 1 reply; 19+ messages in thread From: KAMEZAWA Hiroyuki @ 2008-11-13 6:30 UTC (permalink / raw) To: Ryo Tsuruta Cc: linux-kernel, dm-devel, containers, virtualization, xen-devel, agk, balbir, xemul, fernando, menage@google.com, lizf@cn.fujitsu.com On Thu, 13 Nov 2008 12:10:19 +0900 (JST) Ryo Tsuruta <ryov@valinux.co.jp> wrote: > Hi everyone, > > This is a new release of dm-ioband and bio-cgroup. With this release, > the overhead of bio-cgroup is significantly reduced and the accuracy > of block I/O tracking is much improved. These patches are for > 2.6.28-rc2-mm1. > >From my point of view, a way to record bio_cgroup_id to page_cgroup is quite neat and nice. My concern is "bio_cgroup_id". It's provided only for bio_cgroup. In this summer, I tried to add swap_cgroup_id only for mem+swap controller but commenters said "please provide "id and lookup" in cgroup layer, it should be useful." And I agree them. (and postponed it ;) Could you try "id" in cgroup layer ? How do you think, Paul and others ? That's my only concern and if I/O controller people decides to live with this bio tracking infrastracture, == page -> page_cgroup -> bio_cgroup_id == I have no objections. And enqueue necessary changes to my queue. Thanks, -Kame > Enjoy it! > > dm-ioband > ========= > > Dm-ioband is an I/O bandwidth controller implemented as a > device-mapper driver, which gives specified bandwidth to each job > running on the same block device. A job is a group of processes > or a virtual machine such as KVM or Xen. > I/O throughput on dm-ioband is excellent not only on SATA storage > but on SDD, which as good as the one without dm-ioband. > > Changes from the previous release: > - Fix a bug that create_workqueue() is called during spin lock > when creating a new ioband group. > - A new tunable parameter "carryover" is added, which specifies > how many tokens an ioband group can keep for the future use > when the group isn't so active. > > TODO: > - Other policies to schedule BIOs. > - Policies which fits SSD. > e.g.) > - Guarantee response time. > - Guarantee throughput. > - Policies which fits Highend Storage or hardware raid storage. > - Some LUNs may share the same bandwidth. > - Support WRITE_BARRIER when the device-mapper layer supports it. > - Implement the algorithm of dm-ioband in the block I/O layer > experimentally. > > bio-cgroup > ========== > > Bio-cgroup is a BIO tracking mechanism, which is implemented on the > cgroup memory subsystem. With the mechanism, it is able to determine > which cgroup each of bio belongs to, even when the bio is one of > delayed-write requests issued from a kernel thread such as pdflush. > > Changes from the previous release: > - This release is a new implementation. > - This is based on the new design of the cgroup memory controller > framework, which pre-allocates all cgroup-page data structures to > reduce the overhead. > - The overhead to trace block I/O requests is much smaller than that > of the previous one. This is done by making every page have the id > of its corresponding bio-cgroup instead of the pointer to it and > most of spin-locks and atomic operations are gone. > - This implementation uses only 4 bytes per page for I/O tracking > while the previous version uses 12 bytes on a 32 bit machine and 24 > bytes on a 64 bit machine. > - The accuracy of I/O tracking is improved that it can trace I/O > requests even when the processes which issued these requests get > moved into another bio-cgroup. > - Support bounce buffers tracking. They will have the same bio-cgroup > owners as the original I/O requests. > > TODO: > - Support to track I/O requests that will be generated in Linux > kernel, such as those of RAID0 and RAID5. > > A list of patches > ================= > > The following is a list of patches: > > [PATCH 0/8] I/O bandwidth controller and BIO tracking > [PATCH 1/8] dm-ioband: Introduction > [PATCH 2/8] dm-ioband: Source code and patch > [PATCH 3/8] dm-ioband: Document > [PATCH 4/8] bio-cgroup: Introduction > [PATCH 5/8] bio-cgroup: The new page_cgroup framework > [PATCH 6/8] bio-cgroup: The body of bio-cgroup > [PATCH 7/8] bio-cgroup: Page tracking hooks > [PATCH 8/8] bio-cgroup: Add a cgroup support to dm-ioband > > Please see the following site for more information: > Linux Block I/O Bandwidth Control Project > http://people.valinux.co.jp/~ryov/bwctl/ > > Thanks, > Ryo Tsuruta > ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [dm-devel] Re: [PATCH 0/8] I/O bandwidth controller and BIO tracking 2008-11-13 6:30 ` [PATCH 0/8] I/O bandwidth controller and BIO tracking KAMEZAWA Hiroyuki @ 2008-11-13 7:26 ` Hirokazu Takahashi 2008-11-13 16:20 ` Balbir Singh 0 siblings, 1 reply; 19+ messages in thread From: Hirokazu Takahashi @ 2008-11-13 7:26 UTC (permalink / raw) To: kamezawa.hiroyu, Paul Menage Cc: dm-devel, ryov, xen-devel, containers, lizf, linux-kernel, virtualization, agk, menage, xemul, fernando, balbir Hi, Kamezawa-san, > > Hi everyone, > > > > This is a new release of dm-ioband and bio-cgroup. With this release, > > the overhead of bio-cgroup is significantly reduced and the accuracy > > of block I/O tracking is much improved. These patches are for > > 2.6.28-rc2-mm1. > > > > >From my point of view, a way to record bio_cgroup_id to page_cgroup is quite neat > and nice. > > My concern is "bio_cgroup_id". It's provided only for bio_cgroup. > In this summer, I tried to add swap_cgroup_id only for mem+swap controller but > commenters said "please provide "id and lookup" in cgroup layer, it should be useful." > And I agree them. (and postponed it ;) Yup, that sounds really good. > Could you try "id" in cgroup layer ? How do you think, Paul and others ? It seems to easy to implement this feature since what I need to do is move the code from bio-group to there. Okay, I'll start it if Paul agrees with this approach. > That's my only concern and if I/O controller people decides to live with > this bio tracking infrastracture, > == > page -> page_cgroup -> bio_cgroup_id > == > I have no objections. And enqueue necessary changes to my queue. It would be nice if you can include the following patch, which just makes the page_cgroup infrastructure can be compiled in even when the cgroup memory controller is compiled out. > Thanks, > -Kame Thank you, Hirokazu Takahashi. --------------------------- This patch makes the page_cgroup framework be able to be used even if the compile option of the cgroup memory controller is off. So bio-cgroup can use this framework without the memory controller. Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> diff -dupr linux-2.6.28-rc2.bc0/include/linux/memcontrol.h linux-2.6.28-rc2/include/linux/memcontrol.h --- linux-2.6.28-rc2.bc0/include/linux/memcontrol.h 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/memcontrol.h 2008-11-11 13:51:42.000000000 +0900 @@ -27,6 +27,9 @@ struct mm_struct; #ifdef CONFIG_CGROUP_MEM_RES_CTLR +extern void __init_mem_page_cgroup(struct page_cgroup *pc); +#define mem_cgroup_disabled() mem_cgroup_subsys.disabled + extern int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm, gfp_t gfp_mask); /* for swap handling */ @@ -81,6 +84,15 @@ extern long mem_cgroup_calc_reclaim(stru #else /* CONFIG_CGROUP_MEM_RES_CTLR */ struct mem_cgroup; +static inline void __init_mem_page_cgroup(struct page_cgroup *pc) +{ +} + +static inline int mem_cgroup_disabled(void) +{ + return 1; +} + static inline int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm, gfp_t gfp_mask) { diff -dupr linux-2.6.28-rc2.bc0/include/linux/mmzone.h linux-2.6.28-rc2/include/linux/mmzone.h --- linux-2.6.28-rc2.bc0/include/linux/mmzone.h 2008-11-10 18:50:50.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/mmzone.h 2008-11-11 13:51:42.000000000 +0900 @@ -603,7 +603,7 @@ typedef struct pglist_data { int nr_zones; #ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */ struct page *node_mem_map; -#ifdef CONFIG_CGROUP_MEM_RES_CTLR +#ifdef CONFIG_CGROUP_PAGE struct page_cgroup *node_page_cgroup; #endif #endif @@ -952,7 +952,7 @@ struct mem_section { /* See declaration of similar field in struct zone */ unsigned long *pageblock_flags; -#ifdef CONFIG_CGROUP_MEM_RES_CTLR +#ifdef CONFIG_CGROUP_PAGE /* * If !SPARSEMEM, pgdat doesn't have page_cgroup pointer. We use * section. (see memcontrol.h/page_cgroup.h about this.) diff -dupr linux-2.6.28-rc2.bc0/include/linux/page_cgroup.h linux-2.6.28-rc2/include/linux/page_cgroup.h --- linux-2.6.28-rc2.bc0/include/linux/page_cgroup.h 2008-11-10 19:29:00.000000000 +0900 +++ linux-2.6.28-rc2/include/linux/page_cgroup.h 2008-11-11 14:46:47.000000000 +0900 @@ -1,7 +1,7 @@ #ifndef __LINUX_PAGE_CGROUP_H #define __LINUX_PAGE_CGROUP_H -#ifdef CONFIG_CGROUP_MEM_RES_CTLR +#ifdef CONFIG_CGROUP_PAGE #include <linux/bit_spinlock.h> /* * Page Cgroup can be considered as an extended mem_map. @@ -12,9 +12,11 @@ */ struct page_cgroup { unsigned long flags; - struct mem_cgroup *mem_cgroup; struct page *page; +#ifdef CONFIG_CGROUP_MEM_RES_CTLR + struct mem_cgroup *mem_cgroup; struct list_head lru; /* per cgroup LRU list */ +#endif }; void __init pgdat_page_cgroup_init(struct pglist_data *pgdat); @@ -88,7 +90,7 @@ static inline void unlock_page_cgroup(st bit_spin_unlock(PCG_LOCK, &pc->flags); } -#else /* CONFIG_CGROUP_MEM_RES_CTLR */ +#else /* CONFIG_CGROUP_PAGE */ struct page_cgroup; static inline void pgdat_page_cgroup_init(struct pglist_data *pgdat) diff -dupr linux-2.6.28-rc2.bc0/init/Kconfig linux-2.6.28-rc2/init/Kconfig --- linux-2.6.28-rc2.bc0/init/Kconfig 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/init/Kconfig 2008-11-11 14:46:47.000000000 +0900 @@ -425,6 +425,10 @@ config CGROUP_MEM_RES_CTLR This config option also selects MM_OWNER config option, which could in turn add some fork/exit overhead. +config CGROUP_PAGE + def_bool y + depends on CGROUP_MEM_RES_CTLR + config MM_OWNER bool diff -dupr linux-2.6.28-rc2.bc0/mm/Makefile linux-2.6.28-rc2/mm/Makefile --- linux-2.6.28-rc2.bc0/mm/Makefile 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/mm/Makefile 2008-11-11 14:46:47.000000000 +0900 @@ -34,5 +34,6 @@ obj-$(CONFIG_FS_XIP) += filemap_xip.o obj-$(CONFIG_MIGRATION) += migrate.o obj-$(CONFIG_SMP) += allocpercpu.o cpu_alloc.o obj-$(CONFIG_QUICKLIST) += quicklist.o -obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o page_cgroup.o +obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o +obj-$(CONFIG_CGROUP_PAGE) += page_cgroup.o obj-$(CONFIG_KMEMTRACE) += kmemtrace.o diff -dupr linux-2.6.28-rc2.bc0/mm/memcontrol.c linux-2.6.28-rc2/mm/memcontrol.c --- linux-2.6.28-rc2.bc0/mm/memcontrol.c 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/mm/memcontrol.c 2008-11-11 14:48:17.000000000 +0900 @@ -157,6 +157,11 @@ pcg_default_flags[NR_CHARGE_TYPE] = { 0, /* FORCE */ }; +void __meminit __init_mem_page_cgroup(struct page_cgroup *pc) +{ + pc->mem_cgroup = NULL; +} + /* * Always modified under lru lock. Then, not necessary to preempt_disable() */ diff -dupr linux-2.6.28-rc2.bc0/mm/page_cgroup.c linux-2.6.28-rc2/mm/page_cgroup.c --- linux-2.6.28-rc2.bc0/mm/page_cgroup.c 2008-11-10 18:31:34.000000000 +0900 +++ linux-2.6.28-rc2/mm/page_cgroup.c 2008-11-11 14:46:47.000000000 +0900 @@ -8,13 +8,14 @@ #include <linux/memory.h> #include <linux/vmalloc.h> #include <linux/cgroup.h> +#include <linux/memcontrol.h> static void __meminit __init_page_cgroup(struct page_cgroup *pc, unsigned long pfn) { pc->flags = 0; - pc->mem_cgroup = NULL; pc->page = pfn_to_page(pfn); + __init_mem_page_cgroup(pc); } static unsigned long total_usage; @@ -69,7 +70,7 @@ void __init page_cgroup_init(void) int nid, fail; - if (mem_cgroup_subsys.disabled) + if (mem_cgroup_disabled()) return; for_each_online_node(nid) { @@ -229,7 +230,7 @@ void __init page_cgroup_init(void) unsigned long pfn; int fail = 0; - if (mem_cgroup_subsys.disabled) + if (mem_cgroup_disabled()) return; for (pfn = 0; !fail && pfn < max_pfn; pfn += PAGES_PER_SECTION) { ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [dm-devel] Re: [PATCH 0/8] I/O bandwidth controller and BIO tracking 2008-11-13 7:26 ` [dm-devel] " Hirokazu Takahashi @ 2008-11-13 16:20 ` Balbir Singh 2008-11-13 23:15 ` Hirokazu Takahashi 0 siblings, 1 reply; 19+ messages in thread From: Balbir Singh @ 2008-11-13 16:20 UTC (permalink / raw) To: Hirokazu Takahashi Cc: kamezawa.hiroyu, Paul Menage, xen-devel, containers, linux-kernel, virtualization, dm-devel, agk, fernando, xemul Hirokazu Takahashi wrote: > Hi, Kamezawa-san, > > This patch makes the page_cgroup framework be able to be used even if > the compile option of the cgroup memory controller is off. > So bio-cgroup can use this framework without the memory controller. > > Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> > > diff -dupr linux-2.6.28-rc2.bc0/include/linux/memcontrol.h linux-2.6.28-rc2/include/linux/memcontrol.h > --- linux-2.6.28-rc2.bc0/include/linux/memcontrol.h 2008-11-10 18:31:34.000000000 +0900 > +++ linux-2.6.28-rc2/include/linux/memcontrol.h 2008-11-11 13:51:42.000000000 +0900 > @@ -27,6 +27,9 @@ struct mm_struct; > > #ifdef CONFIG_CGROUP_MEM_RES_CTLR > > +extern void __init_mem_page_cgroup(struct page_cgroup *pc); > +#define mem_cgroup_disabled() mem_cgroup_subsys.disabled > + > extern int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm, > gfp_t gfp_mask); > /* for swap handling */ > @@ -81,6 +84,15 @@ extern long mem_cgroup_calc_reclaim(stru > #else /* CONFIG_CGROUP_MEM_RES_CTLR */ > struct mem_cgroup; > > +static inline void __init_mem_page_cgroup(struct page_cgroup *pc) > +{ > +} > + > +static inline int mem_cgroup_disabled(void) > +{ > + return 1; > +} > + With CONFIG_CGROUP_MEM_RES_CTLR not defined, page_cgroup init routines will just return, is that what bio page_cgroup needs? -- Balbir ^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [dm-devel] Re: [PATCH 0/8] I/O bandwidth controller and BIO tracking 2008-11-13 16:20 ` Balbir Singh @ 2008-11-13 23:15 ` Hirokazu Takahashi 0 siblings, 0 replies; 19+ messages in thread From: Hirokazu Takahashi @ 2008-11-13 23:15 UTC (permalink / raw) To: balbir Cc: kamezawa.hiroyu, menage, xen-devel, containers, linux-kernel, virtualization, dm-devel, agk, fernando, xemul Hi, Balbir, > Hirokazu Takahashi wrote: > > Hi, Kamezawa-san, > > > > This patch makes the page_cgroup framework be able to be used even if > > the compile option of the cgroup memory controller is off. > > So bio-cgroup can use this framework without the memory controller. > > > > Signed-off-by: Hirokazu Takahashi <taka@valinux.co.jp> > > > > diff -dupr linux-2.6.28-rc2.bc0/include/linux/memcontrol.h linux-2.6.28-rc2/include/linux/memcontrol.h > > --- linux-2.6.28-rc2.bc0/include/linux/memcontrol.h 2008-11-10 18:31:34.000000000 +0900 > > +++ linux-2.6.28-rc2/include/linux/memcontrol.h 2008-11-11 13:51:42.000000000 +0900 > > @@ -27,6 +27,9 @@ struct mm_struct; > > > > #ifdef CONFIG_CGROUP_MEM_RES_CTLR > > > > +extern void __init_mem_page_cgroup(struct page_cgroup *pc); > > +#define mem_cgroup_disabled() mem_cgroup_subsys.disabled > > + > > extern int mem_cgroup_newpage_charge(struct page *page, struct mm_struct *mm, > > gfp_t gfp_mask); > > /* for swap handling */ > > @@ -81,6 +84,15 @@ extern long mem_cgroup_calc_reclaim(stru > > #else /* CONFIG_CGROUP_MEM_RES_CTLR */ > > struct mem_cgroup; > > > > +static inline void __init_mem_page_cgroup(struct page_cgroup *pc) > > +{ > > +} > > + > > +static inline int mem_cgroup_disabled(void) > > +{ > > + return 1; > > +} > > + > > With CONFIG_CGROUP_MEM_RES_CTLR not defined, page_cgroup init routines will just > return, is that what bio page_cgroup needs? > > -- > Balbir One of the other patches includes the following code, which calls __init_bio_page_cgroup() to initialize bio-cgroup thing. +++ linux-2.6.28-rc2/mm/page_cgroup.c 2008-11-12 11:20:33.000000000 +0900 @@ -9,6 +9,7 @@ #include <linux/vmalloc.h> #include <linux/cgroup.h> #include <linux/memcontrol.h> +#include <linux/biotrack.h> static void __meminit __init_page_cgroup(struct page_cgroup *pc, unsigned long pfn) @@ -16,6 +17,7 @@ __init_page_cgroup(struct page_cgroup *p pc->flags = 0; pc->page = pfn_to_page(pfn); __init_mem_page_cgroup(pc); + __init_bio_page_cgroup(pc); } static unsigned long total_usage; ^ permalink raw reply [flat|nested] 19+ messages in thread
end of thread, other threads:[~2008-11-17 7:48 UTC | newest] Thread overview: 19+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2008-11-13 3:10 [PATCH 0/8] I/O bandwidth controller and BIO tracking Ryo Tsuruta 2008-11-13 3:11 ` [PATCH 1/8] dm-ioband: Introduction Ryo Tsuruta 2008-11-13 3:12 ` [PATCH 2/8] dm-ioband: Source code and patch Ryo Tsuruta 2008-11-13 3:12 ` [PATCH 3/8] dm-ioband: Document Ryo Tsuruta 2008-11-13 3:13 ` [PATCH 4/8] bio-cgroup: Introduction Ryo Tsuruta 2008-11-13 3:13 ` [PATCH 5/8] bio-cgroup: The new page_cgroup framework Ryo Tsuruta 2008-11-13 3:14 ` [PATCH 6/8] bio-cgroup: The body of bio-cgroup Ryo Tsuruta 2008-11-13 3:15 ` [PATCH 7/8] bio-cgroup: Page tracking hooks Ryo Tsuruta 2008-11-13 3:15 ` [PATCH 8/8] bio-cgroup: Add a cgroup support to dm-ioband Ryo Tsuruta 2008-11-14 7:01 ` [PATCH 6/8] bio-cgroup: The body of bio-cgroup Takuya Yoshikawa 2008-11-16 11:46 ` Hirokazu Takahashi 2008-11-17 7:50 ` [PATCH 6/8]Re: " Takuya Yoshikawa 2008-11-13 19:36 ` [dm-devel] [PATCH 1/8] dm-ioband: Introduction Phillip Susi 2008-11-13 23:18 ` Hirokazu Takahashi 2008-11-14 1:38 ` Ryo Tsuruta 2008-11-13 6:30 ` [PATCH 0/8] I/O bandwidth controller and BIO tracking KAMEZAWA Hiroyuki 2008-11-13 7:26 ` [dm-devel] " Hirokazu Takahashi 2008-11-13 16:20 ` Balbir Singh 2008-11-13 23:15 ` Hirokazu Takahashi
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox