]>
Commit | Line | Data |
---|---|---|
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 | ||
17 | void res_counter_init(struct res_counter *counter, struct res_counter *parent) | |
18 | { | |
19 | spin_lock_init(&counter->lock); | |
20 | counter->limit = RES_COUNTER_MAX; | |
21 | counter->soft_limit = RES_COUNTER_MAX; | |
22 | counter->parent = parent; | |
23 | } | |
24 | ||
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) | |
37 | { | |
38 | int ret = 0; | |
39 | ||
40 | if (counter->usage + val > counter->limit) { | |
41 | counter->failcnt++; | |
42 | ret = -ENOMEM; | |
43 | if (!force) | |
44 | return ret; | |
45 | } | |
46 | ||
47 | counter->usage += val; | |
48 | if (counter->usage > counter->max_usage) | |
49 | counter->max_usage = counter->usage; | |
50 | return ret; | |
51 | } | |
52 | ||
53 | static int __res_counter_charge(struct res_counter *counter, unsigned long val, | |
54 | struct res_counter **limit_fail_at, bool force) | |
55 | { | |
56 | int ret, r; | |
57 | unsigned long flags; | |
58 | struct res_counter *c, *u; | |
59 | ||
60 | r = ret = 0; | |
61 | *limit_fail_at = NULL; | |
62 | local_irq_save(flags); | |
63 | for (c = counter; c != NULL; c = c->parent) { | |
64 | spin_lock(&c->lock); | |
65 | r = res_counter_charge_locked(c, val, force); | |
66 | spin_unlock(&c->lock); | |
67 | if (r < 0 && !ret) { | |
68 | ret = r; | |
69 | *limit_fail_at = c; | |
70 | if (!force) | |
71 | break; | |
72 | } | |
73 | } | |
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 | } | |
81 | } | |
82 | local_irq_restore(flags); | |
83 | ||
84 | return ret; | |
85 | } | |
86 | ||
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 | ||
93 | int res_counter_charge_nofail(struct res_counter *counter, unsigned long val, | |
94 | struct res_counter **limit_fail_at) | |
95 | { | |
96 | return __res_counter_charge(counter, val, limit_fail_at, true); | |
97 | } | |
98 | ||
99 | u64 res_counter_uncharge_until(struct res_counter *counter, | |
100 | struct res_counter *top, | |
101 | unsigned long val) | |
102 | { | |
103 | unsigned long flags; | |
104 | struct res_counter *c; | |
105 | u64 ret = 0; | |
106 | ||
107 | local_irq_save(flags); | |
108 | for (c = counter; c != top; c = c->parent) { | |
109 | u64 r; | |
110 | spin_lock(&c->lock); | |
111 | r = res_counter_uncharge_locked(c, val); | |
112 | if (c == counter) | |
113 | ret = r; | |
114 | spin_unlock(&c->lock); | |
115 | } | |
116 | local_irq_restore(flags); | |
117 | return ret; | |
118 | } | |
119 | ||
120 | u64 res_counter_uncharge(struct res_counter *counter, unsigned long val) | |
121 | { | |
122 | return res_counter_uncharge_until(counter, NULL, val); | |
123 | } | |
124 | ||
125 | static inline unsigned long long * | |
126 | res_counter_member(struct res_counter *counter, int member) | |
127 | { | |
128 | switch (member) { | |
129 | case RES_USAGE: | |
130 | return &counter->usage; | |
131 | case RES_MAX_USAGE: | |
132 | return &counter->max_usage; | |
133 | case RES_LIMIT: | |
134 | return &counter->limit; | |
135 | case RES_FAILCNT: | |
136 | return &counter->failcnt; | |
137 | case RES_SOFT_LIMIT: | |
138 | return &counter->soft_limit; | |
139 | }; | |
140 | ||
141 | BUG(); | |
142 | return NULL; | |
143 | } | |
144 | ||
145 | ssize_t res_counter_read(struct res_counter *counter, int member, | |
146 | const char __user *userbuf, size_t nbytes, loff_t *pos, | |
147 | int (*read_strategy)(unsigned long long val, char *st_buf)) | |
148 | { | |
149 | unsigned long long *val; | |
150 | char buf[64], *s; | |
151 | ||
152 | s = buf; | |
153 | val = res_counter_member(counter, member); | |
154 | if (read_strategy) | |
155 | s += read_strategy(*val, s); | |
156 | else | |
157 | s += sprintf(s, "%llu\n", *val); | |
158 | return simple_read_from_buffer((void __user *)userbuf, nbytes, | |
159 | pos, buf, s - buf); | |
160 | } | |
161 | ||
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 | |
175 | u64 res_counter_read_u64(struct res_counter *counter, int member) | |
176 | { | |
177 | return *res_counter_member(counter, member); | |
178 | } | |
179 | #endif | |
180 | ||
181 | int res_counter_memparse_write_strategy(const char *buf, | |
182 | unsigned long long *resp) | |
183 | { | |
184 | char *end; | |
185 | unsigned long long res; | |
186 | ||
187 | /* return RES_COUNTER_MAX(unlimited) if "-1" is specified */ | |
188 | if (*buf == '-') { | |
189 | res = simple_strtoull(buf + 1, &end, 10); | |
190 | if (res != 1 || *end != '\0') | |
191 | return -EINVAL; | |
192 | *resp = RES_COUNTER_MAX; | |
193 | return 0; | |
194 | } | |
195 | ||
196 | res = memparse(buf, &end); | |
197 | if (*end != '\0') | |
198 | return -EINVAL; | |
199 | ||
200 | if (PAGE_ALIGN(res) >= res) | |
201 | res = PAGE_ALIGN(res); | |
202 | else | |
203 | res = RES_COUNTER_MAX; | |
204 | ||
205 | *resp = res; | |
206 | ||
207 | return 0; | |
208 | } |