Commit | Line | Data |
---|---|---|
e552b661 PE |
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> | |
856c13aa | 15 | #include <linux/mm.h> |
e552b661 | 16 | |
28dbc4b6 | 17 | void res_counter_init(struct res_counter *counter, struct res_counter *parent) |
e552b661 PE |
18 | { |
19 | spin_lock_init(&counter->lock); | |
6de5a8bf SZ |
20 | counter->limit = RES_COUNTER_MAX; |
21 | counter->soft_limit = RES_COUNTER_MAX; | |
28dbc4b6 | 22 | counter->parent = parent; |
e552b661 PE |
23 | } |
24 | ||
539a13b4 DR |
25 | static u64 res_counter_uncharge_locked(struct res_counter *counter, |
26 | unsigned long val) | |
27 | { | |
28 | if (WARN_ON(counter->usage < val)) | |
29 | val = counter->usage; | |
30 | ||
31 | counter->usage -= val; | |
32 | return counter->usage; | |
33 | } | |
34 | ||
35 | static int res_counter_charge_locked(struct res_counter *counter, | |
36 | unsigned long val, bool force) | |
e552b661 | 37 | { |
4d8438f0 FW |
38 | int ret = 0; |
39 | ||
e552b661 PE |
40 | if (counter->usage + val > counter->limit) { |
41 | counter->failcnt++; | |
4d8438f0 FW |
42 | ret = -ENOMEM; |
43 | if (!force) | |
44 | return ret; | |
e552b661 PE |
45 | } |
46 | ||
47 | counter->usage += val; | |
0d4dde1a | 48 | if (counter->usage > counter->max_usage) |
c84872e1 | 49 | counter->max_usage = counter->usage; |
4d8438f0 | 50 | return ret; |
e552b661 PE |
51 | } |
52 | ||
4d8438f0 FW |
53 | static int __res_counter_charge(struct res_counter *counter, unsigned long val, |
54 | struct res_counter **limit_fail_at, bool force) | |
e552b661 | 55 | { |
4d8438f0 | 56 | int ret, r; |
e552b661 | 57 | unsigned long flags; |
28dbc4b6 | 58 | struct res_counter *c, *u; |
e552b661 | 59 | |
4d8438f0 | 60 | r = ret = 0; |
28dbc4b6 BS |
61 | *limit_fail_at = NULL; |
62 | local_irq_save(flags); | |
63 | for (c = counter; c != NULL; c = c->parent) { | |
64 | spin_lock(&c->lock); | |
4d8438f0 | 65 | r = res_counter_charge_locked(c, val, force); |
28dbc4b6 | 66 | spin_unlock(&c->lock); |
4d8438f0 FW |
67 | if (r < 0 && !ret) { |
68 | ret = r; | |
28dbc4b6 | 69 | *limit_fail_at = c; |
4d8438f0 FW |
70 | if (!force) |
71 | break; | |
28dbc4b6 BS |
72 | } |
73 | } | |
4d8438f0 FW |
74 | |
75 | if (ret < 0 && !force) { | |
76 | for (u = counter; u != c; u = u->parent) { | |
77 | spin_lock(&u->lock); | |
78 | res_counter_uncharge_locked(u, val); | |
79 | spin_unlock(&u->lock); | |
80 | } | |
28dbc4b6 | 81 | } |
28dbc4b6 | 82 | local_irq_restore(flags); |
4d8438f0 | 83 | |
e552b661 PE |
84 | return ret; |
85 | } | |
86 | ||
4d8438f0 FW |
87 | int res_counter_charge(struct res_counter *counter, unsigned long val, |
88 | struct res_counter **limit_fail_at) | |
89 | { | |
90 | return __res_counter_charge(counter, val, limit_fail_at, false); | |
91 | } | |
92 | ||
0e90b31f GC |
93 | int res_counter_charge_nofail(struct res_counter *counter, unsigned long val, |
94 | struct res_counter **limit_fail_at) | |
95 | { | |
4d8438f0 | 96 | return __res_counter_charge(counter, val, limit_fail_at, true); |
0e90b31f | 97 | } |
4d8438f0 | 98 | |
50bdd430 GC |
99 | u64 res_counter_uncharge_until(struct res_counter *counter, |
100 | struct res_counter *top, | |
101 | unsigned long val) | |
e552b661 PE |
102 | { |
103 | unsigned long flags; | |
28dbc4b6 | 104 | struct res_counter *c; |
50bdd430 | 105 | u64 ret = 0; |
e552b661 | 106 | |
28dbc4b6 | 107 | local_irq_save(flags); |
2bb2ba9d | 108 | for (c = counter; c != top; c = c->parent) { |
50bdd430 | 109 | u64 r; |
28dbc4b6 | 110 | spin_lock(&c->lock); |
50bdd430 GC |
111 | r = res_counter_uncharge_locked(c, val); |
112 | if (c == counter) | |
113 | ret = r; | |
28dbc4b6 BS |
114 | spin_unlock(&c->lock); |
115 | } | |
116 | local_irq_restore(flags); | |
50bdd430 | 117 | return ret; |
e552b661 PE |
118 | } |
119 | ||
50bdd430 | 120 | u64 res_counter_uncharge(struct res_counter *counter, unsigned long val) |
2bb2ba9d | 121 | { |
50bdd430 | 122 | return res_counter_uncharge_until(counter, NULL, val); |
2bb2ba9d | 123 | } |
e552b661 | 124 | |
0eea1030 BS |
125 | static inline unsigned long long * |
126 | res_counter_member(struct res_counter *counter, int member) | |
e552b661 PE |
127 | { |
128 | switch (member) { | |
129 | case RES_USAGE: | |
130 | return &counter->usage; | |
c84872e1 PE |
131 | case RES_MAX_USAGE: |
132 | return &counter->max_usage; | |
e552b661 PE |
133 | case RES_LIMIT: |
134 | return &counter->limit; | |
135 | case RES_FAILCNT: | |
136 | return &counter->failcnt; | |
296c81d8 BS |
137 | case RES_SOFT_LIMIT: |
138 | return &counter->soft_limit; | |
e552b661 PE |
139 | }; |
140 | ||
141 | BUG(); | |
142 | return NULL; | |
143 | } | |
144 | ||
145 | ssize_t res_counter_read(struct res_counter *counter, int member, | |
0eea1030 BS |
146 | const char __user *userbuf, size_t nbytes, loff_t *pos, |
147 | int (*read_strategy)(unsigned long long val, char *st_buf)) | |
e552b661 | 148 | { |
0eea1030 | 149 | unsigned long long *val; |
e552b661 PE |
150 | char buf[64], *s; |
151 | ||
152 | s = buf; | |
153 | val = res_counter_member(counter, member); | |
0eea1030 BS |
154 | if (read_strategy) |
155 | s += read_strategy(*val, s); | |
156 | else | |
157 | s += sprintf(s, "%llu\n", *val); | |
e552b661 PE |
158 | return simple_read_from_buffer((void __user *)userbuf, nbytes, |
159 | pos, buf, s - buf); | |
160 | } | |
161 | ||
6c191cd0 KH |
162 | #if BITS_PER_LONG == 32 |
163 | u64 res_counter_read_u64(struct res_counter *counter, int member) | |
164 | { | |
165 | unsigned long flags; | |
166 | u64 ret; | |
167 | ||
168 | spin_lock_irqsave(&counter->lock, flags); | |
169 | ret = *res_counter_member(counter, member); | |
170 | spin_unlock_irqrestore(&counter->lock, flags); | |
171 | ||
172 | return ret; | |
173 | } | |
174 | #else | |
2c7eabf3 PM |
175 | u64 res_counter_read_u64(struct res_counter *counter, int member) |
176 | { | |
177 | return *res_counter_member(counter, member); | |
178 | } | |
6c191cd0 | 179 | #endif |
2c7eabf3 | 180 | |
856c13aa | 181 | int res_counter_memparse_write_strategy(const char *buf, |
1a36e59d | 182 | unsigned long long *resp) |
e552b661 | 183 | { |
856c13aa | 184 | char *end; |
1a36e59d | 185 | unsigned long long res; |
c5b947b2 | 186 | |
6de5a8bf | 187 | /* return RES_COUNTER_MAX(unlimited) if "-1" is specified */ |
c5b947b2 | 188 | if (*buf == '-') { |
6c5a53c6 FF |
189 | int rc = kstrtoull(buf + 1, 10, &res); |
190 | ||
191 | if (rc) | |
192 | return rc; | |
193 | if (res != 1) | |
c5b947b2 | 194 | return -EINVAL; |
1a36e59d | 195 | *resp = RES_COUNTER_MAX; |
c5b947b2 DN |
196 | return 0; |
197 | } | |
198 | ||
1a36e59d | 199 | res = memparse(buf, &end); |
856c13aa PM |
200 | if (*end != '\0') |
201 | return -EINVAL; | |
e552b661 | 202 | |
1a36e59d SZ |
203 | if (PAGE_ALIGN(res) >= res) |
204 | res = PAGE_ALIGN(res); | |
3af33516 | 205 | else |
1a36e59d SZ |
206 | res = RES_COUNTER_MAX; |
207 | ||
208 | *resp = res; | |
3af33516 | 209 | |
856c13aa PM |
210 | return 0; |
211 | } |