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
  16 /*
  17  * UID task count cache, to get fast user lookup in "alloc_uid"
  18  * when changing user ID's (ie setuid() and friends).
  19  */
  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)))
  25
  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;
  29
  30 struct user_struct root_user = {
  31         .__count        = ATOMIC_INIT(1),
  32         .processes      = ATOMIC_INIT(1),
  33         .files          = ATOMIC_INIT(0),
  34         .sigpending     = ATOMIC_INIT(0),
  35         .mq_bytes       = 0,
  36         .locked_shm     = 0,
  37 };
  38
  39 /*
  40  * These routines must be called with the uidhash spinlock held!
  41  */
  42 static inline void uid_hash_insert(struct user_struct *up, struct list_head *hashent)
  43 {
  44         list_add(&up->uidhash_list, hashent);
  45 }
  46
  47 static inline void uid_hash_remove(struct user_struct *up)
  48 {
  49         list_del(&up->uidhash_list);
  50 }
  51
  52 static inline struct user_struct *uid_hash_find(uid_t uid, struct list_head *hashent)
  53 {
  54         struct list_head *up;
  55
  56         list_for_each(up, hashent) {
  57                 struct user_struct *user;
  58
  59                 user = list_entry(up, struct user_struct, uidhash_list);
  60
  61                 if(user->uid == uid) {
  62                         atomic_inc(&user->__count);
  63                         return user;
  64                 }
  65         }
  66
  67         return NULL;
  68 }
  69
  70 /*
  71  * Locate the user_struct for the passed UID.  If found, take a ref on it.  The
  72  * caller must undo that ref with free_uid().
  73  *
  74  * If the user_struct could not be found, return NULL.
  75  */
  76 struct user_struct *find_user(uid_t uid)
  77 {
  78         struct user_struct *ret;
  79
  80         spin_lock(&uidhash_lock);
  81         ret = uid_hash_find(uid, uidhashentry(uid));
  82         spin_unlock(&uidhash_lock);
  83         return ret;
  84 }
  85
  86 void free_uid(struct user_struct *up)
  87 {
  88         if (up && atomic_dec_and_lock(&up->__count, &uidhash_lock)) {
  89                 uid_hash_remove(up);
  90                 kmem_cache_free(uid_cachep, up);
  91                 spin_unlock(&uidhash_lock);
  92         }
  93 }
  94
  95 struct user_struct * alloc_uid(uid_t uid)
  96 {
  97         struct list_head *hashent = uidhashentry(uid);
  98         struct user_struct *up;
  99
 100         spin_lock(&uidhash_lock);
 101         up = uid_hash_find(uid, hashent);
 102         spin_unlock(&uidhash_lock);
 103
 104         if (!up) {
 105                 struct user_struct *new;
 106
 107                 new = kmem_cache_alloc(uid_cachep, SLAB_KERNEL);
 108                 if (!new)
 109                         return NULL;
 110                 new->uid = uid;
 111                 atomic_set(&new->__count, 1);
 112                 atomic_set(&new->processes, 0);
 113                 atomic_set(&new->files, 0);
 114                 atomic_set(&new->sigpending, 0);
 115
 116                 new->mq_bytes = 0;
 117                 new->locked_shm = 0;
 118
 119                 /*
 120                  * Before adding this, check whether we raced
 121                  * on adding the same user already..
 122                  */
 123                 spin_lock(&uidhash_lock);
 124                 up = uid_hash_find(uid, hashent);
 125                 if (up) {
 126                         kmem_cache_free(uid_cachep, new);
 127                 } else {
 128                         uid_hash_insert(new, hashent);
 129                         up = new;
 130                 }
 131                 spin_unlock(&uidhash_lock);
 132
 133         }
 134         return up;
 135 }
 136
 137 void switch_uid(struct user_struct *new_user)
 138 {
 139         struct user_struct *old_user;
 140
 141         /* What if a process setreuid()'s and this brings the
 142          * new uid over his NPROC rlimit?  We can check this now
 143          * cheaply with the new uid cache, so if it matters
 144          * we should be checking for it.  -DaveM
 145          */
 146         old_user = current->user;
 147         atomic_inc(&new_user->processes);
 148         atomic_dec(&old_user->processes);
 149         current->user = new_user;
 150         free_uid(old_user);
 151 }
 152
 153
 154 static int __init uid_cache_init(void)
 155 {
 156         int n;
 157
 158         uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
 159                         0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
 160
 161         for(n = 0; n < UIDHASH_SZ; ++n)
 162                 INIT_LIST_HEAD(uidhash_table + n);
 163
 164         /* Insert the root user immediately (init already runs as root) */
 165         spin_lock(&uidhash_lock);
 166         uid_hash_insert(&root_user, uidhashentry(0));
 167         spin_unlock(&uidhash_lock);
 168
 169         return 0;
 170 }
 171
 172 module_init(uid_cache_init);