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