lkml.org 
[lkml]   [2009]   [Mar]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Date
    Subject[PATCH 2/4] Memory controller soft limit interface (v3)

    From: Balbir Singh <balbir@linux.vnet.ibm.com>

    Changelog v2...v1
    1. Add support for res_counter_check_soft_limit_locked. This is used
    by the hierarchy code.

    Add an interface to allow get/set of soft limits. Soft limits for memory plus
    swap controller (memsw) is currently not supported. Resource counters have
    been enhanced to support soft limits and new type RES_SOFT_LIMIT has been
    added. Unlike hard limits, soft limits can be directly set and do not
    need any reclaim or checks before setting them to a newer value.

    Kamezawa-San raised a question as to whether soft limit should belong
    to res_counter. Since all resources understand the basic concepts of
    hard and soft limits, it is justified to add soft limits here. Soft limits
    are a generic resource usage feature, even file system quotas support
    soft limits.

    Signed-off-by: Balbir Singh <balbir@linux.vnet.ibm.com>
    ---

    include/linux/res_counter.h | 47 +++++++++++++++++++++++++++++++++++++++++++
    kernel/res_counter.c | 3 +++
    mm/memcontrol.c | 20 ++++++++++++++++++
    3 files changed, 70 insertions(+), 0 deletions(-)


    diff --git a/include/linux/res_counter.h b/include/linux/res_counter.h
    index 4c5bcf6..b5f14fa 100644
    --- a/include/linux/res_counter.h
    +++ b/include/linux/res_counter.h
    @@ -35,6 +35,10 @@ struct res_counter {
    */
    unsigned long long limit;
    /*
    + * the limit that usage can be exceed
    + */
    + unsigned long long soft_limit;
    + /*
    * the number of unsuccessful attempts to consume the resource
    */
    unsigned long long failcnt;
    @@ -85,6 +89,7 @@ enum {
    RES_MAX_USAGE,
    RES_LIMIT,
    RES_FAILCNT,
    + RES_SOFT_LIMIT,
    };

    /*
    @@ -130,6 +135,36 @@ static inline bool res_counter_limit_check_locked(struct res_counter *cnt)
    return false;
    }

    +static inline bool res_counter_soft_limit_check_locked(struct res_counter *cnt)
    +{
    + if (cnt->usage < cnt->soft_limit)
    + return true;
    +
    + return false;
    +}
    +
    +/**
    + * Get the difference between the usage and the soft limit
    + * @cnt: The counter
    + *
    + * Returns 0 if usage is less than or equal to soft limit
    + * The difference between usage and soft limit, otherwise.
    + */
    +static inline unsigned long long
    +res_counter_soft_limit_excess(struct res_counter *cnt)
    +{
    + unsigned long long excess;
    + unsigned long flags;
    +
    + spin_lock_irqsave(&cnt->lock, flags);
    + if (cnt->usage <= cnt->soft_limit)
    + excess = 0;
    + else
    + excess = cnt->usage - cnt->soft_limit;
    + spin_unlock_irqrestore(&cnt->lock, flags);
    + return excess;
    +}
    +
    /*
    * Helper function to detect if the cgroup is within it's limit or
    * not. It's currently called from cgroup_rss_prepare()
    @@ -178,4 +213,16 @@ static inline int res_counter_set_limit(struct res_counter *cnt,
    return ret;
    }

    +static inline int
    +res_counter_set_soft_limit(struct res_counter *cnt,
    + unsigned long long soft_limit)
    +{
    + unsigned long flags;
    +
    + spin_lock_irqsave(&cnt->lock, flags);
    + cnt->soft_limit = soft_limit;
    + spin_unlock_irqrestore(&cnt->lock, flags);
    + return 0;
    +}
    +
    #endif
    diff --git a/kernel/res_counter.c b/kernel/res_counter.c
    index bf8e753..4e6dafe 100644
    --- a/kernel/res_counter.c
    +++ b/kernel/res_counter.c
    @@ -19,6 +19,7 @@ void res_counter_init(struct res_counter *counter, struct res_counter *parent)
    {
    spin_lock_init(&counter->lock);
    counter->limit = (unsigned long long)LLONG_MAX;
    + counter->soft_limit = (unsigned long long)LLONG_MAX;
    counter->parent = parent;
    }

    @@ -101,6 +102,8 @@ res_counter_member(struct res_counter *counter, int member)
    return &counter->limit;
    case RES_FAILCNT:
    return &counter->failcnt;
    + case RES_SOFT_LIMIT:
    + return &counter->soft_limit;
    };

    BUG();
    diff --git a/mm/memcontrol.c b/mm/memcontrol.c
    index 7bb14fd..75a7b1a 100644
    --- a/mm/memcontrol.c
    +++ b/mm/memcontrol.c
    @@ -1939,6 +1939,20 @@ static int mem_cgroup_write(struct cgroup *cont, struct cftype *cft,
    else
    ret = mem_cgroup_resize_memsw_limit(memcg, val);
    break;
    + case RES_SOFT_LIMIT:
    + ret = res_counter_memparse_write_strategy(buffer, &val);
    + if (ret)
    + break;
    + /*
    + * For memsw, soft limits are hard to implement in terms
    + * of semantics, for now, we support soft limits for
    + * control without swap
    + */
    + if (type == _MEM)
    + ret = res_counter_set_soft_limit(&memcg->res, val);
    + else
    + ret = -EINVAL;
    + break;
    default:
    ret = -EINVAL; /* should be BUG() ? */
    break;
    @@ -2188,6 +2202,12 @@ static struct cftype mem_cgroup_files[] = {
    .read_u64 = mem_cgroup_read,
    },
    {
    + .name = "soft_limit_in_bytes",
    + .private = MEMFILE_PRIVATE(_MEM, RES_SOFT_LIMIT),
    + .write_string = mem_cgroup_write,
    + .read_u64 = mem_cgroup_read,
    + },
    + {
    .name = "failcnt",
    .private = MEMFILE_PRIVATE(_MEM, RES_FAILCNT),
    .trigger = mem_cgroup_reset,
    --
    Balbir


    \
     
     \ /
      Last update: 2009-03-01 07:33    [W:0.040 / U:32.156 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site