Merge tag 'char-misc-5.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregk...
[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 #define UCOUNT_ENTRY(name)                              \
62         {                                               \
63                 .procname       = name,                 \
64                 .maxlen         = sizeof(int),          \
65                 .mode           = 0644,                 \
66                 .proc_handler   = proc_dointvec_minmax, \
67                 .extra1         = SYSCTL_ZERO,          \
68                 .extra2         = SYSCTL_INT_MAX,       \
69         }
70 static struct ctl_table user_table[] = {
71         UCOUNT_ENTRY("max_user_namespaces"),
72         UCOUNT_ENTRY("max_pid_namespaces"),
73         UCOUNT_ENTRY("max_uts_namespaces"),
74         UCOUNT_ENTRY("max_ipc_namespaces"),
75         UCOUNT_ENTRY("max_net_namespaces"),
76         UCOUNT_ENTRY("max_mnt_namespaces"),
77         UCOUNT_ENTRY("max_cgroup_namespaces"),
78         UCOUNT_ENTRY("max_time_namespaces"),
79 #ifdef CONFIG_INOTIFY_USER
80         UCOUNT_ENTRY("max_inotify_instances"),
81         UCOUNT_ENTRY("max_inotify_watches"),
82 #endif
83 #ifdef CONFIG_FANOTIFY
84         UCOUNT_ENTRY("max_fanotify_groups"),
85         UCOUNT_ENTRY("max_fanotify_marks"),
86 #endif
87         { },
88         { },
89         { },
90         { },
91         { }
92 };
93 #endif /* CONFIG_SYSCTL */
94
95 bool setup_userns_sysctls(struct user_namespace *ns)
96 {
97 #ifdef CONFIG_SYSCTL
98         struct ctl_table *tbl;
99
100         BUILD_BUG_ON(ARRAY_SIZE(user_table) != UCOUNT_COUNTS + 1);
101         setup_sysctl_set(&ns->set, &set_root, set_is_seen);
102         tbl = kmemdup(user_table, sizeof(user_table), GFP_KERNEL);
103         if (tbl) {
104                 int i;
105                 for (i = 0; i < UCOUNT_COUNTS; i++) {
106                         tbl[i].data = &ns->ucount_max[i];
107                 }
108                 ns->sysctls = __register_sysctl_table(&ns->set, "user", tbl);
109         }
110         if (!ns->sysctls) {
111                 kfree(tbl);
112                 retire_sysctl_set(&ns->set);
113                 return false;
114         }
115 #endif
116         return true;
117 }
118
119 void retire_userns_sysctls(struct user_namespace *ns)
120 {
121 #ifdef CONFIG_SYSCTL
122         struct ctl_table *tbl;
123
124         tbl = ns->sysctls->ctl_table_arg;
125         unregister_sysctl_table(ns->sysctls);
126         retire_sysctl_set(&ns->set);
127         kfree(tbl);
128 #endif
129 }
130
131 static struct ucounts *find_ucounts(struct user_namespace *ns, kuid_t uid, struct hlist_head *hashent)
132 {
133         struct ucounts *ucounts;
134
135         hlist_for_each_entry(ucounts, hashent, node) {
136                 if (uid_eq(ucounts->uid, uid) && (ucounts->ns == ns))
137                         return ucounts;
138         }
139         return NULL;
140 }
141
142 static void hlist_add_ucounts(struct ucounts *ucounts)
143 {
144         struct hlist_head *hashent = ucounts_hashentry(ucounts->ns, ucounts->uid);
145         spin_lock_irq(&ucounts_lock);
146         hlist_add_head(&ucounts->node, hashent);
147         spin_unlock_irq(&ucounts_lock);
148 }
149
150 struct ucounts *get_ucounts(struct ucounts *ucounts)
151 {
152         if (ucounts && atomic_add_negative(1, &ucounts->count)) {
153                 put_ucounts(ucounts);
154                 ucounts = NULL;
155         }
156         return ucounts;
157 }
158
159 struct ucounts *alloc_ucounts(struct user_namespace *ns, kuid_t uid)
160 {
161         struct hlist_head *hashent = ucounts_hashentry(ns, uid);
162         struct ucounts *ucounts, *new;
163
164         spin_lock_irq(&ucounts_lock);
165         ucounts = find_ucounts(ns, uid, hashent);
166         if (!ucounts) {
167                 spin_unlock_irq(&ucounts_lock);
168
169                 new = kzalloc(sizeof(*new), GFP_KERNEL);
170                 if (!new)
171                         return NULL;
172
173                 new->ns = ns;
174                 new->uid = uid;
175                 atomic_set(&new->count, 1);
176
177                 spin_lock_irq(&ucounts_lock);
178                 ucounts = find_ucounts(ns, uid, hashent);
179                 if (ucounts) {
180                         kfree(new);
181                 } else {
182                         hlist_add_head(&new->node, hashent);
183                         spin_unlock_irq(&ucounts_lock);
184                         return new;
185                 }
186         }
187         spin_unlock_irq(&ucounts_lock);
188         ucounts = get_ucounts(ucounts);
189         return ucounts;
190 }
191
192 void put_ucounts(struct ucounts *ucounts)
193 {
194         unsigned long flags;
195
196         if (atomic_dec_and_test(&ucounts->count)) {
197                 spin_lock_irqsave(&ucounts_lock, flags);
198                 hlist_del_init(&ucounts->node);
199                 spin_unlock_irqrestore(&ucounts_lock, flags);
200                 kfree(ucounts);
201         }
202 }
203
204 static inline bool atomic_long_inc_below(atomic_long_t *v, int u)
205 {
206         long c, old;
207         c = atomic_long_read(v);
208         for (;;) {
209                 if (unlikely(c >= u))
210                         return false;
211                 old = atomic_long_cmpxchg(v, c, c+1);
212                 if (likely(old == c))
213                         return true;
214                 c = old;
215         }
216 }
217
218 struct ucounts *inc_ucount(struct user_namespace *ns, kuid_t uid,
219                            enum ucount_type type)
220 {
221         struct ucounts *ucounts, *iter, *bad;
222         struct user_namespace *tns;
223         ucounts = alloc_ucounts(ns, uid);
224         for (iter = ucounts; iter; iter = tns->ucounts) {
225                 long max;
226                 tns = iter->ns;
227                 max = READ_ONCE(tns->ucount_max[type]);
228                 if (!atomic_long_inc_below(&iter->ucount[type], max))
229                         goto fail;
230         }
231         return ucounts;
232 fail:
233         bad = iter;
234         for (iter = ucounts; iter != bad; iter = iter->ns->ucounts)
235                 atomic_long_dec(&iter->ucount[type]);
236
237         put_ucounts(ucounts);
238         return NULL;
239 }
240
241 void dec_ucount(struct ucounts *ucounts, enum ucount_type type)
242 {
243         struct ucounts *iter;
244         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
245                 long dec = atomic_long_dec_if_positive(&iter->ucount[type]);
246                 WARN_ON_ONCE(dec < 0);
247         }
248         put_ucounts(ucounts);
249 }
250
251 long inc_rlimit_ucounts(struct ucounts *ucounts, enum ucount_type type, long v)
252 {
253         struct ucounts *iter;
254         long ret = 0;
255
256         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
257                 long max = READ_ONCE(iter->ns->ucount_max[type]);
258                 long new = atomic_long_add_return(v, &iter->ucount[type]);
259                 if (new < 0 || new > max)
260                         ret = LONG_MAX;
261                 else if (iter == ucounts)
262                         ret = new;
263         }
264         return ret;
265 }
266
267 bool dec_rlimit_ucounts(struct ucounts *ucounts, enum ucount_type type, long v)
268 {
269         struct ucounts *iter;
270         long new = -1; /* Silence compiler warning */
271         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
272                 long dec = atomic_long_add_return(-v, &iter->ucount[type]);
273                 WARN_ON_ONCE(dec < 0);
274                 if (iter == ucounts)
275                         new = dec;
276         }
277         return (new == 0);
278 }
279
280 bool is_ucounts_overlimit(struct ucounts *ucounts, enum ucount_type type, unsigned long max)
281 {
282         struct ucounts *iter;
283         if (get_ucounts_value(ucounts, type) > max)
284                 return true;
285         for (iter = ucounts; iter; iter = iter->ns->ucounts) {
286                 max = READ_ONCE(iter->ns->ucount_max[type]);
287                 if (get_ucounts_value(iter, type) > max)
288                         return true;
289         }
290         return false;
291 }
292
293 static __init int user_namespace_sysctl_init(void)
294 {
295 #ifdef CONFIG_SYSCTL
296         static struct ctl_table_header *user_header;
297         static struct ctl_table empty[1];
298         /*
299          * It is necessary to register the user directory in the
300          * default set so that registrations in the child sets work
301          * properly.
302          */
303         user_header = register_sysctl("user", empty);
304         kmemleak_ignore(user_header);
305         BUG_ON(!user_header);
306         BUG_ON(!setup_userns_sysctls(&init_user_ns));
307 #endif
308         hlist_add_ucounts(&init_ucounts);
309         inc_rlimit_ucounts(&init_ucounts, UCOUNT_RLIMIT_NPROC, 1);
310         return 0;
311 }
312 subsys_initcall(user_namespace_sysctl_init);