[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-devel] [PATCH] dm-ioband-v1.12.2: I/O bandwidth controller



Hi Alasdair,

This is dm-ioband v1.12.2 release that is a minor update to fit the
current dm-devel tree.
  
Could you please replace dm-add-ioband.patch in your tree with this
patch? And I would appreciate it if you would let me know your
thoughts about merging dm-ioband to upstream.

Thanks,
Ryo Tsuruta

About dm-ioband:
dm-ioband is an I/O bandwidth controller implemented as a
device-mapper driver and can control bandwidth on per partition, per
user, per process, per virtual machine (such as KVM or Xen) basis.
Please visit our website for further information.
http://sourceforge.net/apps/trac/ioband/

Signed-off-by: Ryo Tsuruta <ryov@xxxxxxxxxxxxx>
Signed-off-by: Hirokazu Takahashi <taka@xxxxxxxxxxxxx>

---
 Documentation/device-mapper/ioband.txt   | 1113 ++++++++++++++++++++++++++
 Documentation/device-mapper/range-bw.txt |   99 ++
 drivers/md/Kconfig                       |   13 
 drivers/md/Makefile                      |    3 
 drivers/md/dm-ioband-ctl.c               | 1322 +++++++++++++++++++++++++++++++
 drivers/md/dm-ioband-policy.c            |  459 ++++++++++
 drivers/md/dm-ioband-rangebw.c           |  673 +++++++++++++++
 drivers/md/dm-ioband-type.c              |   76 +
 drivers/md/dm-ioband.h                   |  228 +++++
 include/trace/events/dm-ioband.h         |  242 +++++
 10 files changed, 4228 insertions(+)

Index: linux-2.6.31-rc4/Documentation/device-mapper/ioband.txt
===================================================================
--- /dev/null
+++ linux-2.6.31-rc4/Documentation/device-mapper/ioband.txt
@@ -0,0 +1,1113 @@
+                     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 block device have to share the
+   bandwidth of the device. dm-ioband gives bandwidth to each job according
+   to bandwidth control policies.
+
+     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 blkio-cgroup patch, which can be found at
+   http://sourceforge.net/apps/trac/ioband/.
+
+       +-------+ +-------+ +-------+ +-------+ +-------+ +-------+
+       |cgroup | |cgroup | |  the  | |  pid  | |  pid  | |  the  |   jobs
+       |   A   | |   B   | |others | |   X   | |   Y   | |others |
+       +---|---+ +---|---+ +---|---+ +---|---+ +---|---+ +---|---+
+           |         |         |         |         |         |
+     +-----|---------|---------|----+----|---------|---------|-----+
+     |     | /dev/mapper/disk1 |    |    | /dev/mapper/disk2 |     |
+     |-----|---------|---------|----+----|---------|---------|-----|
+     | +---V---+ +---V---+ +---V---+ +---V---+ +---V---+ +---V---+ |
+     | | ioband| | ioband| |default| | ioband| | ioband| |default| |
+     | | group | | group | | group | | group | | group | | group | | dm-ioband
+     | |-------+-+-------+-+-------+-+-------+-+-------+-+-------| |
+     | |                     bandwidth control                   | |
+     | +-------------|-----------------------------|-------------+ |
+      ---------------|-----------------------------|---------------
+                     |                             |
+     +---------------V--------------+--------------V---------------+
+     |           /dev/sdb1          |          /dev/sdb2           | partitions
+     +------------------------------+------------------------------+
+
+
+   --------------------------------------------------------------------------
+
+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 block
+   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.
+
+     The bandwidth of each job is determined by a bandwidth control policy.
+   dm-ioband provides three kinds of policies "weight", "weight-iosize" and
+   "range-bw", and a user can select one of them at the time of setup.
+
+   --------------------------------------------------------------------------
+
+  weight and weight-iosize policy
+
+     Every ioband device has one ioband group, which by default is called the
+   default group, and can also have extra ioband groups in the ioband device.
+   Each ioband group has its own weight and tokens. The amount of tokens are
+   determined proportional to the weight of each ioband group.
+
+     The ioband group can pass 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 ioband group. The tokens are
+   refilled once all of the ioband groups that have requests on a given
+   underlying block device use up their tokens.
+
+     The weight policy lets dm-ioband consume one token per one I/O request.
+   The weight-iosize policy lets dm-ioband consume one token per one I/O
+   sector, for example, one I/O request which consists of 4Kbytes (512bytes *
+   8 sectors) read consumes 8 tokens.
+
+     With this approach, a job running on the ioband group with large weight
+   is guaranteed a wide I/O bandwidth.
+
+   --------------------------------------------------------------------------
+
+  range-bw policy
+
+     range-bw means the predicable I/O bandwidth with minimum and maximum
+   value defined by administrator. And it is also possible to set up only
+   maximum value for only I/O limitation. So, you can define the specific and
+   fixed bandwidth to satisfy I/O requirement regardless of whole I/O
+   bandwidth.
+
+     Minimum I/O bandwidth is to guarantee the stable performance or
+   reliability of specific process group and maximum bandwidth is to throttle
+   the unnecessary I/O usage or to reserve the I/O bandwidth for another use.
+   So range-bw supports adequate and predicable I/O bandwidth between minimum
+   and maximum value.
+
+     The setting unit is based on Kbytes/sec. If you want to allocate
+   3M~5Mbytes/sec I/O bandwidth to X group, you should set 3000 to min-bw,
+   5000 to max-bw.
+
+     Attention
+
+     Although range-bw supports the predicable I/O bandwidth, it should be
+   configured in the scope of total I/O bandwidth of the I/O system to
+   guarantee the minimum I/O requirement. For example, if total I/O bandwidth
+   is 40Mbytes/sec, the summary of I/O bandwidth configured in each process
+   group should be equal or smaller than 40Mbytes/sec. So, we need to check
+   total I/O bandwidth before set it up.
+
+   --------------------------------------------------------------------------
+
+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.0.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 "/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."
+
+     First, set the ioband group type as user. Next, create two ioband groups
+   that have id 1000 and 2000. Then, give weights of 30 and 20 to the ioband
+   groups 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 owned by uid 1000 can use 30% --- 30/(30+20+40+10)*100
+   --- of the bandwidth of "/dev/sda" when the processes issue I/O requests
+   through "ioband1." The processes owned by uid 2000 can use 20% of the
+   bandwidth likewise.
+
+   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 policy_args...
+
+
+                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 for an ioband device can be symbolic,
+                        numeric, or mixed. The same ID must be set among the
+                        ioband devices that share the same bandwidth. This is
+                        useful for grouping disk drives partitioned from one
+                        disk drive such as RAID drive or LVM logical striped
+                        volume.
+
+                io_throttle
+
+                          When a device has a lot of tokens, and the number
+                        of in-flight I/Os in dm-ioband exceeds io_throttle,
+                        dm-ioband gives priority to the device and issues
+                        I/Os to the device until no tokens of the device are
+                        left. If 0 is specified, the default value is used.
+                        This setting applies all ioband devices which has the
+                        same ioband device ID as you specified by
+                        "ioband_device_id."
+
+                io_limit
+
+                          Dm-ioband blocks all I/O requests for IOBAND_DEVICE
+                        when the number of BIOs in progress exceeds this
+                        value. If 0 is specified, the default value is used.
+                        This setting applies all ioband devices which has the
+                        same ioband device ID as you specified by
+                        "ioband_device_id."
+
+                ioband_group_type
+
+                          Specify how to evaluate the ioband group ID. The
+                        selectable group types are "none", "user", "gid",
+                        "pid" or "pgrp." The type "cgroup" is enabled by
+                        applying the blkio-cgroup patch. Specify "none" if
+                        you don't need any ioband groups other than the
+                        default ioband group.
+
+                policy and policy_args
+
+                          Specify a bandwidth control policy. The selectable
+                        policies are "weight", "weight-iosize" or "range-bw."
+                        This setting applies all ioband devices which has the
+                        same ioband device ID as you specified by
+                        "ioband_device_id."
+
+                          policy_args are specific for each policy. See below
+                        for information on each policy.
+
+   WEIGHT AND WEIGHT-IOSIZE POLICIES
+
+             The "weight" and "weight-iosize" policies distribute bandwidth
+           proportional to the weight of each ioband group. Each ioband group
+           is charged on an I/O count basis when the "weight" policy is used
+           and an I/O size basis when the "weight-iosize" policy is used. The
+           arguments are of the form:
+
+             token_base :weight [ioband_group_id:weight...]
+
+
+                token_base
+
+                          The number of tokens which specified by token_base
+                        will be distributed to all ioband groups proportional
+                        to the weight of each ioband group. If 0 is
+                        specified, the default value is used. This setting
+                        applies all ioband devices which has the same ioband
+                        device ID as you specified by "ioband_device_id."
+
+                :weight
+
+                          Set the weight of the default ioband group.
+
+                ioband_group_id:weight
+
+                          Create an extra ioband group with an
+                        ioband_group_id and set its weight. The
+                        ioband_group_id is an identification number and
+                        corresponds to pid, pgrp , uid and so on which depend
+                        on ioband group type settings.
+
+   RANGE-BW POLICY
+
+             The "range-bw" policy distributes the predicable bandwidth to
+           each group according to the values of minimum and maximum
+           bandwidth value. And range-bw is not based on I/O token which is
+           usually grant for I/O authority.
+
+             So, "0" value is used for token_base parameter in range-bw
+           policy. And both parameters, min-bw and max-bw, are generally used
+           together, but, max-bw can be used alone for only limitation. The
+           arguments are of the form:
+
+             token_base :min-bw:max-bw [ioband_group_id:min-bw:max-bw...]
+
+
+                token_base
+
+                          "0" is used, because it is not meaningful in this
+                        policy
+
+                min-bw
+
+                          Set the minimum bandwidth of the default ioband
+                        group. This parameter can't be used alone.
+
+                max-bw
+
+                          Set the maximum bandwidth of the default ioband
+                        group.
+
+                ioband_group_id:min-bw:max-bw
+
+                          Create an extra ioband group with an
+                        ioband_group_id and set its min and max bandwidth.
+                        The ioband_group_id is an identification number and
+                        corresponds to pid, pgrp , uid and so on which depend
+                        on ioband group type settings.
+
+   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 = "share1"
+
+              *   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" \
+               "share1 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 an ioband group type of IOBAND_DEVICE. TYPE must be one of
+           "none", "user", "gid", "pid" or "pgrp." The type "cgroup" is
+           enabled by applying the blkio-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 POLICY to a bandwidth control policy. The selectable
+           policies are "weight", "weight-iosize" and "range-bw." This
+           setting applies all ioband devices which has the same ioband
+           device ID as IOBAND_DEVICE.
+
+                weight
+
+                          This policy distributes bandwidth proportional to
+                        the weight of each ioband group. Each ioband group is
+                        charged on an I/O count basis.
+
+                weight-iosize
+
+                          This policy distributes bandwidth proportional to
+                        the weight of each ioband group. Each ioband group is
+                        charged on an I/O size basis.
+
+                range-bw
+
+                          This policy guarantees minimum bandwidth and limits
+                        maximum bandwidth for each ioband group.
+
+   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 which belongs to
+           IOBAND_DEVICE. The group is determined by ID. If ID: is omitted,
+           the default ioband group is chosen.
+
+             The following example means that "ioband1" can use 80% ---
+           40/(40+10)*100 --- of the bandwidth of the underlying block device
+           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 range-bw of an ioband group
+
+   SYNOPSIS
+
+           dmsetup -- message IOBAND_DEVICE 0 range-bw -1:MIN:MAX
+
+           dmsetup message IOBAND_DEVICE 0 range-bw ID:MIN-BW:MAX-BW
+
+   DESCRIPTION
+
+             Set the range-bw of the ioband group which belongs to
+           IOBAND_DEVICE. The group is determined by ID. If -1 is specified
+           as ID, the default ioband group is chosen.
+
+             The following example means that "ioband1" can use
+           5M~6Mbytes/sec bandwidth of the underlying block device while
+           "ioband2" can use 900K~1Mbytes/sec bandwidth.
+
+             # dmsetup message -- ioband1 0 range-bw -1:5000:6000
+
+             # dmsetup message -- ioband2 0 range-bw -1:900:1000
+
+
+             MIN-BW and MAX-BW and must be an integer larger than 0 and its
+           unit is Kbyte/sec.
+
+   EXAMPLE
+
+             Set the range-bw of the default ioband group of "ioband1" to
+           200K~300K I/O bandwidth.
+
+             # dmsetup -- message ioband1 0 range-bw -1:200:300
+
+
+             Set the weight of the ioband group of "ioband1" with ID "1000"
+           to 10M~12M I/O bandwidth.
+
+             # dmsetup message ioband1 0 range-bw 1000:10000:12000
+
+
+   --------------------------------------------------------------------------
+
+  Set the number of tokens
+
+   SYNOPSIS
+
+           dmsetup message IOBAND_DEVICE 0 token VAL
+
+   DESCRIPTION
+
+             The number of tokens will be distributed to all ioband groups
+           proportional to the weight of each ioband group. If 0 is
+           specified, the default value is used. This setting applies all
+           ioband devices which has the same ioband device ID as
+           IOBAND_DEVICE
+
+   EXAMPLE
+
+             Set the number of tokens 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. This setting applies all
+           ioband devices which has the same ioband device ID as
+           IOBAND_DEVICE.
+
+   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
+
+             When a device has a lot of tokens, and the number of in-flight
+           I/Os in dm-ioband exceeds io_throttle, dm-ioband gives priority to
+           the device and issues I/Os to the device until no tokens of the
+           device are left. If 0 is specified, the default value is used.
+           This setting applies all ioband devices which has the same ioband
+           device ID as you specified by "ioband_device_id."
+
+   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
+
+             Dm-ioband blocks all I/O requests for IOBAND_DEVICE when the
+           number of BIOs in progress exceeds this value. If 0 is specified,
+           the default value is used. This setting applies all ioband devices
+           which has the same ioband device ID as IOBAND_DEVICE.
+
+   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        | partitions
+     +---------------------------+---------------------------+
+
+
+     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 disks
+     +--------------------------+ +--------------------------+
+
+
+     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 #4: 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        | partitions
+     +---------------------------+---------------------------+
+
+
+     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 #3: 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        | partitions
+     +---------------------------+---------------------------+
+
+
+     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 #4: 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---------+
+        |       tapdisk       |     |        tapdisk      |    tapdisk daemons
+        |       (15011)       |     |        (15276)      |    (daemon's pid)
+        +----------|----------+     +-----------|---------+
+                   |                            |
+     +-------------|----------------------------|------------+
+     |             |     /dev/mapper/ioband1    |            | ioband device
+     |             |       mount on /vmdisk     |            |
+     +-------------V-------------+--------------V------------+
+     |     group for PID=15011   |    group for PID=15276    | ioband groups
+     |           (80)            |            (40)           |    (weight)
+     +-------------|----------------------------|------------+
+                   |                            |
+     +-------------|----------------------------|------------+
+     |  +----------V----------+     +-----------V---------+  |
+     |  |       vm1.img       |     |        vm2.img      |  | disk image files
+     |  +---------------------+     +---------------------+  |
+     |                       /dev/sda1                       | partition
+     +-------------------------------------------------------+
+
+
+     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
Index: linux-2.6.31-rc4/drivers/md/Kconfig
===================================================================
--- linux-2.6.31-rc4.orig/drivers/md/Kconfig
+++ linux-2.6.31-rc4/drivers/md/Kconfig
@@ -294,4 +294,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
Index: linux-2.6.31-rc4/drivers/md/Makefile
===================================================================
--- linux-2.6.31-rc4.orig/drivers/md/Makefile
+++ linux-2.6.31-rc4/drivers/md/Makefile
@@ -8,6 +8,8 @@ dm-multipath-y  += dm-path-selector.o dm-
 dm-snapshot-y  += dm-snap.o dm-exception-store.o dm-snap-transient.o \
                    dm-snap-persistent.o
 dm-mirror-y    += dm-raid1.o
+dm-ioband-y    += dm-ioband-ctl.o dm-ioband-policy.o dm-ioband-rangebw.o \
+                   dm-ioband-type.o
 dm-log-userspace-y \
                += dm-log-userspace-base.o dm-log-userspace-transfer.o
 md-mod-y       += md.o bitmap.o
@@ -37,6 +39,7 @@ obj-$(CONFIG_BLK_DEV_MD)      += md-mod.o
 obj-$(CONFIG_BLK_DEV_DM)       += dm-mod.o
 obj-$(CONFIG_DM_CRYPT)         += dm-crypt.o
 obj-$(CONFIG_DM_DELAY)         += dm-delay.o
+obj-$(CONFIG_DM_IOBAND)                += dm-ioband.o
 obj-$(CONFIG_DM_MULTIPATH)     += dm-multipath.o dm-round-robin.o
 obj-$(CONFIG_DM_MULTIPATH_QL)  += dm-queue-length.o
 obj-$(CONFIG_DM_MULTIPATH_ST)  += dm-service-time.o
Index: linux-2.6.31-rc4/drivers/md/dm-ioband-ctl.c
===================================================================
--- /dev/null
+++ linux-2.6.31-rc4/drivers/md/dm-ioband-ctl.c
@@ -0,0 +1,1322 @@
+/*
+ * Copyright (C) 2008-2009 VA Linux Systems Japan K.K.
+ * Authors: Hirokazu Takahashi <taka@xxxxxxxxxxxxx>
+ *          Ryo Tsuruta <ryov@xxxxxxxxxxxxx>
+ *
+ *  I/O bandwidth control
+ *
+ * Some blktrace messages were added by Alan D. Brunelle <Alan.Brunelle@xxxxxx>
+ *
+ * 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/rbtree.h>
+#include "dm.h"
+#include "md.h"
+#include "dm-ioband.h"
+
+#define CREATE_TRACE_POINTS
+#include <trace/events/dm-ioband.h>
+
+#define num_issued(dp) \
+       ((dp)->g_issued[BLK_RW_SYNC] + (dp)->g_issued[BLK_RW_ASYNC])
+
+static LIST_HEAD(ioband_device_list);
+/* lock up during configuration */
+static DEFINE_MUTEX(ioband_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 *, const char *, const char *);
+static int ioband_group_attach(struct ioband_group *, int, const char *);
+static int ioband_group_type_select(struct ioband_group *, const char *);
+
+static void do_nothing(void) {}
+
+static int policy_init(struct ioband_device *dp, const char *name,
+                                               int argc, char **argv)
+{
+       const struct ioband_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;
+       /* do nothing if the same policy is already set */
+       if (dp->g_policy == p)
+               return 0;
+
+       spin_lock_irqsave(&dp->g_lock, flags);
+       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 (!r) {
+               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(const char *name,
+                                               int io_throttle, int io_limit)
+{
+       struct ioband_device *dp, *new_dp;
+
+       new_dp = kzalloc(sizeof(struct ioband_device), GFP_KERNEL);
+       if (!new_dp)
+               return NULL;
+
+       /*
+        * Prepare its own workqueue as generic_make_request() may
+        * potentially block the workqueue when submitting BIOs.
+        */
+       new_dp->g_ioband_wq = create_workqueue("kioband");
+       if (!new_dp->g_ioband_wq) {
+               kfree(new_dp);
+               return NULL;
+       }
+
+       list_for_each_entry(dp, &ioband_device_list, g_list) {
+               if (!strcmp(dp->g_name, name)) {
+                       dp->g_ref++;
+                       destroy_workqueue(new_dp->g_ioband_wq);
+                       kfree(new_dp);
+                       return dp;
+               }
+       }
+
+       INIT_DELAYED_WORK(&new_dp->g_conductor, ioband_conduct);
+       INIT_LIST_HEAD(&new_dp->g_groups);
+       INIT_LIST_HEAD(&new_dp->g_list);
+       spin_lock_init(&new_dp->g_lock);
+       bio_list_init(&new_dp->g_urgent_bios);
+       new_dp->g_io_throttle = io_throttle;
+       new_dp->g_io_limit = io_limit;
+       new_dp->g_issued[BLK_RW_SYNC] = 0;
+       new_dp->g_issued[BLK_RW_ASYNC] = 0;
+       new_dp->g_blocked = 0;
+       new_dp->g_ref = 1;
+       new_dp->g_flags = 0;
+       strlcpy(new_dp->g_name, name, sizeof(new_dp->g_name));
+       new_dp->g_policy = NULL;
+       new_dp->g_hold_bio = NULL;
+       new_dp->g_pop_bio = NULL;
+       init_waitqueue_head(&new_dp->g_waitq);
+       init_waitqueue_head(&new_dp->g_waitq_suspend);
+       init_waitqueue_head(&new_dp->g_waitq_flush);
+       list_add_tail(&new_dp->g_list, &ioband_device_list);
+       return new_dp;
+}
+
+static void release_ioband_device(struct ioband_device *dp)
+{
+       dp->g_ref--;
+       if (dp->g_ref > 0)
+               return;
+       list_del(&dp->g_list);
+       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 && num_issued(dp) > 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 =
+                       rb_entry(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 **node = &root->rb_node, *parent = NULL;
+       struct ioband_group *p;
+
+       while (*node) {
+               p = rb_entry(*node, struct ioband_group, c_group_node);
+               parent = *node;
+               node = (gp->c_id < p->c_id) ?
+                               &(*node)->rb_left : &(*node)->rb_right;
+       }
+
+       rb_link_node(&gp->c_group_node, parent, node);
+       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, const 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("%s: id=%d already exists.", __func__, 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 *p;
+       unsigned long flags;
+
+       spin_lock_irqsave(&dp->g_lock, flags);
+       while ((p = ioband_group_find(gp, IOBAND_ID_ANY)))
+               ioband_group_release(gp, p);
+       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);
+       }
+       set_group_down(head);
+       if (suspend)
+               set_group_suspended(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);
+       }
+       clear_group_down(head);
+       clear_group_suspended(head);
+       spin_unlock_irqrestore(&dp->g_lock, flags);
+}
+
+static int parse_group_param(const char *param, long *id, char const **value)
+{
+       char *s, *endp;
+       long n;
+
+       s = strpbrk(param, POLICY_PARAM_DELIM);
+
+       if (!s) {
+               *id = IOBAND_ID_ANY;
+               *value = param;
+               return 0;
+       }
+
+       n = simple_strtol(param, &endp, 0);
+       if (endp != s)
+               return -EINVAL;
+
+       *id = n;
+       *value = s + 1;
+       return 0;
+}
+
+/*
+ * 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 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;
+       const char *param;
+       char *s;
+
+       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;
+       }
+
+       r = strict_strtol(argv[2], 0, &val);
+       if (r || val < 0 || val > SHORT_MAX) {
+               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 || val > SHORT_MAX) {
+               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;
+               }
+               /*
+                * The block layer accepts I/O requests up to 50% over
+                * nr_requests when the requests are issued from a
+                * "batcher" process.
+                */
+               io_limit = (3 * q->nr_requests / 2);
+       }
+
+       if (io_limit < io_throttle)
+               io_limit = io_throttle;
+
+       mutex_lock(&ioband_lock);
+       dp = alloc_ioband_device(argv[1], io_throttle, io_limit);
+       if (!dp) {
+               ti->error = "Cannot create ioband device";
+               r = -EINVAL;
+               mutex_unlock(&ioband_lock);
+               goto release_dm_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->num_flush_requests = 1;
+       ti->private = gp;
+       gp->c_target = ti;
+       gp->c_dev = dev;
+
+       /* Find a default group parameter */
+       for (start = POLICY_PARAM_START; start < argc; start++) {
+               s = strpbrk(argv[start], POLICY_PARAM_DELIM);
+               if (s == argv[start])
+                       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 = parse_group_param(argv[i], &id, &param);
+               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(&ioband_lock);
+       return 0;
+
+release_ioband_group:
+       ioband_group_destroy_all(gp);
+release_ioband_device:
+       release_ioband_device(dp);
+       mutex_unlock(&ioband_lock);
+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;
+       struct dm_dev *dev = gp->c_dev;
+
+       mutex_lock(&ioband_lock);
+
+       ioband_group_stop_all(gp, 0);
+       cancel_delayed_work_sync(&dp->g_conductor);
+       ioband_group_destroy_all(gp);
+
+       release_ioband_device(dp);
+       mutex_unlock(&ioband_lock);
+
+       dm_put_device(ti, dev);
+}
+
+static void ioband_hold_bio(struct ioband_group *gp, struct bio *bio)
+{
+       /* Todo: The list should be split into a sync list and an async 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 * 2) {
+               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 bool bio_is_sync(struct bio *bio)
+{
+       /* Must be the same condition as rw_is_sync() in blkdev.h */
+       return !bio_data_dir(bio) || bio_sync(bio);
+}
+
+static inline int prepare_to_issue(struct ioband_group *gp, struct bio *bio)
+{
+       struct ioband_device *dp = gp->c_banddev;
+
+       dp->g_issued[bio_is_sync(bio)]++;
+       return dp->g_prepare_bio(gp, bio, 0);
+}
+
+static inline int room_for_bio(struct ioband_device *dp)
+{
+       return dp->g_issued[BLK_RW_SYNC] < dp->g_io_limit
+               || dp->g_issued[BLK_RW_ASYNC] < dp->g_io_limit;
+}
+
+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)) {
+               dp->g_prepare_bio(gp, bio, IOBAND_URGENT);
+               bio_list_add(&dp->g_urgent_bios, bio);
+               trace_ioband_hold_urgent_bio(gp, bio);
+       } else {
+               gp->c_blocked++;
+               dp->g_hold_bio(gp, bio);
+               trace_ioband_hold_bio(gp, bio);
+       }
+}
+
+static inline int room_for_bio_sync(struct ioband_device *dp, int sync)
+{
+       return dp->g_issued[sync] < dp->g_io_limit;
+}
+
+static void push_prio_bio(struct ioband_group *gp, struct bio *bio, int sync)
+{
+       if (bio_list_empty(&gp->c_prio_bios))
+               set_prio_queue(gp, sync);
+       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);
+               trace_ioband_make_pback_list(gp, 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);
+               trace_ioband_make_issue_list(gp, 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_sync(dp, BLK_RW_ASYNC)) {
+               bio = bio_list_pop(&dp->g_urgent_bios);
+               if (!bio)
+                       return;
+               dp->g_blocked--;
+               dp->g_issued[bio_is_sync(bio)]++;
+               bio_list_add(issue_list, bio);
+               trace_ioband_release_urgent_bios(dp, 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 sync;
+       int ret;
+
+       if (bio_list_empty(&gp->c_prio_bios))
+               return R_OK;
+       sync = prio_queue_sync(gp);
+       while (gp->c_prio_blocked) {
+               if (!dp->g_can_submit(gp))
+                       return R_BLOCK;
+               if (!room_for_bio_sync(dp, sync))
+                       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 sync, 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;
+
+               sync = bio_is_sync(bio);
+               if (!room_for_bio_sync(dp, sync)) {
+                       push_prio_bio(gp, bio, sync);
+                       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 direct;
+
+       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;
+       if (bio_sectors(bio))
+               bio->bi_sector -= ti->begin;
+       direct = bio_data_dir(bio);
+
+       if (!gp->c_blocked && room_for_bio_sync(dp, bio_is_sync(bio))) {
+               if (dp->g_can_submit(gp)) {
+                       prepare_to_issue(gp, bio);
+                       gp->c_stat[direct].immediate++;
+                       gp->c_stat[direct].sectors += bio_sectors(bio);
+                       spin_unlock_irqrestore(&dp->g_lock, flags);
+                       return DM_MAPIO_REMAPPED;
+               } else if (!dp->g_blocked && num_issued(dp) == 0) {
+                       DMDEBUG("%s: token expired gp:%p", __func__, gp);
+                       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_sync(dp, prio_queue_sync(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 * 2) {
+               clear_device_blocked(dp);
+               wake_up_all(&dp->g_waitq);
+       }
+
+       if (dp->g_blocked &&
+           room_for_bio_sync(dp, BLK_RW_SYNC) &&
+           room_for_bio_sync(dp, BLK_RW_ASYNC) &&
+           bio_list_empty(&issue_list) && bio_list_empty(&pushback_list) &&
+           dp->g_restart_bios(dp)) {
+               DMDEBUG("%s: token expired dp:%p issued(%d,%d) g_blocked(%d)",
+                       __func__, dp,
+                       dp->g_issued[BLK_RW_SYNC], dp->g_issued[BLK_RW_ASYNC],
+                       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))) {
+               trace_ioband_make_request(dp, bio);
+               generic_make_request(bio);
+       }
+
+       while ((bio = bio_list_pop(&pushback_list))) {
+               trace_ioband_pushback_bio(dp, bio);
+               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_is_sync(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) && num_issued(dp) == 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;
+
+       ioband_group_stop_all(gp, 1);
+}
+
+static void ioband_resume(struct dm_target *ti)
+{
+       struct ioband_group *gp = ti->private;
+
+       ioband_group_resume_all(gp);
+}
+
+static void ioband_group_status(struct ioband_group *gp, int *szp,
+                               char *result, unsigned 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 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;
+
+       spin_lock_irqsave(&dp->g_lock, flags);
+
+       switch (type) {
+       case STATUSTYPE_INFO:
+               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);
+               }
+               break;
+
+       case STATUSTYPE_TABLE:
+               DMEMIT("%s %s %d %d %s %s",
+                      gp->c_dev->name, dp->g_name,
+                      dp->g_io_throttle, dp->g_io_limit,
+                      gp->c_type->t_name, dp->g_policy->p_name);
+               dp->g_show(gp, &sz, result, maxlen);
+               break;
+       }
+
+       spin_unlock_irqrestore(&dp->g_lock, flags);
+       return 0;
+}
+
+static int ioband_group_type_select(struct ioband_group *gp, const char *name)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       const struct ioband_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("%s: %s isn't supported.", __func__, 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,
+                               const char *cmd, const char *value)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       const char *val_str;
+       long id;
+       unsigned long flags;
+       int r;
+
+       r = parse_group_param(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("%s: id=%ld not found.", __func__, 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, const char *param)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       struct ioband_group *sub_gp;
+       int r;
+
+       if (id < 0) {
+               DMWARN("%s: invalid id:%d", __func__, id);
+               return -EINVAL;
+       }
+       if (!gp->c_type->t_getid) {
+               DMWARN("%s: no ioband group type is specified", __func__);
+               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("%s: invalid id:%d", __func__, 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("%s: invalid id:%d", __func__, 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 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], "io_throttle")) {
+               r = strict_strtol(argv[1], 0, &val);
+               if (r || val < 0 || val > SHORT_MAX)
+                       return -EINVAL;
+               if (val == 0)
+                       val = DEFAULT_IO_THROTTLE;
+               spin_lock_irqsave(&dp->g_lock, flags);
+               if (val > dp->g_io_limit) {
+                       spin_unlock_irqrestore(&dp->g_lock, flags);
+                       return -EINVAL;
+               }
+               dp->g_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 || val > SHORT_MAX)
+                       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;
+                       }
+                       /*
+                        * The block layer accepts I/O requests up to
+                        * 50% over nr_requests when the requests are
+                        * issued from a "batcher" process.
+                        */
+                       val = (3 * q->nr_requests / 2);
+               }
+               if (val < dp->g_io_throttle) {
+                       spin_unlock_irqrestore(&dp->g_lock, flags);
+                       return -EINVAL;
+               }
+               dp->g_io_limit = 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 argc, char **argv)
+{
+       int r;
+
+       mutex_lock(&ioband_lock);
+       r = __ioband_message(ti, argc, argv);
+       mutex_unlock(&ioband_lock);
+       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 int ioband_iterate_devices(struct dm_target *ti,
+                                 iterate_devices_callout_fn fn, void *data)
+{
+       struct ioband_group *gp = ti->private;
+
+       return fn(ti, gp->c_dev, 0, ti->len, data);
+}
+
+static struct target_type ioband_target = {
+       .name        = "ioband",
+       .module      = THIS_MODULE,
+       .version     = {1, 12, 2},
+       .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,
+       .iterate_devices = ioband_iterate_devices,
+};
+
+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;
+}
+
+static void __exit dm_ioband_exit(void)
+{
+       dm_unregister_target(&ioband_target);
+}
+
+module_init(dm_ioband_init);
+module_exit(dm_ioband_exit);
+
+MODULE_DESCRIPTION(DM_NAME " I/O bandwidth control");
+MODULE_AUTHOR("Hirokazu Takahashi, Ryo Tsuruta, Dong-Jae Kang");
+MODULE_LICENSE("GPL");
Index: linux-2.6.31-rc4/drivers/md/dm-ioband-policy.c
===================================================================
--- /dev/null
+++ linux-2.6.31-rc4/drivers/md/dm-ioband-policy.c
@@ -0,0 +1,459 @@
+/*
+ * Copyright (C) 2008-2009 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-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[READ] + dp->g_issued[WRITE] >=
+                   dp->g_io_throttle)
+                       return 0;
+       }
+
+       dp->g_epoch++;
+       DMDEBUG("make_epoch %d", 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;
+       DMDEBUG("refill token: gp:%p token:%d->%d extra(%d) allowance(%d)",
+               gp, gp->c_token - delta, gp->c_token, extra, allowance);
+       if (gp->c_token > 0)
+               return iopriority(gp);
+       DMDEBUG("refill token: yet empty gp:%p token:%d", 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 * 2 * 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 * 2 * 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;
+       if (dp->g_carryover < 1)
+               dp->g_carryover = 1;
+       dp->g_token_left = 0;
+}
+
+static int policy_weight_param(struct ioband_group *gp,
+                               const char *cmd, const char *value)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       long val = 0;
+       int r = 0, err = 0;
+
+       if (value)
+               err = strict_strtol(value, 0, &val);
+
+       if (!strcmp(cmd, "weight")) {
+               if (!value)
+                       set_weight(gp, DEFAULT_WEIGHT);
+               else if (!err && 0 < val && val <= SHORT_MAX)
+                       set_weight(gp, val);
+               else
+                       r = -EINVAL;
+       } else if (!strcmp(cmd, "token")) {
+               if (!err && 0 <= val && val <= INT_MAX) {
+                       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 && 0 <= val && val <= INT_MAX) {
+                       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, const char *arg)
+{
+       struct ioband_device *dp = gp->c_banddev;
+
+       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 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 || val > INT_MAX)
+                       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 iosize_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 policy_weight_iosize_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 || val > INT_MAX)
+                       return -EINVAL;
+       }
+
+       r = policy_weight_init(dp, argc, argv);
+       if (r < 0)
+               return r;
+
+       dp->g_prepare_bio = iosize_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);
+}
+
+const struct ioband_policy_type dm_ioband_policy_type[] = {
+       { "default",            policy_default_init             },
+       { "weight",             policy_weight_init              },
+       { "weight-iosize",      policy_weight_iosize_init       },
+       { "range-bw",           policy_range_bw_init            },
+       { NULL,                 policy_default_init             }
+};
Index: linux-2.6.31-rc4/drivers/md/dm-ioband-type.c
===================================================================
--- /dev/null
+++ linux-2.6.31-rc4/drivers/md/dm-ioband-type.c
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2008-2009 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-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 */
+}
+
+const struct ioband_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}
+};
Index: linux-2.6.31-rc4/drivers/md/dm-ioband.h
===================================================================
--- /dev/null
+++ linux-2.6.31-rc4/drivers/md/dm-ioband.h
@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2008-2009 VA Linux Systems Japan K.K.
+ *
+ *  I/O bandwidth control
+ *
+ * This file is released under the GPL.
+ */
+
+#ifndef DM_IOBAND_H
+#define DM_IOBAND_H
+
+#include <linux/version.h>
+#include <linux/wait.h>
+
+#define DM_MSG_PREFIX "ioband"
+
+#define DEFAULT_IO_THROTTLE    4
+#define IOBAND_NAME_MAX                31
+#define IOBAND_ID_ANY          (-1)
+#define POLICY_PARAM_START     6
+#define POLICY_PARAM_DELIM     "=:,"
+
+#define MAX_BW_OVER             1
+#define MAX_BW_UNDER            0
+#define NO_IO_MODE              4
+
+#define TIME_COMPENSATOR        10
+
+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;
+       int g_issued[2];
+       int g_blocked;
+       spinlock_t g_lock;
+       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];
+       const struct ioband_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 *, const char *);
+       void (*g_group_dtr) (struct ioband_group *);
+       int (*g_set_param) (struct ioband_group *, const char *, const char *);
+       int (*g_should_block) (struct ioband_group *);
+       void (*g_show) (struct ioband_group *, int *, char *, unsigned);
+
+       /* 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;
+
+       /* members for range-bw policy */
+       int     g_min_bw_total;
+       int     g_max_bw_total;
+       unsigned long   g_next_time_period;
+       int     g_time_period_expired;
+       struct ioband_group *g_running_gp;
+       int     g_total_min_bw_token;
+       int     g_consumed_min_bw_token;
+       int     g_io_mode;
+
+};
+
+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 */
+       const struct ioband_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; */
+
+       /* members for range-bw policy */
+       wait_queue_head_t       c_max_bw_over_waitq;
+       struct timer_list *c_timer;
+       int     timer_set;
+       int     c_min_bw;
+       int     c_max_bw;
+       int     c_time_slice_expired;
+       int     c_min_bw_token;
+       int     c_max_bw_token;
+       int     c_consumed_min_bw_token;
+       int     c_is_over_max_bw;
+       int     c_io_mode;
+       unsigned long   c_time_slice;
+       unsigned long   c_time_slice_start;
+       unsigned long   c_time_slice_end;
+       int     c_wait_p_count;
+
+};
+
+#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_SYNC      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_async(gp)             ((gp)->c_flags |= IOG_PRIO_QUEUE)
+#define clear_prio_async(gp)           ((gp)->c_flags &= ~IOG_PRIO_QUEUE)
+#define is_prio_async(gp) \
+       ((gp)->c_flags & (IOG_PRIO_QUEUE|IOG_PRIO_BIO_SYNC) == IOG_PRIO_QUEUE)
+
+#define set_prio_sync(gp) \
+       ((gp)->c_flags |= (IOG_PRIO_QUEUE|IOG_PRIO_BIO_SYNC))
+#define clear_prio_sync(gp) \
+       ((gp)->c_flags &= ~(IOG_PRIO_QUEUE|IOG_PRIO_BIO_SYNC))
+#define is_prio_sync(gp) \
+       ((gp)->c_flags & (IOG_PRIO_QUEUE|IOG_PRIO_BIO_SYNC) == \
+               (IOG_PRIO_QUEUE|IOG_PRIO_BIO_SYNC))
+
+#define set_prio_queue(gp, sync) \
+       ((gp)->c_flags |= (IOG_PRIO_QUEUE|sync))
+#define clear_prio_queue(gp)           clear_prio_sync(gp)
+#define is_prio_queue(gp)              ((gp)->c_flags & IOG_PRIO_QUEUE)
+#define prio_queue_sync(gp)            ((gp)->c_flags & IOG_PRIO_BIO_SYNC)
+
+struct ioband_policy_type {
+       const char *p_name;
+       int (*p_policy_init) (struct ioband_device *, int, char **);
+};
+
+extern const struct ioband_policy_type dm_ioband_policy_type[];
+
+struct ioband_group_type {
+       const char *t_name;
+       int (*t_getid) (struct bio *);
+};
+
+extern const struct ioband_group_type dm_ioband_group_type[];
+
+extern int policy_range_bw_init(struct ioband_device *, int, char **);
+
+#endif /* DM_IOBAND_H */
Index: linux-2.6.31-rc4/drivers/md/dm-ioband-rangebw.c
===================================================================
--- /dev/null
+++ linux-2.6.31-rc4/drivers/md/dm-ioband-rangebw.c
@@ -0,0 +1,673 @@
+/*
+ * dm-ioband-rangebw.c
+ *
+ * This is a I/O control policy to support the Range Bandwidth in Disk I/O.
+ * And this policy is for dm-ioband controller by Ryo Tsuruta,
+ * Hirokazu Takahashi
+ *
+ * Copyright (C) 2008 - 2011
+ * Electronics and Telecommunications Research Institute(ETRI)
+ *
+ * This program is free software. you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License(GPL) as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Contact Information:
+ * Dong-Jae, Kang <djkang@xxxxxxxxxx>, Chei-Yol,Kim <gauri@xxxxxxxxxx>,
+ * Sung-In,Jung <sijung@xxxxxxxxxx>
+ */
+
+#include <linux/bio.h>
+#include <linux/workqueue.h>
+#include <linux/rbtree.h>
+#include <linux/jiffies.h>
+#include <linux/random.h>
+#include <linux/time.h>
+#include <linux/timer.h>
+#include "dm.h"
+#include "md.h"
+#include "dm-ioband.h"
+
+static void range_bw_timeover(unsigned long);
+static void range_bw_timer_register(struct timer_list *,
+                                        unsigned long, unsigned long);
+
+/*
+ * Functions for Range Bandwidth(range-bw) policy based on
+ * the time slice and token.
+ */
+#define DEFAULT_BUCKET          2
+#define DEFAULT_TOKENPOOL       2048
+
+#define TIME_SLICE_EXPIRED      1
+#define TIME_SLICE_NOT_EXPIRED  0
+
+#define MINBW_IO_MODE           0
+#define LEFTOVER_IO_MODE        1
+#define RANGE_IO_MODE           2
+#define DEFAULT_IO_MODE         3
+#define NO_IO_MODE             4
+
+#define MINBW_PRIO_BASE         10
+#define OVER_IO_RATE           4
+
+#define DEFAULT_RANGE_BW        "0:0"
+#define DEFAULT_MIN_BW          0
+#define DEFAULT_MAX_BW          0
+
+static const int time_slice_base = HZ / 10;
+static const int range_time_slice_base = HZ / 50;
+static void do_nothing(void) {}
+/*
+ * g_restart_bios function for range-bw policy
+ */
+static int range_bw_restart_bios(struct ioband_device *dp)
+{
+       return 1;
+}
+
+/*
+ * Allocate the time slice when IO mode is MINBW_IO_MODE,
+ * RANGE_IO_MODE or LEFTOVER_IO_MODE
+ */
+static int set_time_slice(struct ioband_group *gp)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       int dp_io_mode, gp_io_mode;
+       unsigned long now = jiffies;
+
+       dp_io_mode = dp->g_io_mode;
+       gp_io_mode = gp->c_io_mode;
+
+       gp->c_time_slice_start = now;
+
+       if (dp_io_mode == LEFTOVER_IO_MODE) {
+               gp->c_time_slice_end = now + gp->c_time_slice;
+               return 0;
+       }
+
+       if (gp_io_mode == MINBW_IO_MODE)
+               gp->c_time_slice_end = now + gp->c_time_slice;
+       else if (gp_io_mode == RANGE_IO_MODE)
+               gp->c_time_slice_end = now + range_time_slice_base;
+       else if (gp_io_mode == DEFAULT_IO_MODE)
+               gp->c_time_slice_end = now + time_slice_base;
+       else if (gp_io_mode == NO_IO_MODE) {
+               gp->c_time_slice_end = 0;
+               gp->c_time_slice_expired = TIME_SLICE_EXPIRED;
+               return 0;
+       }
+
+       gp->c_time_slice_expired = TIME_SLICE_NOT_EXPIRED;
+
+       return 0;
+}
+
+/*
+ * Calculate the priority of given ioband_group
+ */
+static int range_bw_priority(struct ioband_group *gp)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       int prio = 0;
+
+       if (dp->g_io_mode == LEFTOVER_IO_MODE) {
+               prio = random32() % MINBW_PRIO_BASE;
+               if (prio == 0)
+                       prio = 1;
+       } else if (gp->c_io_mode == MINBW_IO_MODE) {
+               prio = (gp->c_min_bw_token - gp->c_consumed_min_bw_token) *
+                                                        MINBW_PRIO_BASE;
+       } else if (gp->c_io_mode == DEFAULT_IO_MODE) {
+               prio = MINBW_PRIO_BASE;
+       } else if (gp->c_io_mode == RANGE_IO_MODE) {
+               prio = MINBW_PRIO_BASE / 2;
+       } else {
+               prio = 0;
+       }
+
+       return prio;
+}
+
+/*
+ * Check whether this group has right to issue an I/O in range-bw policy mode.
+ *  Return 0 if it doesn't have right, otherwise return the non-zero value.
+ */
+static int has_right_to_issue(struct ioband_group *gp)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       int prio;
+
+       if (gp->c_prio_blocked > 0 || gp->c_blocked - gp->c_prio_blocked > 0) {
+               prio = range_bw_priority(gp);
+               if (prio <= 0)
+                       return 1;
+               return prio;
+       }
+
+       if (gp == dp->g_running_gp) {
+
+               if (gp->c_time_slice_expired == TIME_SLICE_EXPIRED) {
+
+                       gp->c_time_slice_expired = TIME_SLICE_NOT_EXPIRED;
+                       gp->c_time_slice_end = 0;
+
+                       return 0;
+               }
+
+               if (gp->c_time_slice_end == 0)
+                       set_time_slice(gp);
+
+               return range_bw_priority(gp);
+
+       }
+
+       dp->g_running_gp = gp;
+       set_time_slice(gp);
+
+       return range_bw_priority(gp);
+}
+
+/*
+ * Reset all variables related with range-bw token and time slice
+ */
+static int reset_range_bw_token(struct ioband_group *gp, unsigned long now)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       struct ioband_group *p;
+
+       list_for_each_entry(p, &dp->g_groups, c_list) {
+               p->c_consumed_min_bw_token = 0;
+               p->c_is_over_max_bw = MAX_BW_UNDER;
+               if (p->c_io_mode != DEFAULT_IO_MODE)
+                       p->c_io_mode = MINBW_IO_MODE;
+       }
+
+       dp->g_consumed_min_bw_token = 0;
+
+       dp->g_next_time_period = now + HZ;
+       dp->g_time_period_expired = TIME_SLICE_NOT_EXPIRED;
+       dp->g_io_mode = MINBW_IO_MODE;
+
+       list_for_each_entry(p, &dp->g_groups, c_list) {
+               if (waitqueue_active(&p->c_max_bw_over_waitq))
+                       wake_up_all(&p->c_max_bw_over_waitq);
+       }
+       return 0;
+}
+
+/*
+ * Use tokens(Increase the number of consumed token) to issue an I/O
+ * for guranteeing the range-bw. and check the expiration of local and
+ * global time slice, and overflow of max bw
+ */
+static int range_bw_consume_token(struct ioband_group *gp, int count, int flag)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       struct ioband_group *p;
+       unsigned long now = jiffies;
+       int io_mode;
+
+       dp->g_current = gp;
+
+       if (dp->g_next_time_period == 0) {
+               dp->g_next_time_period = now + HZ;
+               dp->g_time_period_expired = TIME_SLICE_NOT_EXPIRED;
+       }
+
+       if (time_after(now, dp->g_next_time_period)) {
+               reset_range_bw_token(gp, now);
+       } else {
+               gp->c_consumed_min_bw_token += count;
+               dp->g_consumed_min_bw_token += count;
+
+               if (gp->c_max_bw > 0 && gp->c_consumed_min_bw_token >=
+                                                       gp->c_max_bw_token) {
+                       gp->c_is_over_max_bw = MAX_BW_OVER;
+                       gp->c_io_mode = NO_IO_MODE;
+                       return R_YIELD;
+               }
+
+               if (gp->c_io_mode != RANGE_IO_MODE && gp->c_min_bw_token <=
+                                               gp->c_consumed_min_bw_token) {
+                       gp->c_io_mode = RANGE_IO_MODE;
+
+                       if (dp->g_total_min_bw_token <=
+                                               dp->g_consumed_min_bw_token) {
+                               list_for_each_entry(p, &dp->g_groups, c_list) {
+                                       if (p->c_io_mode == RANGE_IO_MODE ||
+                                           p->c_io_mode == DEFAULT_IO_MODE) {
+                                               io_mode = 1;
+                                       } else {
+                                               io_mode = 0;
+                                               break;
+                                       }
+                               }
+
+                               if (io_mode && dp->g_io_mode == MINBW_IO_MODE)
+                                       dp->g_io_mode = LEFTOVER_IO_MODE;
+                       }
+               }
+       }
+
+       if (gp->c_time_slice_end != 0 &&
+           time_after(now, gp->c_time_slice_end)) {
+               gp->c_time_slice_expired = TIME_SLICE_EXPIRED;
+               return R_YIELD;
+       }
+
+       return R_OK;
+}
+
+static int is_no_io_mode(struct ioband_group *gp)
+{
+       if (gp->c_io_mode == NO_IO_MODE)
+               return 1;
+
+       return 0;
+}
+
+/*
+ * Check if this group is able to receive a new bio.
+ * in range bw policy, we only check that ioband device should be blocked
+ */
+static int range_bw_queue_full(struct ioband_group *gp)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       unsigned long now, time_step;
+
+       if (is_no_io_mode(gp)) {
+               now = jiffies;
+               if (time_after(dp->g_next_time_period, now)) {
+                       time_step = dp->g_next_time_period - now;
+                       range_bw_timer_register(gp->c_timer,
+                                               (time_step + TIME_COMPENSATOR),
+                                               (unsigned long)gp);
+                       wait_event_lock_irq(gp->c_max_bw_over_waitq,
+                                           !is_no_io_mode(gp),
+                                           dp->g_lock, do_nothing());
+               }
+       }
+
+       return (gp->c_blocked >= gp->c_limit);
+}
+
+/*
+ * Convert the bw valuse to the number of bw token
+ * bw : Kbyte unit bandwidth
+ * token_base : the number of tokens used for one 1Kbyte-size IO
+ * -- Attention : Currently, We support the 512byte or 1Kbyte per 1 token
+ */
+static int convert_bw_to_token(int bw, int token_unit)
+{
+       int token;
+       int token_base;
+
+       token_base = (1 << token_unit) / 4;
+       token = bw * token_base;
+
+       return token;
+}
+
+
+/*
+ * Allocate the time slice for MINBW_IO_MODE to each group
+ */
+static void range_bw_time_slice_init(struct ioband_group *gp)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       struct ioband_group *p;
+
+       list_for_each_entry(p, &dp->g_groups, c_list) {
+
+               if (dp->g_min_bw_total == 0)
+                       p->c_time_slice = time_slice_base;
+               else
+                       p->c_time_slice = time_slice_base +
+                               ((time_slice_base *
+                                 ((p->c_min_bw + p->c_max_bw) / 2)) /
+                                        dp->g_min_bw_total);
+       }
+}
+
+/*
+ *  Allocate the range_bw and range_bw_token to the given group
+ */
+static void set_range_bw(struct ioband_group *gp, int new_min, int new_max)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       struct ioband_group *p;
+       int token_unit;
+
+       dp->g_min_bw_total += (new_min - gp->c_min_bw);
+       gp->c_min_bw = new_min;
+
+       dp->g_max_bw_total += (new_max - gp->c_max_bw);
+       gp->c_max_bw = new_max;
+
+       if (new_min)
+               gp->c_io_mode = MINBW_IO_MODE;
+       else
+               gp->c_io_mode = DEFAULT_IO_MODE;
+
+       range_bw_time_slice_init(gp);
+
+       token_unit = dp->g_token_unit;
+       gp->c_min_bw_token = convert_bw_to_token(new_min, token_unit);
+       dp->g_total_min_bw_token =
+               convert_bw_to_token(dp->g_min_bw_total, token_unit);
+
+       gp->c_max_bw_token = convert_bw_to_token(new_max, token_unit);
+
+       if (dp->g_min_bw_total == 0) {
+               list_for_each_entry(p, &dp->g_groups, c_list)
+                       p->c_limit = 1;
+       } else {
+               list_for_each_entry(p, &dp->g_groups, c_list) {
+                       p->c_limit = dp->g_io_limit * 2 * p->c_min_bw /
+                               dp->g_min_bw_total / OVER_IO_RATE + 1;
+               }
+       }
+
+       return;
+}
+
+/*
+ * Allocate the min_bw and min_bw_token to the given group
+ */
+static void set_min_bw(struct ioband_group *gp, int new)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       struct ioband_group *p;
+       int token_unit;
+
+       dp->g_min_bw_total += (new - gp->c_min_bw);
+       gp->c_min_bw = new;
+
+       if (new)
+               gp->c_io_mode = MINBW_IO_MODE;
+       else
+               gp->c_io_mode = DEFAULT_IO_MODE;
+
+       range_bw_time_slice_init(gp);
+
+       token_unit = dp->g_token_unit;
+       gp->c_min_bw_token = convert_bw_to_token(gp->c_min_bw, token_unit);
+       dp->g_total_min_bw_token =
+               convert_bw_to_token(dp->g_min_bw_total, token_unit);
+
+       if (dp->g_min_bw_total == 0) {
+               list_for_each_entry(p, &dp->g_groups, c_list)
+                       p->c_limit = 1;
+       } else {
+               list_for_each_entry(p, &dp->g_groups, c_list) {
+                       p->c_limit = dp->g_io_limit * 2 * p->c_min_bw /
+                               dp->g_min_bw_total / OVER_IO_RATE + 1;
+               }
+       }
+
+       return;
+}
+
+/*
+ * Allocate the max_bw and max_bw_token to the pointed group
+ */
+static void set_max_bw(struct ioband_group *gp, int new)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       int token_unit;
+
+       token_unit = dp->g_token_unit;
+
+       dp->g_max_bw_total += (new - gp->c_max_bw);
+       gp->c_max_bw = new;
+       gp->c_max_bw_token = convert_bw_to_token(new, token_unit);
+
+       range_bw_time_slice_init(gp);
+
+       return;
+
+}
+
+static void init_range_bw_token_bucket(struct ioband_device *dp, int val)
+{
+       dp->g_token_bucket = (dp->g_io_limit * 2 * DEFAULT_BUCKET) <<
+                                                       dp->g_token_unit;
+       if (!val)
+               val = DEFAULT_TOKENPOOL << dp->g_token_unit;
+       if (val < dp->g_token_bucket)
+               val = dp->g_token_bucket;
+       dp->g_carryover = val/dp->g_token_bucket;
+       dp->g_token_left = 0;
+}
+
+static int policy_range_bw_param(struct ioband_group *gp,
+                                       const char *cmd, const char *value)
+{
+       long val = 0, min_val = DEFAULT_MIN_BW, max_val = DEFAULT_MAX_BW;
+       int r = 0, err = 0;
+       char *endp;
+
+       if (value) {
+               min_val = simple_strtol(value, &endp, 0);
+               if (strchr(POLICY_PARAM_DELIM, *endp)) {
+                       max_val = simple_strtol(endp + 1, &endp, 0);
+                       if (*endp != '\0')
+                               err++;
+               } else
+                       err++;
+       }
+
+       if (!strcmp(cmd, "range-bw")) {
+               if (!err && 0 <= min_val &&
+                   min_val <= (INT_MAX / 2) && 0 <= max_val &&
+                   max_val <= (INT_MAX / 2) && min_val <= max_val)
+                       set_range_bw(gp, min_val, max_val);
+               else
+                       r = -EINVAL;
+       } else if (!strcmp(cmd, "min-bw")) {
+               if (!err && 0 <= val && val <= (INT_MAX / 2))
+                       set_min_bw(gp, val);
+               else
+                       r = -EINVAL;
+       } else if (!strcmp(cmd, "max-bw")) {
+               if ((!err && 0 <= val && val <= (INT_MAX / 2) &&
+                    gp->c_min_bw <= val) || val == 0)
+                       set_max_bw(gp, val);
+               else
+                       r = -EINVAL;
+       } else {
+               r = -EINVAL;
+       }
+       return r;
+}
+
+static int policy_range_bw_ctr(struct ioband_group *gp, const char *arg)
+{
+       int ret;
+
+       init_waitqueue_head(&gp->c_max_bw_over_waitq);
+
+       gp->c_min_bw = 0;
+       gp->c_max_bw = 0;
+       gp->c_io_mode = DEFAULT_IO_MODE;
+       gp->c_time_slice_expired = TIME_SLICE_NOT_EXPIRED;
+       gp->c_min_bw_token = 0;
+       gp->c_max_bw_token = 0;
+       gp->c_consumed_min_bw_token = 0;
+       gp->c_is_over_max_bw = MAX_BW_UNDER;
+       gp->c_time_slice_start = 0;
+       gp->c_time_slice_end = 0;
+       gp->c_wait_p_count = 0;
+
+       gp->c_time_slice = time_slice_base;
+
+       gp->c_timer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
+       if (gp->c_timer == NULL)
+               return -EINVAL;
+       memset(gp->c_timer, 0, sizeof(struct timer_list));
+       gp->timer_set = 0;
+
+       ret = policy_range_bw_param(gp, "range-bw", arg);
+
+       return ret;
+}
+
+static void policy_range_bw_dtr(struct ioband_group *gp)
+{
+       struct ioband_device *dp = gp->c_banddev;
+
+       gp->c_time_slice = 0;
+       set_range_bw(gp, 0, 0);
+
+       dp->g_running_gp = NULL;
+
+       if (gp->c_timer != NULL) {
+               del_timer(gp->c_timer);
+               kfree(gp->c_timer);
+       }
+}
+
+static void policy_range_bw_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:%d", dp->g_token_bucket * dp->g_carryover,
+                                               gp->c_min_bw, gp->c_max_bw);
+
+       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:%d", p->c_id, p->c_min_bw, p->c_max_bw);
+       }
+       *szp = sz;
+}
+
+static int range_bw_prepare_token(struct ioband_group *gp,
+                                               struct bio *bio, int flag)
+{
+       struct ioband_device *dp = gp->c_banddev;
+       int unit;
+       int bio_count;
+       int token_count = 0;
+
+       unit = (1 << dp->g_token_unit);
+       bio_count = bio_sectors(bio);
+
+       if (unit == 8)
+               token_count = bio_count;
+       else if (unit == 4)
+               token_count = bio_count / 2;
+       else if (unit == 2)
+               token_count = bio_count / 4;
+       else if (unit == 1)
+               token_count = bio_count / 8;
+
+       return range_bw_consume_token(gp, token_count, flag);
+}
+
+void range_bw_timer_register(struct timer_list *ptimer,
+                               unsigned long timeover, unsigned long  gp)
+{
+       struct ioband_group *group = (struct ioband_group *)gp;
+
+       if (group->timer_set == 0) {
+               init_timer(ptimer);
+               ptimer->expires = get_jiffies_64() + timeover;
+               ptimer->data = gp;
+               ptimer->function = range_bw_timeover;
+               add_timer(ptimer);
+               group->timer_set = 1;
+       }
+}
+
+/*
+ * Timer Handler function to protect the all processes's hanging in
+ * lower min-bw configuration
+ */
+void range_bw_timeover(unsigned long gp)
+{
+       struct ioband_group *group = (struct ioband_group *)gp;
+
+       if (group->c_is_over_max_bw == MAX_BW_OVER)
+               group->c_is_over_max_bw = MAX_BW_UNDER;
+
+       if (group->c_io_mode == NO_IO_MODE)
+               group->c_io_mode = MINBW_IO_MODE;
+
+       if (waitqueue_active(&group->c_max_bw_over_waitq))
+               wake_up_all(&group->c_max_bw_over_waitq);
+
+       group->timer_set = 0;
+}
+
+/*
+ *  <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.
+ */
+
+int policy_range_bw_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 = has_right_to_issue;
+       dp->g_prepare_bio = range_bw_prepare_token;
+       dp->g_restart_bios = range_bw_restart_bios;
+       dp->g_group_ctr = policy_range_bw_ctr;
+       dp->g_group_dtr = policy_range_bw_dtr;
+       dp->g_set_param = policy_range_bw_param;
+       dp->g_should_block = range_bw_queue_full;
+       dp->g_show = policy_range_bw_show;
+
+       dp->g_min_bw_total = 0;
+       dp->g_running_gp = NULL;
+       dp->g_total_min_bw_token = 0;
+       dp->g_io_mode = MINBW_IO_MODE;
+       dp->g_consumed_min_bw_token = 0;
+       dp->g_current = NULL;
+       dp->g_next_time_period = 0;
+       dp->g_time_period_expired = TIME_SLICE_NOT_EXPIRED;
+
+       dp->g_token_unit = PAGE_SHIFT - 9;
+       init_range_bw_token_bucket(dp, val);
+
+       return 0;
+}
Index: linux-2.6.31-rc4/Documentation/device-mapper/range-bw.txt
===================================================================
--- /dev/null
+++ linux-2.6.31-rc4/Documentation/device-mapper/range-bw.txt
@@ -0,0 +1,99 @@
+Range-BW I/O controller by Dong-Jae Kang <djkang@xxxxxxxxxx>
+
+
+1. Introduction
+===============
+
+The design of Range-BW is related with three another parts, Cgroup,
+bio-cgroup (or blkio-cgroup) and dm-ioband and it was implemented as
+an additional controller for dm-ioband.
+Cgroup framework is used to support process grouping mechanism and
+bio-cgroup is used to control delayed I/O or non-direct I/O. Finally,
+dm-ioband is a kind of I/O controller allowing the proportional I/O
+bandwidth to process groups based on its priority.
+The supposed controller supports the process group-based range
+bandwidth according to the priority or importance of the group. Range
+bandwidth means the predicable I/O bandwidth with minimum and maximum
+value defined by administrator.
+
+Minimum I/O bandwidth should be guaranteed for stable performance or
+reliability of specific service and I/O bandwidth over maximum should
+be throttled to protect the limited I/O resource from
+over-provisioning in unnecessary usage or to reserve the I/O bandwidth
+for another use.
+So, Range-BW was implemented to include the two concepts, guaranteeing
+of minimum I/O requirement and limitation of unnecessary bandwidth
+depending on its priority.
+And it was implemented as device mapper driver such like dm-ioband.
+So, it is independent of the underlying specific I/O scheduler, for
+example, CFQ, AS, NOOP, deadline and so on.
+
+* Attention
+Range-BW supports the predicable I/O bandwidth, but it should be
+configured in the scope of total I/O bandwidth of the I/O system to
+guarantee the minimum I/O requirement. For example, if total I/O
+bandwidth is 40Mbytes/sec,
+
+the summary of I/O bandwidth configured in each process group should
+be equal or smaller than 40Mbytes/sec.
+So, we need to check total I/O bandwidth before set it up.
+
+2. Setup and Installation
+=========================
+
+This part is same with dm-ioband,
+../../Documentation/device-mapper/ioband.txt or
+http://sourceforge.net/apps/trac/ioband/wiki/dm-ioband/man/setup
+except the allocation of range-bw values.
+
+3. Usage
+========
+
+It is very useful to refer the documentation for dm-ioband in
+../../Documentation/device-mapper/ioband.txt or
+
+http://sourceforge.net/apps/trac/ioband/wiki/dm-ioband, because
+Range-BW follows the basic semantics of dm-ioband.
+This example is for range-bw configuration.
+
+# mount the cgroup
+mount -t cgroup -o blkio none /root/cgroup/blkio
+
+# create the process groups (3 groups)
+mkdir /root/cgroup/blkio/bgroup1
+mkdir /root/cgroup/blkio/bgroup2
+mkdir /root/cgroup/blkio/bgroup3
+
+# create the ioband device ( name : ioband1 )
+echo "0 $(blockdev --getsize /dev/sdb2) ioband /dev/sdb2 1 0 0 none
+range-bw 0 :0:0" | dmsetup create ioband1
+: Attention - device name (/dev/sdb2) should be modified depending on
+your system
+
+# init ioband device ( type and policy )
+dmsetup message ioband1 0 type cgroup
+dmsetup message ioband1 0 policy range-bw
+
+# attach the groups to the ioband device
+dmsetup message ioband1 0 attach 2
+dmsetup message ioband1 0 attach 3
+dmsetup message ioband1 0 attach 4
+: group number can be referred in /root/cgroup/blkio/bgroup1/blkio.id
+
+# allocate the values ( range-bw ) : XXX Kbytes
+: the sum of minimum I/O bandwidth in each group should be equal or
+smaller than total bandwidth to be supported by your system
+
+# range : about 100~500 Kbytes
+dmsetup message ioband1 0 range-bw 2:100:500
+
+# range : about 700~1000 Kbytes
+dmsetup message ioband1 0 range-bw 3:700:1000
+
+# range : about 30~35Mbytes
+dmsetup message ioband1 0 range-bw 4:30000:35000
+
+You can confirm the configuration of range-bw by using this command :
+[root@localhost range-bw]# dmsetup table --target ioband
+ioband1: 0 305235000 ioband 8:18 1 4 128 cgroup \
+    range-bw 16384 :0:0 2:100:500 3:700:1000 4:30000:35000
Index: linux-2.6.31-rc4/include/trace/events/dm-ioband.h
===================================================================
--- /dev/null
+++ linux-2.6.31-rc4/include/trace/events/dm-ioband.h
@@ -0,0 +1,242 @@
+#if !defined(_TRACE_DM_IOBAND_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_DM_IOBAND_H
+
+#include <linux/tracepoint.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM dm-ioband
+
+TRACE_EVENT(ioband_hold_urgent_bio,
+
+       TP_PROTO(struct ioband_group *gp, struct bio *bio),
+
+       TP_ARGS(gp, bio),
+
+       TP_STRUCT__entry(
+               __string(       g_name,         gp->c_banddev->g_name   )
+               __field(        int,            c_id                    )
+               __field(        int,            g_blocked               )
+               __field(        int,            c_blocked               )
+               __field(        dev_t,          dev                     )
+               __field(        sector_t,       sector                  )
+               __field(        unsigned int,   nr_sector               )
+               __field(        char,           rw                      )
+       ),
+
+       TP_fast_assign(
+               __assign_str(g_name, gp->c_banddev->g_name);
+               __entry->c_id           = gp->c_id;
+               __entry->g_blocked      = gp->c_banddev->g_blocked;
+               __entry->c_blocked      = gp->c_blocked;
+               __entry->dev            = bio->bi_bdev->bd_dev;
+               __entry->sector         = bio->bi_sector;
+               __entry->nr_sector      = bio->bi_size >> 9;
+               __entry->rw     = (bio_data_dir(bio) == READ) ? 'R' : 'W';
+       ),
+
+       TP_printk("%s,%d: %d,%d %c %llu + %u %d %d",
+                 __get_str(g_name), __entry->c_id,
+                 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rw,
+                 (unsigned long long)__entry->sector,
+                 __entry->nr_sector, __entry->g_blocked, __entry->c_blocked)
+);
+
+TRACE_EVENT(ioband_hold_bio,
+
+       TP_PROTO(struct ioband_group *gp, struct bio *bio),
+
+       TP_ARGS(gp, bio),
+
+       TP_STRUCT__entry(
+               __string(       g_name,         gp->c_banddev->g_name   )
+               __field(        int,            c_id                    )
+               __field(        int,            g_blocked               )
+               __field(        int,            c_blocked               )
+               __field(        dev_t,          dev                     )
+               __field(        sector_t,       sector                  )
+               __field(        unsigned int,   nr_sector               )
+               __field(        char,           rw                      )
+       ),
+
+       TP_fast_assign(
+               __assign_str(g_name, gp->c_banddev->g_name);
+               __entry->c_id           = gp->c_id;
+               __entry->g_blocked      = gp->c_banddev->g_blocked;
+               __entry->c_blocked      = gp->c_blocked;
+               __entry->dev            = bio->bi_bdev->bd_dev;
+               __entry->sector         = bio->bi_sector;
+               __entry->nr_sector      = bio->bi_size >> 9;
+               __entry->rw     = (bio_data_dir(bio) == READ) ? 'R' : 'W';
+       ),
+
+       TP_printk("%s,%d: %d,%d %c %llu + %u %d %d",
+                 __get_str(g_name), __entry->c_id,
+                 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rw,
+                 (unsigned long long)__entry->sector,
+                 __entry->nr_sector, __entry->g_blocked, __entry->c_blocked)
+);
+
+TRACE_EVENT(ioband_make_pback_list,
+
+       TP_PROTO(struct ioband_group *gp, struct bio *bio),
+
+       TP_ARGS(gp, bio),
+
+       TP_STRUCT__entry(
+               __string(       g_name,         gp->c_banddev->g_name   )
+               __field(        int,            c_id                    )
+               __field(        int,            g_blocked               )
+               __field(        int,            c_blocked               )
+               __field(        dev_t,          dev                     )
+               __field(        sector_t,       sector                  )
+               __field(        unsigned int,   nr_sector               )
+               __field(        char,           rw                      )
+       ),
+
+       TP_fast_assign(
+               __assign_str(g_name, gp->c_banddev->g_name);
+               __entry->c_id           = gp->c_id;
+               __entry->g_blocked      = gp->c_banddev->g_blocked;
+               __entry->c_blocked      = gp->c_blocked;
+               __entry->dev            = bio->bi_bdev->bd_dev;
+               __entry->sector         = bio->bi_sector;
+               __entry->nr_sector      = bio->bi_size >> 9;
+               __entry->rw     = (bio_data_dir(bio) == READ) ? 'R' : 'W';
+       ),
+
+       TP_printk("%s,%d: %d,%d %c %llu + %u %d %d",
+                 __get_str(g_name), __entry->c_id,
+                 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rw,
+                 (unsigned long long)__entry->sector,
+                 __entry->nr_sector, __entry->g_blocked, __entry->c_blocked)
+);
+
+TRACE_EVENT(ioband_make_issue_list,
+
+       TP_PROTO(struct ioband_group *gp, struct bio *bio),
+
+       TP_ARGS(gp, bio),
+
+       TP_STRUCT__entry(
+               __string(       g_name,         gp->c_banddev->g_name   )
+               __field(        int,            c_id                    )
+               __field(        int,            g_blocked               )
+               __field(        int,            c_blocked               )
+               __field(        dev_t,          dev                     )
+               __field(        sector_t,       sector                  )
+               __field(        unsigned int,   nr_sector               )
+               __field(        char,           rw                      )
+       ),
+
+       TP_fast_assign(
+               __assign_str(g_name, gp->c_banddev->g_name);
+               __entry->c_id           = gp->c_id;
+               __entry->g_blocked      = gp->c_banddev->g_blocked;
+               __entry->c_blocked      = gp->c_blocked;
+               __entry->dev            = bio->bi_bdev->bd_dev;
+               __entry->sector         = bio->bi_sector;
+               __entry->nr_sector      = bio->bi_size >> 9;
+               __entry->rw     = (bio_data_dir(bio) == READ) ? 'R' : 'W';
+       ),
+
+       TP_printk("%s,%d: %d,%d %c %llu + %u %d %d",
+                 __get_str(g_name), __entry->c_id,
+                 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rw,
+                 (unsigned long long)__entry->sector,
+                 __entry->nr_sector, __entry->g_blocked, __entry->c_blocked)
+);
+
+TRACE_EVENT(ioband_release_urgent_bios,
+
+       TP_PROTO(struct ioband_device *dp, struct bio *bio),
+
+       TP_ARGS(dp, bio),
+
+       TP_STRUCT__entry(
+               __string(       g_name,         dp->g_name              )
+               __field(        int,            g_blocked               )
+               __field(        dev_t,          dev                     )
+               __field(        sector_t,       sector                  )
+               __field(        unsigned int,   nr_sector               )
+               __field(        char,           rw                      )
+       ),
+
+       TP_fast_assign(
+               __assign_str(g_name, dp->g_name);
+               __entry->g_blocked      = dp->g_blocked;
+               __entry->dev            = bio->bi_bdev->bd_dev;
+               __entry->sector         = bio->bi_sector;
+               __entry->nr_sector      = bio->bi_size >> 9;
+               __entry->rw     = (bio_data_dir(bio) == READ) ? 'R' : 'W';
+       ),
+
+       TP_printk("%s: %d,%d %c %llu + %u %d",
+                 __get_str(g_name),
+                 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rw,
+                 (unsigned long long)__entry->sector,
+                 __entry->nr_sector, __entry->g_blocked)
+);
+
+TRACE_EVENT(ioband_make_request,
+
+       TP_PROTO(struct ioband_device *dp, struct bio *bio),
+
+       TP_ARGS(dp, bio),
+
+       TP_STRUCT__entry(
+               __string(       g_name,         dp->g_name              )
+               __field(        int,            c_id                    )
+               __field(        dev_t,          dev                     )
+               __field(        sector_t,       sector                  )
+               __field(        unsigned int,   nr_sector               )
+               __field(        char,           rw                      )
+       ),
+
+       TP_fast_assign(
+               __assign_str(g_name, dp->g_name);
+               __entry->dev            = bio->bi_bdev->bd_dev;
+               __entry->sector         = bio->bi_sector;
+               __entry->nr_sector      = bio->bi_size >> 9;
+               __entry->rw     = (bio_data_dir(bio) == READ) ? 'R' : 'W';
+       ),
+
+       TP_printk("%s: %d,%d %c %llu + %u",
+                 __get_str(g_name),
+                 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rw,
+                 (unsigned long long)__entry->sector,
+                 __entry->nr_sector)
+);
+
+TRACE_EVENT(ioband_pushback_bio,
+
+       TP_PROTO(struct ioband_device *dp, struct bio *bio),
+
+       TP_ARGS(dp, bio),
+
+       TP_STRUCT__entry(
+               __string(       g_name,         dp->g_name              )
+               __field(        dev_t,          dev                     )
+               __field(        sector_t,       sector                  )
+               __field(        unsigned int,   nr_sector               )
+               __field(        char,           rw                      )
+       ),
+
+       TP_fast_assign(
+               __assign_str(g_name, dp->g_name);
+               __entry->dev            = bio->bi_bdev->bd_dev;
+               __entry->sector         = bio->bi_sector;
+               __entry->nr_sector      = bio->bi_size >> 9;
+               __entry->rw     = (bio_data_dir(bio) == READ) ? 'R' : 'W';
+       ),
+
+       TP_printk("%s: %d,%d %c %llu + %u",
+                 __get_str(g_name),
+                 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rw,
+                 (unsigned long long)__entry->sector,
+                 __entry->nr_sector)
+);
+
+#endif /* _TRACE_DM_IOBAND_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>

_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.