kernel/res_counter.c

   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/slab.h>
  14 #include <linux/res_counter.h>
  15 #include <linux/uaccess.h>
  16
  17 void res_counter_init(struct res_counter *counter)
  18 {
  19         spin_lock_init(&counter->lock);
  20         counter->limit = (unsigned long long)LLONG_MAX;
  21 }
  22
  23 int res_counter_charge_locked(struct res_counter *counter, unsigned long val)
  24 {
  25         if (counter->usage + val > counter->limit) {
  26                 counter->failcnt++;
  27                 return -ENOMEM;
  28         }
  29
  30         counter->usage += val;
  31         return 0;
  32 }
  33
  34 int res_counter_charge(struct res_counter *counter, unsigned long val)
  35 {
  36         int ret;
  37         unsigned long flags;
  38
  39         spin_lock_irqsave(&counter->lock, flags);
  40         ret = res_counter_charge_locked(counter, val);
  41         spin_unlock_irqrestore(&counter->lock, flags);
  42         return ret;
  43 }
  44
  45 void res_counter_uncharge_locked(struct res_counter *counter, unsigned long val)
  46 {
  47         if (WARN_ON(counter->usage < val))
  48                 val = counter->usage;
  49
  50         counter->usage -= val;
  51 }
  52
  53 void res_counter_uncharge(struct res_counter *counter, unsigned long val)
  54 {
  55         unsigned long flags;
  56
  57         spin_lock_irqsave(&counter->lock, flags);
  58         res_counter_uncharge_locked(counter, val);
  59         spin_unlock_irqrestore(&counter->lock, flags);
  60 }
  61
  62
  63 static inline unsigned long long *
  64 res_counter_member(struct res_counter *counter, int member)
  65 {
  66         switch (member) {
  67         case RES_USAGE:
  68                 return &counter->usage;
  69         case RES_LIMIT:
  70                 return &counter->limit;
  71         case RES_FAILCNT:
  72                 return &counter->failcnt;
  73         };
  74
  75         BUG();
  76         return NULL;
  77 }
  78
  79 ssize_t res_counter_read(struct res_counter *counter, int member,
  80                 const char __user *userbuf, size_t nbytes, loff_t *pos,
  81                 int (*read_strategy)(unsigned long long val, char *st_buf))
  82 {
  83         unsigned long long *val;
  84         char buf[64], *s;
  85
  86         s = buf;
  87         val = res_counter_member(counter, member);
  88         if (read_strategy)
  89                 s += read_strategy(*val, s);
  90         else
  91                 s += sprintf(s, "%llu\n", *val);
  92         return simple_read_from_buffer((void __user *)userbuf, nbytes,
  93                         pos, buf, s - buf);
  94 }
  95
  96 u64 res_counter_read_u64(struct res_counter *counter, int member)
  97 {
  98         return *res_counter_member(counter, member);
  99 }
 100
 101 ssize_t res_counter_write(struct res_counter *counter, int member,
 102                 const char __user *userbuf, size_t nbytes, loff_t *pos,
 103                 int (*write_strategy)(char *st_buf, unsigned long long *val))
 104 {
 105         int ret;
 106         char *buf, *end;
 107         unsigned long flags;
 108         unsigned long long tmp, *val;
 109
 110         buf = kmalloc(nbytes + 1, GFP_KERNEL);
 111         ret = -ENOMEM;
 112         if (buf == NULL)
 113                 goto out;
 114
 115         buf[nbytes] = '\0';
 116         ret = -EFAULT;
 117         if (copy_from_user(buf, userbuf, nbytes))
 118                 goto out_free;
 119
 120         ret = -EINVAL;
 121
 122         strstrip(buf);
 123         if (write_strategy) {
 124                 if (write_strategy(buf, &tmp)) {
 125                         goto out_free;
 126                 }
 127         } else {
 128                 tmp = simple_strtoull(buf, &end, 10);
 129                 if (*end != '\0')
 130                         goto out_free;
 131         }
 132         spin_lock_irqsave(&counter->lock, flags);
 133         val = res_counter_member(counter, member);
 134         *val = tmp;
 135         spin_unlock_irqrestore(&counter->lock, flags);
 136         ret = nbytes;
 137 out_free:
 138         kfree(buf);
 139 out:
 140         return ret;
 141 }