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(xid,uid)    ((((uid) >> UIDHASH_BITS) + ((uid)^(xid))) & UIDHASH_MASK)
  24 #define uidhashentry(xid,uid)   (uidhash_table + __uidhashfn((xid),(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 };
  35
  36 /*
  37  * These routines must be called with the uidhash spinlock held!
  38  */
  39 static inline void uid_hash_insert(struct user_struct *up, struct list_head *hashent)
  40 {
  41         list_add(&up->uidhash_list, hashent);
  42 }
  43
  44 static inline void uid_hash_remove(struct user_struct *up)
  45 {
  46         list_del(&up->uidhash_list);
  47 }
  48
  49 static inline struct user_struct *uid_hash_find(xid_t xid, uid_t uid, struct list_head *hashent)
  50 {
  51         struct list_head *up;
  52
  53         list_for_each(up, hashent) {
  54                 struct user_struct *user;
  55
  56                 user = list_entry(up, struct user_struct, uidhash_list);
  57
  58                 if(user->uid == uid && user->xid == xid) {
  59                         atomic_inc(&user->__count);
  60                         return user;
  61                 }
  62         }
  63
  64         return NULL;
  65 }
  66
  67 struct user_struct *find_user(xid_t xid, uid_t uid)
  68 {
  69         return uid_hash_find(xid, uid, uidhashentry(xid, uid));
  70 }
  71
  72 void free_uid(struct user_struct *up)
  73 {
  74         if (up && atomic_dec_and_lock(&up->__count, &uidhash_lock)) {
  75                 uid_hash_remove(up);
  76                 kmem_cache_free(uid_cachep, up);
  77                 spin_unlock(&uidhash_lock);
  78         }
  79 }
  80
  81 struct user_struct * alloc_uid(xid_t xid, uid_t uid)
  82 {
  83         struct list_head *hashent = uidhashentry(xid, uid);
  84         struct user_struct *up;
  85
  86         spin_lock(&uidhash_lock);
  87         up = uid_hash_find(xid, uid, hashent);
  88         spin_unlock(&uidhash_lock);
  89
  90         if (!up) {
  91                 struct user_struct *new;
  92
  93                 new = kmem_cache_alloc(uid_cachep, SLAB_KERNEL);
  94                 if (!new)
  95                         return NULL;
  96                 new->uid = uid;
  97                 new->xid = xid;
  98                 atomic_set(&new->__count, 1);
  99                 atomic_set(&new->processes, 0);
 100                 atomic_set(&new->files, 0);
 101
 102                 /*
 103                  * Before adding this, check whether we raced
 104                  * on adding the same user already..
 105                  */
 106                 spin_lock(&uidhash_lock);
 107                 up = uid_hash_find(xid, uid, hashent);
 108                 if (up) {
 109                         kmem_cache_free(uid_cachep, new);
 110                 } else {
 111                         uid_hash_insert(new, hashent);
 112                         up = new;
 113                 }
 114                 spin_unlock(&uidhash_lock);
 115
 116         }
 117         return up;
 118 }
 119
 120 void switch_uid(struct user_struct *new_user)
 121 {
 122         struct user_struct *old_user;
 123
 124         /* What if a process setreuid()'s and this brings the
 125          * new uid over his NPROC rlimit?  We can check this now
 126          * cheaply with the new uid cache, so if it matters
 127          * we should be checking for it.  -DaveM
 128          */
 129         old_user = current->user;
 130         atomic_inc(&new_user->processes);
 131         atomic_dec(&old_user->processes);
 132         current->user = new_user;
 133         free_uid(old_user);
 134 }
 135
 136
 137 static int __init uid_cache_init(void)
 138 {
 139         int n;
 140
 141         uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
 142                                        0,
 143                                        SLAB_HWCACHE_ALIGN, NULL, NULL);
 144         if(!uid_cachep)
 145                 panic("Cannot create uid taskcount SLAB cache\n");
 146
 147         for(n = 0; n < UIDHASH_SZ; ++n)
 148                 INIT_LIST_HEAD(uidhash_table + n);
 149
 150         /* Insert the root user immediately (init already runs as root) */
 151         spin_lock(&uidhash_lock);
 152         uid_hash_insert(&root_user, uidhashentry(0,0));
 153         spin_unlock(&uidhash_lock);
 154
 155         return 0;
 156 }
 157
 158 module_init(uid_cache_init);