Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-only
2 :
3 : #include <linux/stat.h>
4 : #include <linux/sysctl.h>
5 : #include <linux/slab.h>
6 : #include <linux/cred.h>
7 : #include <linux/hash.h>
8 : #include <linux/kmemleak.h>
9 : #include <linux/user_namespace.h>
10 :
11 : struct ucounts init_ucounts = {
12 : .ns = &init_user_ns,
13 : .uid = GLOBAL_ROOT_UID,
14 : .count = ATOMIC_INIT(1),
15 : };
16 :
17 : #define UCOUNTS_HASHTABLE_BITS 10
18 : static struct hlist_head ucounts_hashtable[(1 << UCOUNTS_HASHTABLE_BITS)];
19 : static DEFINE_SPINLOCK(ucounts_lock);
20 :
21 : #define ucounts_hashfn(ns, uid) \
22 : hash_long((unsigned long)__kuid_val(uid) + (unsigned long)(ns), \
23 : UCOUNTS_HASHTABLE_BITS)
24 : #define ucounts_hashentry(ns, uid) \
25 : (ucounts_hashtable + ucounts_hashfn(ns, uid))
26 :
27 :
28 : #ifdef CONFIG_SYSCTL
29 : static struct ctl_table_set *
30 0 : set_lookup(struct ctl_table_root *root)
31 : {
32 0 : return ¤t_user_ns()->set;
33 : }
34 :
35 0 : static int set_is_seen(struct ctl_table_set *set)
36 : {
37 0 : return ¤t_user_ns()->set == set;
38 : }
39 :
40 0 : static int set_permissions(struct ctl_table_header *head,
41 : struct ctl_table *table)
42 : {
43 0 : struct user_namespace *user_ns =
44 0 : container_of(head->set, struct user_namespace, set);
45 : int mode;
46 :
47 : /* Allow users with CAP_SYS_RESOURCE unrestrained access */
48 0 : if (ns_capable(user_ns, CAP_SYS_RESOURCE))
49 0 : mode = (table->mode & S_IRWXU) >> 6;
50 : else
51 : /* Allow all others at most read-only access */
52 0 : mode = table->mode & S_IROTH;
53 0 : return (mode << 6) | (mode << 3) | mode;
54 : }
55 :
56 : static struct ctl_table_root set_root = {
57 : .lookup = set_lookup,
58 : .permissions = set_permissions,
59 : };
60 :
61 : static long ue_zero = 0;
62 : static long ue_int_max = INT_MAX;
63 :
64 : #define UCOUNT_ENTRY(name) \
65 : { \
66 : .procname = name, \
67 : .maxlen = sizeof(long), \
68 : .mode = 0644, \
69 : .proc_handler = proc_doulongvec_minmax, \
70 : .extra1 = &ue_zero, \
71 : .extra2 = &ue_int_max, \
72 : }
73 : static struct ctl_table user_table[] = {
74 : UCOUNT_ENTRY("max_user_namespaces"),
75 : UCOUNT_ENTRY("max_pid_namespaces"),
76 : UCOUNT_ENTRY("max_uts_namespaces"),
77 : UCOUNT_ENTRY("max_ipc_namespaces"),
78 : UCOUNT_ENTRY("max_net_namespaces"),
79 : UCOUNT_ENTRY("max_mnt_namespaces"),
80 : UCOUNT_ENTRY("max_cgroup_namespaces"),
81 : UCOUNT_ENTRY("max_time_namespaces"),
82 : #ifdef CONFIG_INOTIFY_USER
83 : UCOUNT_ENTRY("max_inotify_instances"),
84 : UCOUNT_ENTRY("max_inotify_watches"),
85 : #endif
86 : #ifdef CONFIG_FANOTIFY
87 : UCOUNT_ENTRY("max_fanotify_groups"),
88 : UCOUNT_ENTRY("max_fanotify_marks"),
89 : #endif
90 : { }
91 : };
92 : #endif /* CONFIG_SYSCTL */
93 :
94 1 : bool setup_userns_sysctls(struct user_namespace *ns)
95 : {
96 : #ifdef CONFIG_SYSCTL
97 : struct ctl_table *tbl;
98 :
99 : BUILD_BUG_ON(ARRAY_SIZE(user_table) != UCOUNT_COUNTS + 1);
100 1 : setup_sysctl_set(&ns->set, &set_root, set_is_seen);
101 1 : tbl = kmemdup(user_table, sizeof(user_table), GFP_KERNEL);
102 1 : if (tbl) {
103 : int i;
104 10 : for (i = 0; i < UCOUNT_COUNTS; i++) {
105 10 : tbl[i].data = &ns->ucount_max[i];
106 : }
107 1 : ns->sysctls = __register_sysctl_table(&ns->set, "user", tbl);
108 : }
109 1 : if (!ns->sysctls) {
110 0 : kfree(tbl);
111 0 : retire_sysctl_set(&ns->set);
112 0 : return false;
113 : }
114 : #endif
115 : return true;
116 : }
117 :
118 0 : void retire_userns_sysctls(struct user_namespace *ns)
119 : {
120 : #ifdef CONFIG_SYSCTL
121 : struct ctl_table *tbl;
122 :
123 0 : tbl = ns->sysctls->ctl_table_arg;
124 0 : unregister_sysctl_table(ns->sysctls);
125 0 : retire_sysctl_set(&ns->set);
126 0 : kfree(tbl);
127 : #endif
128 0 : }
129 :
130 : static struct ucounts *find_ucounts(struct user_namespace *ns, kuid_t uid, struct hlist_head *hashent)
131 : {
132 : struct ucounts *ucounts;
133 :
134 2 : hlist_for_each_entry(ucounts, hashent, node) {
135 0 : if (uid_eq(ucounts->uid, uid) && (ucounts->ns == ns))
136 : return ucounts;
137 : }
138 : return NULL;
139 : }
140 :
141 1 : static void hlist_add_ucounts(struct ucounts *ucounts)
142 : {
143 2 : struct hlist_head *hashent = ucounts_hashentry(ucounts->ns, ucounts->uid);
144 1 : spin_lock_irq(&ucounts_lock);
145 2 : hlist_add_head(&ucounts->node, hashent);
146 1 : spin_unlock_irq(&ucounts_lock);
147 1 : }
148 :
149 : static inline bool get_ucounts_or_wrap(struct ucounts *ucounts)
150 : {
151 : /* Returns true on a successful get, false if the count wraps. */
152 680 : return !atomic_add_negative(1, &ucounts->count);
153 : }
154 :
155 340 : struct ucounts *get_ucounts(struct ucounts *ucounts)
156 : {
157 340 : if (!get_ucounts_or_wrap(ucounts)) {
158 0 : put_ucounts(ucounts);
159 0 : ucounts = NULL;
160 : }
161 340 : return ucounts;
162 : }
163 :
164 1 : struct ucounts *alloc_ucounts(struct user_namespace *ns, kuid_t uid)
165 : {
166 2 : struct hlist_head *hashent = ucounts_hashentry(ns, uid);
167 : struct ucounts *ucounts, *new;
168 : bool wrapped;
169 :
170 1 : spin_lock_irq(&ucounts_lock);
171 1 : ucounts = find_ucounts(ns, uid, hashent);
172 1 : if (!ucounts) {
173 1 : spin_unlock_irq(&ucounts_lock);
174 :
175 1 : new = kzalloc(sizeof(*new), GFP_KERNEL);
176 1 : if (!new)
177 : return NULL;
178 :
179 1 : new->ns = ns;
180 1 : new->uid = uid;
181 2 : atomic_set(&new->count, 1);
182 :
183 1 : spin_lock_irq(&ucounts_lock);
184 1 : ucounts = find_ucounts(ns, uid, hashent);
185 1 : if (ucounts) {
186 0 : kfree(new);
187 : } else {
188 2 : hlist_add_head(&new->node, hashent);
189 1 : get_user_ns(new->ns);
190 1 : spin_unlock_irq(&ucounts_lock);
191 1 : return new;
192 : }
193 : }
194 0 : wrapped = !get_ucounts_or_wrap(ucounts);
195 0 : spin_unlock_irq(&ucounts_lock);
196 0 : if (wrapped) {
197 0 : put_ucounts(ucounts);
198 0 : return NULL;
199 : }
200 : return ucounts;
201 : }
202 :
203 324 : void put_ucounts(struct ucounts *ucounts)
204 : {
205 : unsigned long flags;
206 :
207 324 : if (atomic_dec_and_lock_irqsave(&ucounts->count, &ucounts_lock, flags)) {
208 0 : hlist_del_init(&ucounts->node);
209 0 : spin_unlock_irqrestore(&ucounts_lock, flags);
210 0 : put_user_ns(ucounts->ns);
211 0 : kfree(ucounts);
212 : }
213 324 : }
214 :
215 : static inline bool atomic_long_inc_below(atomic_long_t *v, int u)
216 : {
217 : long c, old;
218 1 : c = atomic_long_read(v);
219 : for (;;) {
220 1 : if (unlikely(c >= u))
221 : return false;
222 2 : old = atomic_long_cmpxchg(v, c, c+1);
223 1 : if (likely(old == c))
224 : return true;
225 : c = old;
226 : }
227 : }
228 :
229 1 : struct ucounts *inc_ucount(struct user_namespace *ns, kuid_t uid,
230 : enum ucount_type type)
231 : {
232 : struct ucounts *ucounts, *iter, *bad;
233 : struct user_namespace *tns;
234 1 : ucounts = alloc_ucounts(ns, uid);
235 2 : for (iter = ucounts; iter; iter = tns->ucounts) {
236 : long max;
237 1 : tns = iter->ns;
238 1 : max = READ_ONCE(tns->ucount_max[type]);
239 2 : if (!atomic_long_inc_below(&iter->ucount[type], max))
240 : goto fail;
241 : }
242 : return ucounts;
243 : fail:
244 : bad = iter;
245 0 : for (iter = ucounts; iter != bad; iter = iter->ns->ucounts)
246 0 : atomic_long_dec(&iter->ucount[type]);
247 :
248 0 : put_ucounts(ucounts);
249 0 : return NULL;
250 : }
251 :
252 0 : void dec_ucount(struct ucounts *ucounts, enum ucount_type type)
253 : {
254 : struct ucounts *iter;
255 0 : for (iter = ucounts; iter; iter = iter->ns->ucounts) {
256 0 : long dec = atomic_long_dec_if_positive(&iter->ucount[type]);
257 0 : WARN_ON_ONCE(dec < 0);
258 : }
259 0 : put_ucounts(ucounts);
260 0 : }
261 :
262 340 : long inc_rlimit_ucounts(struct ucounts *ucounts, enum rlimit_type type, long v)
263 : {
264 : struct ucounts *iter;
265 341 : long max = LONG_MAX;
266 341 : long ret = 0;
267 :
268 682 : for (iter = ucounts; iter; iter = iter->ns->ucounts) {
269 682 : long new = atomic_long_add_return(v, &iter->rlimit[type]);
270 340 : if (new < 0 || new > max)
271 : ret = LONG_MAX;
272 340 : else if (iter == ucounts)
273 340 : ret = new;
274 682 : max = get_userns_rlimit_max(iter->ns, type);
275 : }
276 340 : return ret;
277 : }
278 :
279 325 : bool dec_rlimit_ucounts(struct ucounts *ucounts, enum rlimit_type type, long v)
280 : {
281 : struct ucounts *iter;
282 325 : long new = -1; /* Silence compiler warning */
283 650 : for (iter = ucounts; iter; iter = iter->ns->ucounts) {
284 650 : long dec = atomic_long_sub_return(v, &iter->rlimit[type]);
285 325 : WARN_ON_ONCE(dec < 0);
286 325 : if (iter == ucounts)
287 325 : new = dec;
288 : }
289 325 : return (new == 0);
290 : }
291 :
292 0 : static void do_dec_rlimit_put_ucounts(struct ucounts *ucounts,
293 : struct ucounts *last, enum rlimit_type type)
294 : {
295 : struct ucounts *iter, *next;
296 0 : for (iter = ucounts; iter != last; iter = next) {
297 0 : long dec = atomic_long_sub_return(1, &iter->rlimit[type]);
298 0 : WARN_ON_ONCE(dec < 0);
299 0 : next = iter->ns->ucounts;
300 0 : if (dec == 0)
301 0 : put_ucounts(iter);
302 : }
303 0 : }
304 :
305 0 : void dec_rlimit_put_ucounts(struct ucounts *ucounts, enum rlimit_type type)
306 : {
307 0 : do_dec_rlimit_put_ucounts(ucounts, NULL, type);
308 0 : }
309 :
310 0 : long inc_rlimit_get_ucounts(struct ucounts *ucounts, enum rlimit_type type)
311 : {
312 : /* Caller must hold a reference to ucounts */
313 : struct ucounts *iter;
314 0 : long max = LONG_MAX;
315 0 : long dec, ret = 0;
316 :
317 0 : for (iter = ucounts; iter; iter = iter->ns->ucounts) {
318 0 : long new = atomic_long_add_return(1, &iter->rlimit[type]);
319 0 : if (new < 0 || new > max)
320 : goto unwind;
321 0 : if (iter == ucounts)
322 0 : ret = new;
323 0 : max = get_userns_rlimit_max(iter->ns, type);
324 : /*
325 : * Grab an extra ucount reference for the caller when
326 : * the rlimit count was previously 0.
327 : */
328 0 : if (new != 1)
329 0 : continue;
330 0 : if (!get_ucounts(iter))
331 : goto dec_unwind;
332 : }
333 : return ret;
334 : dec_unwind:
335 0 : dec = atomic_long_sub_return(1, &iter->rlimit[type]);
336 0 : WARN_ON_ONCE(dec < 0);
337 : unwind:
338 0 : do_dec_rlimit_put_ucounts(ucounts, iter, type);
339 0 : return 0;
340 : }
341 :
342 340 : bool is_rlimit_overlimit(struct ucounts *ucounts, enum rlimit_type type, unsigned long rlimit)
343 : {
344 : struct ucounts *iter;
345 340 : long max = rlimit;
346 340 : if (rlimit > LONG_MAX)
347 0 : max = LONG_MAX;
348 340 : for (iter = ucounts; iter; iter = iter->ns->ucounts) {
349 340 : long val = get_rlimit_value(iter, type);
350 340 : if (val < 0 || val > max)
351 : return true;
352 680 : max = get_userns_rlimit_max(iter->ns, type);
353 : }
354 : return false;
355 : }
356 :
357 1 : static __init int user_namespace_sysctl_init(void)
358 : {
359 : #ifdef CONFIG_SYSCTL
360 : static struct ctl_table_header *user_header;
361 : static struct ctl_table empty[1];
362 : /*
363 : * It is necessary to register the user directory in the
364 : * default set so that registrations in the child sets work
365 : * properly.
366 : */
367 1 : user_header = register_sysctl("user", empty);
368 1 : kmemleak_ignore(user_header);
369 1 : BUG_ON(!user_header);
370 1 : BUG_ON(!setup_userns_sysctls(&init_user_ns));
371 : #endif
372 1 : hlist_add_ucounts(&init_ucounts);
373 1 : inc_rlimit_ucounts(&init_ucounts, UCOUNT_RLIMIT_NPROC, 1);
374 1 : return 0;
375 : }
376 : subsys_initcall(user_namespace_sysctl_init);
|
