projects/linux·blob 61844250 · refs

547 lines · 13.0 KiB

1/*
2 * The "user cache".
3 *
4 * (C) Copyright 1991-2000 Linus Torvalds
5 *
6 * We have a per-user structure to keep track of how many
7 * processes, files etc the user has claimed, in order to be
8 * able to have per-user limits for system resources.
9 */
10
11#include <linux/init.h>
12#include <linux/sched.h>
13#include <linux/slab.h>
14#include <linux/bitops.h>
15#include <linux/key.h>
16#include <linux/interrupt.h>
17#include <linux/module.h>
18#include <linux/user_namespace.h>
19
20struct user_namespace init_user_ns = {
21 .kref = {
22 .refcount = ATOMIC_INIT(2),
23 },
24 .root_user = &root_user,
25};
26EXPORT_SYMBOL_GPL(init_user_ns);
27
28/*
29 * UID task count cache, to get fast user lookup in "alloc_uid"
30 * when changing user ID's (ie setuid() and friends).
31 */
32
33#define UIDHASH_MASK (UIDHASH_SZ - 1)
34#define __uidhashfn(uid) (((uid >> UIDHASH_BITS) + uid) & UIDHASH_MASK)
35#define uidhashentry(ns, uid) ((ns)->uidhash_table + __uidhashfn((uid)))
36
37static struct kmem_cache *uid_cachep;
38
39/*
40 * The uidhash_lock is mostly taken from process context, but it is
41 * occasionally also taken from softirq/tasklet context, when
42 * task-structs get RCU-freed. Hence all locking must be softirq-safe.
43 * But free_uid() is also called with local interrupts disabled, and running
44 * local_bh_enable() with local interrupts disabled is an error - we'll run
45 * softirq callbacks, and they can unconditionally enable interrupts, and
46 * the caller of free_uid() didn't expect that..
47 */
48static DEFINE_SPINLOCK(uidhash_lock);
49
50struct user_struct root_user = {
51 .__count = ATOMIC_INIT(1),
52 .processes = ATOMIC_INIT(1),
53 .files = ATOMIC_INIT(0),
54 .sigpending = ATOMIC_INIT(0),
55 .locked_shm = 0,
56#ifdef CONFIG_KEYS
57 .uid_keyring = &root_user_keyring,
58 .session_keyring = &root_session_keyring,
59#endif
60#ifdef CONFIG_USER_SCHED
61 .tg = &init_task_group,
62#endif
63};
64
65/*
66 * These routines must be called with the uidhash spinlock held!
67 */
68static void uid_hash_insert(struct user_struct *up, struct hlist_head *hashent)
69{
70 hlist_add_head(&up->uidhash_node, hashent);
71}
72
73static void uid_hash_remove(struct user_struct *up)
74{
75 hlist_del_init(&up->uidhash_node);
76}
77
78static struct user_struct *uid_hash_find(uid_t uid, struct hlist_head *hashent)
79{
80 struct user_struct *user;
81 struct hlist_node *h;
82
83 hlist_for_each_entry(user, h, hashent, uidhash_node) {
84 if (user->uid == uid) {
85 atomic_inc(&user->__count);
86 return user;
87 }
88 }
89
90 return NULL;
91}
92
93#ifdef CONFIG_USER_SCHED
94
95static void sched_destroy_user(struct user_struct *up)
96{
97 sched_destroy_group(up->tg);
98}
99
100static int sched_create_user(struct user_struct *up)
101{
102 int rc = 0;
103
104 up->tg = sched_create_group(&root_task_group);
105 if (IS_ERR(up->tg))
106 rc = -ENOMEM;
107
108 return rc;
109}
110
111static void sched_switch_user(struct task_struct *p)
112{
113 sched_move_task(p);
114}
115
116#else /* CONFIG_USER_SCHED */
117
118static void sched_destroy_user(struct user_struct *up) { }
119static int sched_create_user(struct user_struct *up) { return 0; }
120static void sched_switch_user(struct task_struct *p) { }
121
122#endif /* CONFIG_USER_SCHED */
123
124#if defined(CONFIG_USER_SCHED) && defined(CONFIG_SYSFS)
125
126static struct kset *uids_kset; /* represents the /sys/kernel/uids/ directory */
127static DEFINE_MUTEX(uids_mutex);
128
129static inline void uids_mutex_lock(void)
130{
131 mutex_lock(&uids_mutex);
132}
133
134static inline void uids_mutex_unlock(void)
135{
136 mutex_unlock(&uids_mutex);
137}
138
139/* uid directory attributes */
140#ifdef CONFIG_FAIR_GROUP_SCHED
141static ssize_t cpu_shares_show(struct kobject *kobj,
142 struct kobj_attribute *attr,
143 char *buf)
144{
145 struct user_struct *up = container_of(kobj, struct user_struct, kobj);
146
147 return sprintf(buf, "%lu\n", sched_group_shares(up->tg));
148}
149
150static ssize_t cpu_shares_store(struct kobject *kobj,
151 struct kobj_attribute *attr,
152 const char *buf, size_t size)
153{
154 struct user_struct *up = container_of(kobj, struct user_struct, kobj);
155 unsigned long shares;
156 int rc;
157
158 sscanf(buf, "%lu", &shares);
159
160 rc = sched_group_set_shares(up->tg, shares);
161
162 return (rc ? rc : size);
163}
164
165static struct kobj_attribute cpu_share_attr =
166 __ATTR(cpu_share, 0644, cpu_shares_show, cpu_shares_store);
167#endif
168
169#ifdef CONFIG_RT_GROUP_SCHED
170static ssize_t cpu_rt_runtime_show(struct kobject *kobj,
171 struct kobj_attribute *attr,
172 char *buf)
173{
174 struct user_struct *up = container_of(kobj, struct user_struct, kobj);
175
176 return sprintf(buf, "%lu\n", sched_group_rt_runtime(up->tg));
177}
178
179static ssize_t cpu_rt_runtime_store(struct kobject *kobj,
180 struct kobj_attribute *attr,
181 const char *buf, size_t size)
182{
183 struct user_struct *up = container_of(kobj, struct user_struct, kobj);
184 unsigned long rt_runtime;
185 int rc;
186
187 sscanf(buf, "%lu", &rt_runtime);
188
189 rc = sched_group_set_rt_runtime(up->tg, rt_runtime);
190
191 return (rc ? rc : size);
192}
193
194static struct kobj_attribute cpu_rt_runtime_attr =
195 __ATTR(cpu_rt_runtime, 0644, cpu_rt_runtime_show, cpu_rt_runtime_store);
196
197static ssize_t cpu_rt_period_show(struct kobject *kobj,
198 struct kobj_attribute *attr,
199 char *buf)
200{
201 struct user_struct *up = container_of(kobj, struct user_struct, kobj);
202
203 return sprintf(buf, "%lu\n", sched_group_rt_period(up->tg));
204}
205
206static ssize_t cpu_rt_period_store(struct kobject *kobj,
207 struct kobj_attribute *attr,
208 const char *buf, size_t size)
209{
210 struct user_struct *up = container_of(kobj, struct user_struct, kobj);
211 unsigned long rt_period;
212 int rc;
213
214 sscanf(buf, "%lu", &rt_period);
215
216 rc = sched_group_set_rt_period(up->tg, rt_period);
217
218 return (rc ? rc : size);
219}
220
221static struct kobj_attribute cpu_rt_period_attr =
222 __ATTR(cpu_rt_period, 0644, cpu_rt_period_show, cpu_rt_period_store);
223#endif
224
225/* default attributes per uid directory */
226static struct attribute *uids_attributes[] = {
227#ifdef CONFIG_FAIR_GROUP_SCHED
228 &cpu_share_attr.attr,
229#endif
230#ifdef CONFIG_RT_GROUP_SCHED
231 &cpu_rt_runtime_attr.attr,
232 &cpu_rt_period_attr.attr,
233#endif
234 NULL
235};
236
237/* the lifetime of user_struct is not managed by the core (now) */
238static void uids_release(struct kobject *kobj)
239{
240 return;
241}
242
243static struct kobj_type uids_ktype = {
244 .sysfs_ops = &kobj_sysfs_ops,
245 .default_attrs = uids_attributes,
246 .release = uids_release,
247};
248
249/* create /sys/kernel/uids/<uid>/cpu_share file for this user */
250static int uids_user_create(struct user_struct *up)
251{
252 struct kobject *kobj = &up->kobj;
253 int error;
254
255 memset(kobj, 0, sizeof(struct kobject));
256 kobj->kset = uids_kset;
257 error = kobject_init_and_add(kobj, &uids_ktype, NULL, "%d", up->uid);
258 if (error) {
259 kobject_put(kobj);
260 goto done;
261 }
262
263 kobject_uevent(kobj, KOBJ_ADD);
264done:
265 return error;
266}
267
268/* create these entries in sysfs:
269 * "/sys/kernel/uids" directory
270 * "/sys/kernel/uids/0" directory (for root user)
271 * "/sys/kernel/uids/0/cpu_share" file (for root user)
272 */
273int __init uids_sysfs_init(void)
274{
275 uids_kset = kset_create_and_add("uids", NULL, kernel_kobj);
276 if (!uids_kset)
277 return -ENOMEM;
278
279 return uids_user_create(&root_user);
280}
281
282/* work function to remove sysfs directory for a user and free up
283 * corresponding structures.
284 */
285static void remove_user_sysfs_dir(struct work_struct *w)
286{
287 struct user_struct *up = container_of(w, struct user_struct, work);
288 unsigned long flags;
289 int remove_user = 0;
290
291 /* Make uid_hash_remove() + sysfs_remove_file() + kobject_del()
292 * atomic.
293 */
294 uids_mutex_lock();
295
296 local_irq_save(flags);
297
298 if (atomic_dec_and_lock(&up->__count, &uidhash_lock)) {
299 uid_hash_remove(up);
300 remove_user = 1;
301 spin_unlock_irqrestore(&uidhash_lock, flags);
302 } else {
303 local_irq_restore(flags);
304 }
305
306 if (!remove_user)
307 goto done;
308
309 kobject_uevent(&up->kobj, KOBJ_REMOVE);
310 kobject_del(&up->kobj);
311 kobject_put(&up->kobj);
312
313 sched_destroy_user(up);
314 key_put(up->uid_keyring);
315 key_put(up->session_keyring);
316 kmem_cache_free(uid_cachep, up);
317
318done:
319 uids_mutex_unlock();
320}
321
322/* IRQs are disabled and uidhash_lock is held upon function entry.
323 * IRQ state (as stored in flags) is restored and uidhash_lock released
324 * upon function exit.
325 */
326static inline void free_user(struct user_struct *up, unsigned long flags)
327{
328 /* restore back the count */
329 atomic_inc(&up->__count);
330 spin_unlock_irqrestore(&uidhash_lock, flags);
331
332 INIT_WORK(&up->work, remove_user_sysfs_dir);
333 schedule_work(&up->work);
334}
335
336#else /* CONFIG_USER_SCHED && CONFIG_SYSFS */
337
338int uids_sysfs_init(void) { return 0; }
339static inline int uids_user_create(struct user_struct *up) { return 0; }
340static inline void uids_mutex_lock(void) { }
341static inline void uids_mutex_unlock(void) { }
342
343/* IRQs are disabled and uidhash_lock is held upon function entry.
344 * IRQ state (as stored in flags) is restored and uidhash_lock released
345 * upon function exit.
346 */
347static inline void free_user(struct user_struct *up, unsigned long flags)
348{
349 uid_hash_remove(up);
350 spin_unlock_irqrestore(&uidhash_lock, flags);
351 sched_destroy_user(up);
352 key_put(up->uid_keyring);
353 key_put(up->session_keyring);
354 kmem_cache_free(uid_cachep, up);
355}
356
357#endif
358
359/*
360 * Locate the user_struct for the passed UID. If found, take a ref on it. The
361 * caller must undo that ref with free_uid().
362 *
363 * If the user_struct could not be found, return NULL.
364 */
365struct user_struct *find_user(uid_t uid)
366{
367 struct user_struct *ret;
368 unsigned long flags;
369 struct user_namespace *ns = current->nsproxy->user_ns;
370
371 spin_lock_irqsave(&uidhash_lock, flags);
372 ret = uid_hash_find(uid, uidhashentry(ns, uid));
373 spin_unlock_irqrestore(&uidhash_lock, flags);
374 return ret;
375}
376
377void free_uid(struct user_struct *up)
378{
379 unsigned long flags;
380
381 if (!up)
382 return;
383
384 local_irq_save(flags);
385 if (atomic_dec_and_lock(&up->__count, &uidhash_lock))
386 free_user(up, flags);
387 else
388 local_irq_restore(flags);
389}
390
391struct user_struct * alloc_uid(struct user_namespace *ns, uid_t uid)
392{
393 struct hlist_head *hashent = uidhashentry(ns, uid);
394 struct user_struct *up, *new;
395
396 /* Make uid_hash_find() + uids_user_create() + uid_hash_insert()
397 * atomic.
398 */
399 uids_mutex_lock();
400
401 spin_lock_irq(&uidhash_lock);
402 up = uid_hash_find(uid, hashent);
403 spin_unlock_irq(&uidhash_lock);
404
405 if (!up) {
406 new = kmem_cache_alloc(uid_cachep, GFP_KERNEL);
407 if (!new)
408 goto out_unlock;
409
410 new->uid = uid;
411 atomic_set(&new->__count, 1);
412 atomic_set(&new->processes, 0);
413 atomic_set(&new->files, 0);
414 atomic_set(&new->sigpending, 0);
415#ifdef CONFIG_INOTIFY_USER
416 atomic_set(&new->inotify_watches, 0);
417 atomic_set(&new->inotify_devs, 0);
418#endif
419#ifdef CONFIG_POSIX_MQUEUE
420 new->mq_bytes = 0;
421#endif
422 new->locked_shm = 0;
423
424 if (alloc_uid_keyring(new, current) < 0)
425 goto out_free_user;
426
427 if (sched_create_user(new) < 0)
428 goto out_put_keys;
429
430 if (uids_user_create(new))
431 goto out_destoy_sched;
432
433 /*
434 * Before adding this, check whether we raced
435 * on adding the same user already..
436 */
437 spin_lock_irq(&uidhash_lock);
438 up = uid_hash_find(uid, hashent);
439 if (up) {
440 /* This case is not possible when CONFIG_USER_SCHED
441 * is defined, since we serialize alloc_uid() using
442 * uids_mutex. Hence no need to call
443 * sched_destroy_user() or remove_user_sysfs_dir().
444 */
445 key_put(new->uid_keyring);
446 key_put(new->session_keyring);
447 kmem_cache_free(uid_cachep, new);
448 } else {
449 uid_hash_insert(new, hashent);
450 up = new;
451 }
452 spin_unlock_irq(&uidhash_lock);
453
454 }
455
456 uids_mutex_unlock();
457
458 return up;
459
460out_destoy_sched:
461 sched_destroy_user(new);
462out_put_keys:
463 key_put(new->uid_keyring);
464 key_put(new->session_keyring);
465out_free_user:
466 kmem_cache_free(uid_cachep, new);
467out_unlock:
468 uids_mutex_unlock();
469 return NULL;
470}
471
472void switch_uid(struct user_struct *new_user)
473{
474 struct user_struct *old_user;
475
476 /* What if a process setreuid()'s and this brings the
477 * new uid over his NPROC rlimit? We can check this now
478 * cheaply with the new uid cache, so if it matters
479 * we should be checking for it. -DaveM
480 */
481 old_user = current->user;
482 atomic_inc(&new_user->processes);
483 atomic_dec(&old_user->processes);
484 switch_uid_keyring(new_user);
485 current->user = new_user;
486 sched_switch_user(current);
487
488 /*
489 * We need to synchronize with __sigqueue_alloc()
490 * doing a get_uid(p->user).. If that saw the old
491 * user value, we need to wait until it has exited
492 * its critical region before we can free the old
493 * structure.
494 */
495 smp_mb();
496 spin_unlock_wait(&current->sighand->siglock);
497
498 free_uid(old_user);
499 suid_keys(current);
500}
501
502#ifdef CONFIG_USER_NS
503void release_uids(struct user_namespace *ns)
504{
505 int i;
506 unsigned long flags;
507 struct hlist_head *head;
508 struct hlist_node *nd;
509
510 spin_lock_irqsave(&uidhash_lock, flags);
511 /*
512 * collapse the chains so that the user_struct-s will
513 * be still alive, but not in hashes. subsequent free_uid()
514 * will free them.
515 */
516 for (i = 0; i < UIDHASH_SZ; i++) {
517 head = ns->uidhash_table + i;
518 while (!hlist_empty(head)) {
519 nd = head->first;
520 hlist_del_init(nd);
521 }
522 }
523 spin_unlock_irqrestore(&uidhash_lock, flags);
524
525 free_uid(ns->root_user);
526}
527#endif
528
529static int __init uid_cache_init(void)
530{
531 int n;
532
533 uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
534 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
535
536 for(n = 0; n < UIDHASH_SZ; ++n)
537 INIT_HLIST_HEAD(init_user_ns.uidhash_table + n);
538
539 /* Insert the root user immediately (init already runs as root) */
540 spin_lock_irq(&uidhash_lock);
541 uid_hash_insert(&root_user, uidhashentry(&init_user_ns, 0));
542 spin_unlock_irq(&uidhash_lock);
543
544 return 0;
545}
546
547module_init(uid_cache_init);