Merge tag 'for-5.16/block-2021-11-09' of git://git.kernel.dk/linux-block
[linux-2.6-microblaze.git] / kernel / ucount.c
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 set_lookup(struct ctl_table_root *root)
31 {
32         return &current_user_ns()->set;
33 }
34
35 static int set_is_seen(struct ctl_table_set *set)
36 {
37         return &current_user_ns()->set == set;
38 }
39
40 static int set_permissions(struct ctl_table_header *head,
41                                   struct ctl_table *table)
42 {
43         struct user_namespace *user_ns =
44                 container_of(head->set, struct user_namespace, set);
45         int mode;
46
47         /* Allow users with CAP_SYS_RESOURCE unrestrained access */
48         if (ns_capable(user_ns, CAP_SYS_RESOURCE))
49                 mode = (table->mode & S_IRWXU) >> 6;
50         else
51         /* Allow all others at most read-only access */
52                 mode = table->mode & S_IROTH;
53         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         { },
93         { },
94         { }
95 };
96 #endif /* CONFIG_SYSCTL */
97
98 bool setup_userns_sysctls(struct user_namespace *ns)
99 {
100 #ifdef CONFIG_SYSCTL
101         struct ctl_table *tbl;
102
103         BUILD_BUG_ON(ARRAY_SIZE(user_table) != UCOUNT_COUNTS + 1);
104         setup_sysctl_set(&ns->set, &set_root, set_is_seen);
105         tbl = kmemdup(user_table, sizeof(user_table), GFP_KERNEL);
106         if (tbl) {
107                 int i;
108                 for (i = 0; i < UCOUNT_COUNTS; i++) {
109                         tbl[i].data = &ns->ucount_max[i];
110                 }
111                 ns->sysctls = __register_sysctl_table(&ns->set, "user", tbl);
112         }
113         if (!ns->sysctls) {
114                 kfree(tbl);
115                 retire_sysctl_set(&ns->set);
116                 return false;
117         }
118 #endif
119         return true;
120 }
121
122 void retire_userns_sysctls(struct user_namespace *ns)
123 {
124 #ifdef CONFIG_SYSCTL
125         struct ctl_table *tbl;
126
127         tbl = ns->sysctls->ctl_table_arg;
128         unregister_sysctl_table(ns->sysctls);
129         retire_sysctl_set(&ns->set);
130         kfree(tbl);
131 #endif
132 }
133
134 static struct ucounts *find_ucounts(struct user_namespace *ns, kuid_t uid, struct hlist_head *hashent)
135 {
136         struct ucounts *ucounts;
137
138         hlist_for_each_entry(ucounts, hashent, node) {
139                 if (uid_eq(ucounts->uid, uid) && (ucounts->ns == ns))
140                         return ucounts;
141         }
142         return NULL;
143 }
144
145 static void hlist_add_ucounts(struct ucounts *ucounts)
146 {
147         struct hlist_head *hashent = ucounts_hashentry(ucounts->ns, ucounts->uid);
148         spin_lock_irq(&ucounts_lock);
149         hlist_add_head(&ucounts->node, hashent);
150         spin_unlock_irq(&ucounts_lock);
151 }
152
153 static inline bool get_ucounts_or_wrap(struct ucounts *ucounts)
154 {
155         /* Returns true on a successful get, false if the count wraps. */
156         return !atomic_add_negative(1, &ucounts->count);
157 }
158
159 struct ucounts *get_ucounts(struct ucounts *ucounts)
160 {
161         if (!get_ucounts_or_wrap(ucounts)) {
162                 put_ucounts(ucounts);
163                 ucounts = NULL;
164         }
165         return ucounts;
166 }
167
168 struct ucounts *alloc_ucounts(struct user_namespace *ns, kuid_t uid)
169 {
170         struct hlist_head *hashent = ucounts_hashentry(ns, uid);
171         struct ucounts *ucounts, *new;
172         bool wrapped;
173
174         spin_lock_irq(&ucounts_lock);
175         ucounts = find_ucounts(ns, uid, hashent);
176         if (!ucounts) {
177                 spin_unlock_irq(&ucounts_lock);
178
179                 new = kzalloc(sizeof(*new), GFP_KERNEL);
180                 if (!new)
181                         return NULL;
182
183                 new->ns = ns;
184                 new->uid = uid;
185                 atomic_set(&new->count, 1);
186
187                 spin_lock_irq(&ucounts_lock);
188                 ucounts = find_ucounts(ns, uid, hashent);
189                 if (ucounts) {
190                         kfree(new);
191                 } else {
192                         hlist_add_head(&new->node, hashent);
193                         spin_unlock_irq(&ucounts_lock);
194                         return new;
195                 }
196         }
197         wrapped = !get_ucounts_or_wrap(ucounts);
198         spin_unlock_irq(&ucounts_lock);
199         if (wrapped) {
200                 put_ucounts(ucounts);
201                 return NULL;
202         }
203         return ucounts;
204 }
205
206 void put_ucounts(struct ucounts *ucounts)
207 {
208         unsigned long flags;
209
210         if (atomic_dec_and_lock_irqsave(&ucounts->count, &ucounts_lock, flags)) {
211                 hlist_del_init(&ucounts->node);
212                 spin_unlock_irqrestore(&ucounts_lock, flags);
213                 kfree(ucounts);
214         }
215 }
216
217 static inline bool atomic_long_inc_below(atomic_long_t *v, int u)
218 {
219         long c, old;
220         c = atomic_long_read(v);
221         for (;;) {
222                 if (unlikely(c >= u))
223                         return false;
224                 old = atomic_long_cmpxchg(v, c, c+1);
225                 if (likely(old == c))
226                         return true;
227                 c = old;
228         }
229 }
230
231 struct ucounts *inc_ucount(struct user_namespace *ns, kuid_t uid,
232                            enum ucount_type type)
233 {
234         struct ucounts *ucounts, *iter, *bad;
235         struct user_namespace *tns;
236         ucounts = alloc_ucounts(ns, uid);
237         for (iter = ucounts; iter; iter = tns->ucounts) {
238                 long max;
239                 tns = iter->ns;
240                 max = READ_ONCE(tns->ucount_max[type]);
241                 if (!atomic_long_inc_below(&iter->ucount[type], max))
242                         goto fail;
243         }
244         return ucounts;
245 fail:
246         bad = iter;
247         for (iter = ucounts; iter != bad; iter = iter->ns->ucounts)
248                 atomic_long_dec(&iter->ucount[type]);
249
250         put_ucounts(ucounts);
251         return NULL;
252 }
253
254 void dec_ucount(struct ucounts *ucounts, enum ucount_type type)
255 {
256         struct ucounts *iter;
257         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
258                 long dec = atomic_long_dec_if_positive(&iter->ucount[type]);
259                 WARN_ON_ONCE(dec < 0);
260         }
261         put_ucounts(ucounts);
262 }
263
264 long inc_rlimit_ucounts(struct ucounts *ucounts, enum ucount_type type, long v)
265 {
266         struct ucounts *iter;
267         long ret = 0;
268
269         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
270                 long max = READ_ONCE(iter->ns->ucount_max[type]);
271                 long new = atomic_long_add_return(v, &iter->ucount[type]);
272                 if (new < 0 || new > max)
273                         ret = LONG_MAX;
274                 else if (iter == ucounts)
275                         ret = new;
276         }
277         return ret;
278 }
279
280 bool dec_rlimit_ucounts(struct ucounts *ucounts, enum ucount_type type, long v)
281 {
282         struct ucounts *iter;
283         long new = -1; /* Silence compiler warning */
284         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
285                 long dec = atomic_long_sub_return(v, &iter->ucount[type]);
286                 WARN_ON_ONCE(dec < 0);
287                 if (iter == ucounts)
288                         new = dec;
289         }
290         return (new == 0);
291 }
292
293 static void do_dec_rlimit_put_ucounts(struct ucounts *ucounts,
294                                 struct ucounts *last, enum ucount_type type)
295 {
296         struct ucounts *iter, *next;
297         for (iter = ucounts; iter != last; iter = next) {
298                 long dec = atomic_long_sub_return(1, &iter->ucount[type]);
299                 WARN_ON_ONCE(dec < 0);
300                 next = iter->ns->ucounts;
301                 if (dec == 0)
302                         put_ucounts(iter);
303         }
304 }
305
306 void dec_rlimit_put_ucounts(struct ucounts *ucounts, enum ucount_type type)
307 {
308         do_dec_rlimit_put_ucounts(ucounts, NULL, type);
309 }
310
311 long inc_rlimit_get_ucounts(struct ucounts *ucounts, enum ucount_type type)
312 {
313         /* Caller must hold a reference to ucounts */
314         struct ucounts *iter;
315         long dec, ret = 0;
316
317         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
318                 long max = READ_ONCE(iter->ns->ucount_max[type]);
319                 long new = atomic_long_add_return(1, &iter->ucount[type]);
320                 if (new < 0 || new > max)
321                         goto unwind;
322                 if (iter == ucounts)
323                         ret = new;
324                 /*
325                  * Grab an extra ucount reference for the caller when
326                  * the rlimit count was previously 0.
327                  */
328                 if (new != 1)
329                         continue;
330                 if (!get_ucounts(iter))
331                         goto dec_unwind;
332         }
333         return ret;
334 dec_unwind:
335         dec = atomic_long_sub_return(1, &iter->ucount[type]);
336         WARN_ON_ONCE(dec < 0);
337 unwind:
338         do_dec_rlimit_put_ucounts(ucounts, iter, type);
339         return 0;
340 }
341
342 bool is_ucounts_overlimit(struct ucounts *ucounts, enum ucount_type type, unsigned long max)
343 {
344         struct ucounts *iter;
345         if (get_ucounts_value(ucounts, type) > max)
346                 return true;
347         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
348                 max = READ_ONCE(iter->ns->ucount_max[type]);
349                 if (get_ucounts_value(iter, type) > max)
350                         return true;
351         }
352         return false;
353 }
354
355 static __init int user_namespace_sysctl_init(void)
356 {
357 #ifdef CONFIG_SYSCTL
358         static struct ctl_table_header *user_header;
359         static struct ctl_table empty[1];
360         /*
361          * It is necessary to register the user directory in the
362          * default set so that registrations in the child sets work
363          * properly.
364          */
365         user_header = register_sysctl("user", empty);
366         kmemleak_ignore(user_header);
367         BUG_ON(!user_header);
368         BUG_ON(!setup_userns_sysctls(&init_user_ns));
369 #endif
370         hlist_add_ucounts(&init_ucounts);
371         inc_rlimit_ucounts(&init_ucounts, UCOUNT_RLIMIT_NPROC, 1);
372         return 0;
373 }
374 subsys_initcall(user_namespace_sysctl_init);