lkml.org 
[lkml]   [2011]   [Mar]   [21]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 1/3] cfq-iosched: Fair cross-group preemption (interface and documentation)
    Date
    blkio.class is a new interface that allows you to specify a cgroup as
    requiring low-latency service on a specific block device. This patch
    includes only the interface and documentation.

    Signed-off-by: Chad Talbott <ctalbott@google.com>
    ---
    Documentation/cgroups/blkio-controller.txt | 16 ++++
    block/blk-cgroup.c | 121 +++++++++++++++++++++-------
    block/blk-cgroup.h | 36 +++++++--
    block/cfq-iosched.c | 12 +++-
    4 files changed, 145 insertions(+), 40 deletions(-)

    diff --git a/Documentation/cgroups/blkio-controller.txt b/Documentation/cgroups/blkio-controller.txt
    index 4ed7b5c..7acf9d2 100644
    --- a/Documentation/cgroups/blkio-controller.txt
    +++ b/Documentation/cgroups/blkio-controller.txt
    @@ -169,6 +169,22 @@ Proportional weight policy files
    dev weight
    8:16 300

    +- blkio.class
    + - Specifies the per-cgroup, per-device service class. There
    + are currently two service classes: real-time (1) and
    + best-effort (2). By default, all groups start as
    + best-effort.
    +
    + #echo dev_maj:dev_minor class > /path/to/cgroup/blkio.class
    + Configure class=real-time on /dev/sdb (8:16) in this cgroup
    + # echo '8:16 1' > blkio.class
    + # cat blkio.class
    + 8:16 1
    +
    + A real-time group can preempt a best-effort group, only as
    + long as it's within its assigned weight; i.e. fairness is
    + preserved.
    +
    - blkio.time
    - disk time allocated to cgroup per device in milliseconds. First
    two fields specify the major and minor number of the device and
    diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c
    index 455768a..f2c553e 100644
    --- a/block/blk-cgroup.c
    +++ b/block/blk-cgroup.c
    @@ -129,6 +129,21 @@ blkio_update_group_weight(struct blkio_group *blkg, unsigned int weight)
    }
    }

    +static inline void
    +blkio_update_group_class(struct blkio_group *blkg, unsigned int class)
    +{
    + struct blkio_policy_type *blkiop;
    +
    + list_for_each_entry(blkiop, &blkio_list, list) {
    + /* If this policy does not own the blkg, do not send updates */
    + if (blkiop->plid != blkg->plid)
    + continue;
    + if (blkiop->ops.blkio_update_group_class_fn)
    + blkiop->ops.blkio_update_group_class_fn(blkg->key,
    + blkg, class);
    + }
    +}
    +
    static inline void blkio_update_group_bps(struct blkio_group *blkg, u64 bps,
    int fileid)
    {
    @@ -708,15 +723,29 @@ static int blkio_policy_parse_and_set(char *buf,

    switch (plid) {
    case BLKIO_POLICY_PROP:
    - ret = strict_strtoul(s[1], 10, &temp);
    - if (ret || (temp < BLKIO_WEIGHT_MIN && temp > 0) ||
    - temp > BLKIO_WEIGHT_MAX)
    - return -EINVAL;
    -
    - newpn->plid = plid;
    - newpn->fileid = fileid;
    - newpn->val.weight = temp;
    - break;
    + switch (fileid) {
    + case BLKIO_PROP_weight_device:
    + ret = strict_strtoul(s[1], 10, &temp);
    + if (ret || (temp < BLKIO_WEIGHT_MIN && temp > 0) ||
    + temp > BLKIO_WEIGHT_MAX)
    + return -EINVAL;
    +
    + newpn->plid = plid;
    + newpn->fileid = fileid;
    + newpn->val.prop.weight = temp;
    + break;
    + case BLKIO_PROP_class:
    + ret = strict_strtoul(s[1], 10, &temp);
    + if (ret ||
    + temp < BLKIO_RT_CLASS ||
    + temp > BLKIO_BE_CLASS)
    + return -EINVAL;
    +
    + newpn->plid = plid;
    + newpn->fileid = fileid;
    + newpn->val.prop.class = temp;
    + break;
    + }
    case BLKIO_POLICY_THROTL:
    switch(fileid) {
    case BLKIO_THROTL_read_bps_device:
    @@ -727,7 +756,7 @@ static int blkio_policy_parse_and_set(char *buf,

    newpn->plid = plid;
    newpn->fileid = fileid;
    - newpn->val.bps = bps;
    + newpn->val.throtl.bps = bps;
    break;
    case BLKIO_THROTL_read_iops_device:
    case BLKIO_THROTL_write_iops_device:
    @@ -740,7 +769,7 @@ static int blkio_policy_parse_and_set(char *buf,

    newpn->plid = plid;
    newpn->fileid = fileid;
    - newpn->val.iops = (unsigned int)iops;
    + newpn->val.throtl.iops = (unsigned int)iops;
    break;
    }
    break;
    @@ -759,20 +788,34 @@ unsigned int blkcg_get_weight(struct blkio_cgroup *blkcg,
    pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_PROP,
    BLKIO_PROP_weight_device);
    if (pn)
    - return pn->val.weight;
    + return pn->val.prop.weight;
    else
    return blkcg->weight;
    }
    EXPORT_SYMBOL_GPL(blkcg_get_weight);

    -uint64_t blkcg_get_read_bps(struct blkio_cgroup *blkcg, dev_t dev)
    +enum blkcg_class blkcg_get_class(struct blkio_cgroup *blkcg,
    + dev_t dev)
    {
    struct blkio_policy_node *pn;
    + enum blkcg_class class = BLKIO_DEFAULT_CLASS;
    +
    + pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_PROP,
    + BLKIO_PROP_class);
    + if (pn)
    + class = pn->val.prop.class;

    + return class;
    +}
    +EXPORT_SYMBOL_GPL(blkcg_get_class);
    +
    +uint64_t blkcg_get_read_bps(struct blkio_cgroup *blkcg, dev_t dev)
    +{
    + struct blkio_policy_node *pn;
    pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_THROTL,
    BLKIO_THROTL_read_bps_device);
    if (pn)
    - return pn->val.bps;
    + return pn->val.throtl.bps;
    else
    return -1;
    }
    @@ -783,7 +826,7 @@ uint64_t blkcg_get_write_bps(struct blkio_cgroup *blkcg, dev_t dev)
    pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_THROTL,
    BLKIO_THROTL_write_bps_device);
    if (pn)
    - return pn->val.bps;
    + return pn->val.throtl.bps;
    else
    return -1;
    }
    @@ -795,7 +838,7 @@ unsigned int blkcg_get_read_iops(struct blkio_cgroup *blkcg, dev_t dev)
    pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_THROTL,
    BLKIO_THROTL_read_iops_device);
    if (pn)
    - return pn->val.iops;
    + return pn->val.throtl.iops;
    else
    return -1;
    }
    @@ -806,7 +849,7 @@ unsigned int blkcg_get_write_iops(struct blkio_cgroup *blkcg, dev_t dev)
    pn = blkio_policy_search_node(blkcg, dev, BLKIO_POLICY_THROTL,
    BLKIO_THROTL_write_iops_device);
    if (pn)
    - return pn->val.iops;
    + return pn->val.throtl.iops;
    else
    return -1;
    }
    @@ -816,19 +859,19 @@ static bool blkio_delete_rule_command(struct blkio_policy_node *pn)
    {
    switch(pn->plid) {
    case BLKIO_POLICY_PROP:
    - if (pn->val.weight == 0)
    + if (pn->val.prop.weight == 0)
    return 1;
    break;
    case BLKIO_POLICY_THROTL:
    switch(pn->fileid) {
    case BLKIO_THROTL_read_bps_device:
    case BLKIO_THROTL_write_bps_device:
    - if (pn->val.bps == 0)
    + if (pn->val.throtl.bps == 0)
    return 1;
    break;
    case BLKIO_THROTL_read_iops_device:
    case BLKIO_THROTL_write_iops_device:
    - if (pn->val.iops == 0)
    + if (pn->val.throtl.iops == 0)
    return 1;
    }
    break;
    @@ -844,17 +887,17 @@ static void blkio_update_policy_rule(struct blkio_policy_node *oldpn,
    {
    switch(oldpn->plid) {
    case BLKIO_POLICY_PROP:
    - oldpn->val.weight = newpn->val.weight;
    + oldpn->val.prop.weight = newpn->val.prop.weight;
    break;
    case BLKIO_POLICY_THROTL:
    switch(newpn->fileid) {
    case BLKIO_THROTL_read_bps_device:
    case BLKIO_THROTL_write_bps_device:
    - oldpn->val.bps = newpn->val.bps;
    + oldpn->val.throtl.bps = newpn->val.throtl.bps;
    break;
    case BLKIO_THROTL_read_iops_device:
    case BLKIO_THROTL_write_iops_device:
    - oldpn->val.iops = newpn->val.iops;
    + oldpn->val.throtl.iops = newpn->val.throtl.iops;
    }
    break;
    default:
    @@ -872,22 +915,24 @@ static void blkio_update_blkg_policy(struct blkio_cgroup *blkcg,
    unsigned int weight, iops;
    u64 bps;

    +
    switch(pn->plid) {
    case BLKIO_POLICY_PROP:
    - weight = pn->val.weight ? pn->val.weight :
    + weight = pn->val.prop.weight ? pn->val.prop.weight :
    blkcg->weight;
    blkio_update_group_weight(blkg, weight);
    + blkio_update_group_class(blkg, pn->val.prop.class);
    break;
    case BLKIO_POLICY_THROTL:
    switch(pn->fileid) {
    case BLKIO_THROTL_read_bps_device:
    case BLKIO_THROTL_write_bps_device:
    - bps = pn->val.bps ? pn->val.bps : (-1);
    + bps = pn->val.throtl.bps ? pn->val.throtl.bps : (-1);
    blkio_update_group_bps(blkg, bps, pn->fileid);
    break;
    case BLKIO_THROTL_read_iops_device:
    case BLKIO_THROTL_write_iops_device:
    - iops = pn->val.iops ? pn->val.iops : (-1);
    + iops = pn->val.throtl.iops ? pn->val.throtl.iops : (-1);
    blkio_update_group_iops(blkg, iops, pn->fileid);
    break;
    }
    @@ -984,21 +1029,28 @@ blkio_print_policy_node(struct seq_file *m, struct blkio_policy_node *pn)
    {
    switch(pn->plid) {
    case BLKIO_POLICY_PROP:
    - if (pn->fileid == BLKIO_PROP_weight_device)
    + switch(pn->fileid) {
    + case BLKIO_PROP_weight_device:
    + seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
    + MINOR(pn->dev), pn->val.prop.weight);
    + break;
    + case BLKIO_PROP_class:
    seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
    - MINOR(pn->dev), pn->val.weight);
    + MINOR(pn->dev), pn->val.prop.class);
    + break;
    + };
    break;
    case BLKIO_POLICY_THROTL:
    switch(pn->fileid) {
    case BLKIO_THROTL_read_bps_device:
    case BLKIO_THROTL_write_bps_device:
    seq_printf(m, "%u:%u\t%llu\n", MAJOR(pn->dev),
    - MINOR(pn->dev), pn->val.bps);
    + MINOR(pn->dev), pn->val.throtl.bps);
    break;
    case BLKIO_THROTL_read_iops_device:
    case BLKIO_THROTL_write_iops_device:
    seq_printf(m, "%u:%u\t%u\n", MAJOR(pn->dev),
    - MINOR(pn->dev), pn->val.iops);
    + MINOR(pn->dev), pn->val.throtl.iops);
    break;
    }
    break;
    @@ -1037,6 +1089,7 @@ static int blkiocg_file_read(struct cgroup *cgrp, struct cftype *cft,
    case BLKIO_POLICY_PROP:
    switch(name) {
    case BLKIO_PROP_weight_device:
    + case BLKIO_PROP_class:
    blkio_read_policy_node_files(cft, blkcg, m);
    return 0;
    default:
    @@ -1243,6 +1296,14 @@ struct cftype blkio_files[] = {
    .max_write_len = 256,
    },
    {
    + .name = "class",
    + .private = BLKIOFILE_PRIVATE(BLKIO_POLICY_PROP,
    + BLKIO_PROP_class),
    + .read_seq_string = blkiocg_file_read,
    + .write_string = blkiocg_file_write,
    + .max_write_len = 256,
    + },
    + {
    .name = "weight",
    .private = BLKIOFILE_PRIVATE(BLKIO_POLICY_PROP,
    BLKIO_PROP_weight),
    diff --git a/block/blk-cgroup.h b/block/blk-cgroup.h
    index ea4861b..0e9cd32 100644
    --- a/block/blk-cgroup.h
    +++ b/block/blk-cgroup.h
    @@ -73,10 +73,18 @@ enum blkg_state_flags {
    BLKG_empty,
    };

    +enum blkcg_class {
    + BLKIO_RT_CLASS = 1,
    + BLKIO_BE_CLASS = 2,
    +};
    +
    +#define BLKIO_DEFAULT_CLASS BLKIO_BE_CLASS
    +
    /* cgroup files owned by proportional weight policy */
    enum blkcg_file_name_prop {
    BLKIO_PROP_weight = 1,
    BLKIO_PROP_weight_device,
    + BLKIO_PROP_class,
    BLKIO_PROP_io_service_bytes,
    BLKIO_PROP_io_serviced,
    BLKIO_PROP_time,
    @@ -157,6 +165,21 @@ struct blkio_group {
    struct blkio_group_stats stats;
    };

    +struct proportion_policy {
    + unsigned int weight;
    + unsigned int class;
    +};
    +
    +union throttle_policy {
    + /*
    + * Rate read/write in terms of byptes per second
    + * Whether this rate represents read or write is determined
    + * by file type "fileid".
    + */
    + u64 bps;
    + unsigned int iops;
    +};
    +
    struct blkio_policy_node {
    struct list_head node;
    dev_t dev;
    @@ -166,14 +189,8 @@ struct blkio_policy_node {
    int fileid;

    union {
    - unsigned int weight;
    - /*
    - * Rate read/write in terms of byptes per second
    - * Whether this rate represents read or write is determined
    - * by file type "fileid".
    - */
    - u64 bps;
    - unsigned int iops;
    + struct proportion_policy prop;
    + union throttle_policy throtl;
    } val;
    };

    @@ -192,6 +209,8 @@ typedef void (blkio_unlink_group_fn) (void *key, struct blkio_group *blkg);

    typedef void (blkio_update_group_weight_fn) (void *key,
    struct blkio_group *blkg, unsigned int weight);
    +typedef void (blkio_update_group_class_fn) (void *key,
    + struct blkio_group *blkg, unsigned int class);
    typedef void (blkio_update_group_read_bps_fn) (void * key,
    struct blkio_group *blkg, u64 read_bps);
    typedef void (blkio_update_group_write_bps_fn) (void *key,
    @@ -204,6 +223,7 @@ typedef void (blkio_update_group_write_iops_fn) (void *key,
    struct blkio_policy_ops {
    blkio_unlink_group_fn *blkio_unlink_group_fn;
    blkio_update_group_weight_fn *blkio_update_group_weight_fn;
    + blkio_update_group_class_fn *blkio_update_group_class_fn;
    blkio_update_group_read_bps_fn *blkio_update_group_read_bps_fn;
    blkio_update_group_write_bps_fn *blkio_update_group_write_bps_fn;
    blkio_update_group_read_iops_fn *blkio_update_group_read_iops_fn;
    diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
    index ea83a4f..55e78b7 100644
    --- a/block/cfq-iosched.c
    +++ b/block/cfq-iosched.c
    @@ -179,6 +179,7 @@ struct cfq_group {
    /* group service_tree key */
    u64 vdisktime;
    unsigned int weight;
    + enum blkcg_class class;

    /* number of cfqq currently on this group */
    int nr_cfqq;
    @@ -988,6 +989,12 @@ void cfq_update_blkio_group_weight(void *key, struct blkio_group *blkg,
    cfqg_of_blkg(blkg)->weight = weight;
    }

    +void cfq_update_blkio_group_class(void *key, struct blkio_group *blkg,
    + unsigned int class)
    +{
    + cfqg_of_blkg(blkg)->class = class;
    +}
    +
    static struct cfq_group *
    cfq_find_alloc_cfqg(struct cfq_data *cfqd, struct cgroup *cgroup, int create)
    {
    @@ -4115,8 +4122,9 @@ static struct elevator_type iosched_cfq = {
    #ifdef CONFIG_CFQ_GROUP_IOSCHED
    static struct blkio_policy_type blkio_policy_cfq = {
    .ops = {
    - .blkio_unlink_group_fn = cfq_unlink_blkio_group,
    - .blkio_update_group_weight_fn = cfq_update_blkio_group_weight,
    + .blkio_unlink_group_fn = cfq_unlink_blkio_group,
    + .blkio_update_group_weight_fn = cfq_update_blkio_group_weight,
    + .blkio_update_group_class_fn = cfq_update_blkio_group_class,
    },
    .plid = BLKIO_POLICY_PROP,
    };
    --
    1.7.3.1


    \
     
     \ /
      Last update: 2011-03-22 02:13    [W:0.043 / U:0.836 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site