4 * (C) Copyright 1991-2000 Linus Torvalds
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.
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>
18 * UID task count cache, to get fast user lookup in "alloc_uid"
19 * when changing user ID's (ie setuid() and friends).
21 #define UIDHASH_BITS 8
22 #define UIDHASH_SZ (1 << UIDHASH_BITS)
23 #define UIDHASH_MASK (UIDHASH_SZ - 1)
24 #define __uidhashfn(uid) (((uid >> UIDHASH_BITS) + uid) & UIDHASH_MASK)
25 #define uidhashentry(uid) (uidhash_table + __uidhashfn((uid)))
27 static kmem_cache_t
*uid_cachep
;
28 static struct list_head uidhash_table
[UIDHASH_SZ
];
29 static spinlock_t uidhash_lock
= SPIN_LOCK_UNLOCKED
;
31 struct user_struct root_user
= {
32 .__count
= ATOMIC_INIT(1),
33 .processes
= ATOMIC_INIT(1),
34 .files
= ATOMIC_INIT(0),
35 .sigpending
= ATOMIC_INIT(0),
39 .uid_keyring
= &root_user_keyring
,
40 .session_keyring
= &root_session_keyring
,
45 * These routines must be called with the uidhash spinlock held!
47 static inline void uid_hash_insert(struct user_struct
*up
, struct list_head
*hashent
)
49 list_add(&up
->uidhash_list
, hashent
);
52 static inline void uid_hash_remove(struct user_struct
*up
)
54 list_del(&up
->uidhash_list
);
57 static inline struct user_struct
*uid_hash_find(uid_t uid
, struct list_head
*hashent
)
61 list_for_each(up
, hashent
) {
62 struct user_struct
*user
;
64 user
= list_entry(up
, struct user_struct
, uidhash_list
);
66 if(user
->uid
== uid
) {
67 atomic_inc(&user
->__count
);
76 * Locate the user_struct for the passed UID. If found, take a ref on it. The
77 * caller must undo that ref with free_uid().
79 * If the user_struct could not be found, return NULL.
81 struct user_struct
*find_user(uid_t uid
)
83 struct user_struct
*ret
;
85 spin_lock(&uidhash_lock
);
86 ret
= uid_hash_find(uid
, uidhashentry(uid
));
87 spin_unlock(&uidhash_lock
);
91 void free_uid(struct user_struct
*up
)
93 if (up
&& atomic_dec_and_lock(&up
->__count
, &uidhash_lock
)) {
95 key_put(up
->uid_keyring
);
96 key_put(up
->session_keyring
);
97 kmem_cache_free(uid_cachep
, up
);
98 spin_unlock(&uidhash_lock
);
102 struct user_struct
* alloc_uid(uid_t uid
)
104 struct list_head
*hashent
= uidhashentry(uid
);
105 struct user_struct
*up
;
107 spin_lock(&uidhash_lock
);
108 up
= uid_hash_find(uid
, hashent
);
109 spin_unlock(&uidhash_lock
);
112 struct user_struct
*new;
114 new = kmem_cache_alloc(uid_cachep
, SLAB_KERNEL
);
118 atomic_set(&new->__count
, 1);
119 atomic_set(&new->processes
, 0);
120 atomic_set(&new->files
, 0);
121 atomic_set(&new->sigpending
, 0);
126 if (alloc_uid_keyring(new) < 0) {
127 kmem_cache_free(uid_cachep
, new);
132 * Before adding this, check whether we raced
133 * on adding the same user already..
135 spin_lock(&uidhash_lock
);
136 up
= uid_hash_find(uid
, hashent
);
138 key_put(new->uid_keyring
);
139 key_put(new->session_keyring
);
140 kmem_cache_free(uid_cachep
, new);
142 uid_hash_insert(new, hashent
);
145 spin_unlock(&uidhash_lock
);
151 void switch_uid(struct user_struct
*new_user
)
153 struct user_struct
*old_user
;
155 /* What if a process setreuid()'s and this brings the
156 * new uid over his NPROC rlimit? We can check this now
157 * cheaply with the new uid cache, so if it matters
158 * we should be checking for it. -DaveM
160 old_user
= current
->user
;
161 atomic_inc(&new_user
->processes
);
162 atomic_dec(&old_user
->processes
);
163 switch_uid_keyring(new_user
);
164 current
->user
= new_user
;
170 static int __init
uid_cache_init(void)
174 uid_cachep
= kmem_cache_create("uid_cache", sizeof(struct user_struct
),
175 0, SLAB_HWCACHE_ALIGN
|SLAB_PANIC
, NULL
, NULL
);
177 for(n
= 0; n
< UIDHASH_SZ
; ++n
)
178 INIT_LIST_HEAD(uidhash_table
+ n
);
180 /* Insert the root user immediately (init already runs as root) */
181 spin_lock(&uidhash_lock
);
182 uid_hash_insert(&root_user
, uidhashentry(0));
183 spin_unlock(&uidhash_lock
);
188 module_init(uid_cache_init
);