sched: cleanup: rename task_grp to task_group
[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         .mq_bytes       = 0,
48         .locked_shm     = 0,
49 #ifdef CONFIG_KEYS
50         .uid_keyring    = &root_user_keyring,
51         .session_keyring = &root_session_keyring,
52 #endif
53 #ifdef CONFIG_FAIR_USER_SCHED
54         .tg             = &init_task_group,
55 #endif
56 };
57
58 #ifdef CONFIG_FAIR_USER_SCHED
59 static void sched_destroy_user(struct user_struct *up)
60 {
61         sched_destroy_group(up->tg);
62 }
63
64 static int sched_create_user(struct user_struct *up)
65 {
66         int rc = 0;
67
68         up->tg = sched_create_group();
69         if (IS_ERR(up->tg))
70                 rc = -ENOMEM;
71
72         return rc;
73 }
74
75 static void sched_switch_user(struct task_struct *p)
76 {
77         sched_move_task(p);
78 }
79
80 #else   /* CONFIG_FAIR_USER_SCHED */
81
82 static void sched_destroy_user(struct user_struct *up) { }
83 static int sched_create_user(struct user_struct *up) { return 0; }
84 static void sched_switch_user(struct task_struct *p) { }
85
86 #endif  /* CONFIG_FAIR_USER_SCHED */
87
88 /*
89  * These routines must be called with the uidhash spinlock held!
90  */
91 static inline void uid_hash_insert(struct user_struct *up, struct hlist_head *hashent)
92 {
93         hlist_add_head(&up->uidhash_node, hashent);
94 }
95
96 static inline void uid_hash_remove(struct user_struct *up)
97 {
98         hlist_del_init(&up->uidhash_node);
99 }
100
101 static inline struct user_struct *uid_hash_find(uid_t uid, struct hlist_head *hashent)
102 {
103         struct user_struct *user;
104         struct hlist_node *h;
105
106         hlist_for_each_entry(user, h, hashent, uidhash_node) {
107                 if(user->uid == uid) {
108                         atomic_inc(&user->__count);
109                         return user;
110                 }
111         }
112
113         return NULL;
114 }
115
116 /*
117  * Locate the user_struct for the passed UID.  If found, take a ref on it.  The
118  * caller must undo that ref with free_uid().
119  *
120  * If the user_struct could not be found, return NULL.
121  */
122 struct user_struct *find_user(uid_t uid)
123 {
124         struct user_struct *ret;
125         unsigned long flags;
126         struct user_namespace *ns = current->nsproxy->user_ns;
127
128         spin_lock_irqsave(&uidhash_lock, flags);
129         ret = uid_hash_find(uid, uidhashentry(ns, uid));
130         spin_unlock_irqrestore(&uidhash_lock, flags);
131         return ret;
132 }
133
134 void free_uid(struct user_struct *up)
135 {
136         unsigned long flags;
137
138         if (!up)
139                 return;
140
141         local_irq_save(flags);
142         if (atomic_dec_and_lock(&up->__count, &uidhash_lock)) {
143                 uid_hash_remove(up);
144                 spin_unlock_irqrestore(&uidhash_lock, flags);
145                 sched_destroy_user(up);
146                 key_put(up->uid_keyring);
147                 key_put(up->session_keyring);
148                 kmem_cache_free(uid_cachep, up);
149         } else {
150                 local_irq_restore(flags);
151         }
152 }
153
154 struct user_struct * alloc_uid(struct user_namespace *ns, uid_t uid)
155 {
156         struct hlist_head *hashent = uidhashentry(ns, uid);
157         struct user_struct *up;
158
159         spin_lock_irq(&uidhash_lock);
160         up = uid_hash_find(uid, hashent);
161         spin_unlock_irq(&uidhash_lock);
162
163         if (!up) {
164                 struct user_struct *new;
165
166                 new = kmem_cache_alloc(uid_cachep, GFP_KERNEL);
167                 if (!new)
168                         return NULL;
169                 new->uid = uid;
170                 atomic_set(&new->__count, 1);
171                 atomic_set(&new->processes, 0);
172                 atomic_set(&new->files, 0);
173                 atomic_set(&new->sigpending, 0);
174 #ifdef CONFIG_INOTIFY_USER
175                 atomic_set(&new->inotify_watches, 0);
176                 atomic_set(&new->inotify_devs, 0);
177 #endif
178
179                 new->mq_bytes = 0;
180                 new->locked_shm = 0;
181
182                 if (alloc_uid_keyring(new, current) < 0) {
183                         kmem_cache_free(uid_cachep, new);
184                         return NULL;
185                 }
186
187                 if (sched_create_user(new) < 0) {
188                         key_put(new->uid_keyring);
189                         key_put(new->session_keyring);
190                         kmem_cache_free(uid_cachep, new);
191                         return NULL;
192                 }
193
194                 /*
195                  * Before adding this, check whether we raced
196                  * on adding the same user already..
197                  */
198                 spin_lock_irq(&uidhash_lock);
199                 up = uid_hash_find(uid, hashent);
200                 if (up) {
201                         sched_destroy_user(new);
202                         key_put(new->uid_keyring);
203                         key_put(new->session_keyring);
204                         kmem_cache_free(uid_cachep, new);
205                 } else {
206                         uid_hash_insert(new, hashent);
207                         up = new;
208                 }
209                 spin_unlock_irq(&uidhash_lock);
210
211         }
212         return up;
213 }
214
215 void switch_uid(struct user_struct *new_user)
216 {
217         struct user_struct *old_user;
218
219         /* What if a process setreuid()'s and this brings the
220          * new uid over his NPROC rlimit?  We can check this now
221          * cheaply with the new uid cache, so if it matters
222          * we should be checking for it.  -DaveM
223          */
224         old_user = current->user;
225         atomic_inc(&new_user->processes);
226         atomic_dec(&old_user->processes);
227         switch_uid_keyring(new_user);
228         current->user = new_user;
229         sched_switch_user(current);
230
231         /*
232          * We need to synchronize with __sigqueue_alloc()
233          * doing a get_uid(p->user).. If that saw the old
234          * user value, we need to wait until it has exited
235          * its critical region before we can free the old
236          * structure.
237          */
238         smp_mb();
239         spin_unlock_wait(&current->sighand->siglock);
240
241         free_uid(old_user);
242         suid_keys(current);
243 }
244
245 void release_uids(struct user_namespace *ns)
246 {
247         int i;
248         unsigned long flags;
249         struct hlist_head *head;
250         struct hlist_node *nd;
251
252         spin_lock_irqsave(&uidhash_lock, flags);
253         /*
254          * collapse the chains so that the user_struct-s will
255          * be still alive, but not in hashes. subsequent free_uid()
256          * will free them.
257          */
258         for (i = 0; i < UIDHASH_SZ; i++) {
259                 head = ns->uidhash_table + i;
260                 while (!hlist_empty(head)) {
261                         nd = head->first;
262                         hlist_del_init(nd);
263                 }
264         }
265         spin_unlock_irqrestore(&uidhash_lock, flags);
266
267         free_uid(ns->root_user);
268 }
269
270 static int __init uid_cache_init(void)
271 {
272         int n;
273
274         uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
275                         0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
276
277         for(n = 0; n < UIDHASH_SZ; ++n)
278                 INIT_HLIST_HEAD(init_user_ns.uidhash_table + n);
279
280         /* Insert the root user immediately (init already runs as root) */
281         spin_lock_irq(&uidhash_lock);
282         uid_hash_insert(&root_user, uidhashentry(&init_user_ns, 0));
283         spin_unlock_irq(&uidhash_lock);
284
285         return 0;
286 }
287
288 module_init(uid_cache_init);