linux/kernel/res_counter.c
<<
>>
Prefs
   1/*
   2 * resource cgroups
   3 *
   4 * Copyright 2007 OpenVZ SWsoft Inc
   5 *
   6 * Author: Pavel Emelianov <xemul@openvz.org>
   7 *
   8 */
   9
  10#include <linux/types.h>
  11#include <linux/parser.h>
  12#include <linux/fs.h>
  13#include <linux/res_counter.h>
  14#include <linux/uaccess.h>
  15#include <linux/mm.h>
  16
  17void res_counter_init(struct res_counter *counter, struct res_counter *parent)
  18{
  19        spin_lock_init(&counter->lock);
  20        counter->limit = RESOURCE_MAX;
  21        counter->soft_limit = RESOURCE_MAX;
  22        counter->parent = parent;
  23}
  24
  25int res_counter_charge_locked(struct res_counter *counter, unsigned long val)
  26{
  27        if (counter->usage + val > counter->limit) {
  28                counter->failcnt++;
  29                return -ENOMEM;
  30        }
  31
  32        counter->usage += val;
  33        if (counter->usage > counter->max_usage)
  34                counter->max_usage = counter->usage;
  35        return 0;
  36}
  37
  38int res_counter_charge(struct res_counter *counter, unsigned long val,
  39                        struct res_counter **limit_fail_at)
  40{
  41        int ret;
  42        unsigned long flags;
  43        struct res_counter *c, *u;
  44
  45        *limit_fail_at = NULL;
  46        local_irq_save(flags);
  47        for (c = counter; c != NULL; c = c->parent) {
  48                spin_lock(&c->lock);
  49                ret = res_counter_charge_locked(c, val);
  50                spin_unlock(&c->lock);
  51                if (ret < 0) {
  52                        *limit_fail_at = c;
  53                        goto undo;
  54                }
  55        }
  56        ret = 0;
  57        goto done;
  58undo:
  59        for (u = counter; u != c; u = u->parent) {
  60                spin_lock(&u->lock);
  61                res_counter_uncharge_locked(u, val);
  62                spin_unlock(&u->lock);
  63        }
  64done:
  65        local_irq_restore(flags);
  66        return ret;
  67}
  68
  69void res_counter_uncharge_locked(struct res_counter *counter, unsigned long val)
  70{
  71        if (WARN_ON(counter->usage < val))
  72                val = counter->usage;
  73
  74        counter->usage -= val;
  75}
  76
  77void res_counter_uncharge(struct res_counter *counter, unsigned long val)
  78{
  79        unsigned long flags;
  80        struct res_counter *c;
  81
  82        local_irq_save(flags);
  83        for (c = counter; c != NULL; c = c->parent) {
  84                spin_lock(&c->lock);
  85                res_counter_uncharge_locked(c, val);
  86                spin_unlock(&c->lock);
  87        }
  88        local_irq_restore(flags);
  89}
  90
  91
  92static inline unsigned long long *
  93res_counter_member(struct res_counter *counter, int member)
  94{
  95        switch (member) {
  96        case RES_USAGE:
  97                return &counter->usage;
  98        case RES_MAX_USAGE:
  99                return &counter->max_usage;
 100        case RES_LIMIT:
 101                return &counter->limit;
 102        case RES_FAILCNT:
 103                return &counter->failcnt;
 104        case RES_SOFT_LIMIT:
 105                return &counter->soft_limit;
 106        };
 107
 108        BUG();
 109        return NULL;
 110}
 111
 112ssize_t res_counter_read(struct res_counter *counter, int member,
 113                const char __user *userbuf, size_t nbytes, loff_t *pos,
 114                int (*read_strategy)(unsigned long long val, char *st_buf))
 115{
 116        unsigned long long *val;
 117        char buf[64], *s;
 118
 119        s = buf;
 120        val = res_counter_member(counter, member);
 121        if (read_strategy)
 122                s += read_strategy(*val, s);
 123        else
 124                s += sprintf(s, "%llu\n", *val);
 125        return simple_read_from_buffer((void __user *)userbuf, nbytes,
 126                        pos, buf, s - buf);
 127}
 128
 129#if BITS_PER_LONG == 32
 130u64 res_counter_read_u64(struct res_counter *counter, int member)
 131{
 132        unsigned long flags;
 133        u64 ret;
 134
 135        spin_lock_irqsave(&counter->lock, flags);
 136        ret = *res_counter_member(counter, member);
 137        spin_unlock_irqrestore(&counter->lock, flags);
 138
 139        return ret;
 140}
 141#else
 142u64 res_counter_read_u64(struct res_counter *counter, int member)
 143{
 144        return *res_counter_member(counter, member);
 145}
 146#endif
 147
 148int res_counter_memparse_write_strategy(const char *buf,
 149                                        unsigned long long *res)
 150{
 151        char *end;
 152
 153        /* return RESOURCE_MAX(unlimited) if "-1" is specified */
 154        if (*buf == '-') {
 155                *res = simple_strtoull(buf + 1, &end, 10);
 156                if (*res != 1 || *end != '\0')
 157                        return -EINVAL;
 158                *res = RESOURCE_MAX;
 159                return 0;
 160        }
 161
 162        /* FIXME - make memparse() take const char* args */
 163        *res = memparse((char *)buf, &end);
 164        if (*end != '\0')
 165                return -EINVAL;
 166
 167        *res = PAGE_ALIGN(*res);
 168        return 0;
 169}
 170
 171int res_counter_write(struct res_counter *counter, int member,
 172                      const char *buf, write_strategy_fn write_strategy)
 173{
 174        char *end;
 175        unsigned long flags;
 176        unsigned long long tmp, *val;
 177
 178        if (write_strategy) {
 179                if (write_strategy(buf, &tmp))
 180                        return -EINVAL;
 181        } else {
 182                tmp = simple_strtoull(buf, &end, 10);
 183                if (*end != '\0')
 184                        return -EINVAL;
 185        }
 186        spin_lock_irqsave(&counter->lock, flags);
 187        val = res_counter_member(counter, member);
 188        *val = tmp;
 189        spin_unlock_irqrestore(&counter->lock, flags);
 190        return 0;
 191}
 192
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.