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>
17 * UID task count cache, to get fast user lookup in "alloc_uid"
18 * when changing user ID's (ie setuid() and friends).
20 #define UIDHASH_BITS 8
21 #define UIDHASH_SZ (1 << UIDHASH_BITS)
22 #define UIDHASH_MASK (UIDHASH_SZ - 1)
23 #define __uidhashfn(uid) (((uid >> UIDHASH_BITS) + uid) & UIDHASH_MASK)
24 #define uidhashentry(uid) (uidhash_table + __uidhashfn((uid)))
26 static kmem_cache_t
*uid_cachep
;
27 static struct list_head uidhash_table
[UIDHASH_SZ
];
28 static spinlock_t uidhash_lock
= SPIN_LOCK_UNLOCKED
;
30 struct user_struct root_user
= {
31 .__count
= ATOMIC_INIT(1),
32 .processes
= ATOMIC_INIT(1),
33 .files
= ATOMIC_INIT(0)
37 * These routines must be called with the uidhash spinlock held!
39 static inline void uid_hash_insert(struct user_struct
*up
, struct list_head
*hashent
)
41 list_add(&up
->uidhash_list
, hashent
);
44 static inline void uid_hash_remove(struct user_struct
*up
)
46 list_del(&up
->uidhash_list
);
49 static inline struct user_struct
*uid_hash_find(uid_t uid
, struct list_head
*hashent
)
53 list_for_each(up
, hashent
) {
54 struct user_struct
*user
;
56 user
= list_entry(up
, struct user_struct
, uidhash_list
);
58 if(user
->uid
== uid
) {
59 atomic_inc(&user
->__count
);
67 struct user_struct
*find_user(uid_t uid
)
69 return uid_hash_find(uid
, uidhashentry(uid
));
72 void free_uid(struct user_struct
*up
)
74 if (up
&& atomic_dec_and_lock(&up
->__count
, &uidhash_lock
)) {
76 kmem_cache_free(uid_cachep
, up
);
77 spin_unlock(&uidhash_lock
);
81 struct user_struct
* alloc_uid(uid_t uid
)
83 struct list_head
*hashent
= uidhashentry(uid
);
84 struct user_struct
*up
;
86 spin_lock(&uidhash_lock
);
87 up
= uid_hash_find(uid
, hashent
);
88 spin_unlock(&uidhash_lock
);
91 struct user_struct
*new;
93 new = kmem_cache_alloc(uid_cachep
, SLAB_KERNEL
);
97 atomic_set(&new->__count
, 1);
98 atomic_set(&new->processes
, 0);
99 atomic_set(&new->files
, 0);
102 * Before adding this, check whether we raced
103 * on adding the same user already..
105 spin_lock(&uidhash_lock
);
106 up
= uid_hash_find(uid
, hashent
);
108 kmem_cache_free(uid_cachep
, new);
110 uid_hash_insert(new, hashent
);
113 spin_unlock(&uidhash_lock
);
119 void switch_uid(struct user_struct
*new_user
)
121 struct user_struct
*old_user
;
123 /* What if a process setreuid()'s and this brings the
124 * new uid over his NPROC rlimit? We can check this now
125 * cheaply with the new uid cache, so if it matters
126 * we should be checking for it. -DaveM
128 old_user
= current
->user
;
129 atomic_inc(&new_user
->processes
);
130 atomic_dec(&old_user
->processes
);
131 current
->user
= new_user
;
136 static int __init
uid_cache_init(void)
140 uid_cachep
= kmem_cache_create("uid_cache", sizeof(struct user_struct
),
142 SLAB_HWCACHE_ALIGN
, NULL
, NULL
);
144 panic("Cannot create uid taskcount SLAB cache\n");
146 for(n
= 0; n
< UIDHASH_SZ
; ++n
)
147 INIT_LIST_HEAD(uidhash_table
+ n
);
149 /* Insert the root user immediately - init already runs with this */
150 uid_hash_insert(&root_user
, uidhashentry(0));
154 module_init(uid_cache_init
);