URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [kernel/] [user.c] - Rev 1774
Go to most recent revision | Compare with Previous | Blame | View Log
/* * The "user cache". * * (C) Copyright 1991-2000 Linus Torvalds * * We have a per-user structure to keep track of how many * processes, files etc the user has claimed, in order to be * able to have per-user limits for system resources. */ #include <linux/init.h> #include <linux/sched.h> #include <linux/slab.h> /* * UID task count cache, to get fast user lookup in "alloc_uid" * when changing user ID's (ie setuid() and friends). */ #define UIDHASH_BITS 8 #define UIDHASH_SZ (1 << UIDHASH_BITS) #define UIDHASH_MASK (UIDHASH_SZ - 1) #define __uidhashfn(uid) (((uid >> UIDHASH_BITS) ^ uid) & UIDHASH_MASK) #define uidhashentry(uid) (uidhash_table + __uidhashfn(uid)) static kmem_cache_t *uid_cachep; static struct user_struct *uidhash_table[UIDHASH_SZ]; static spinlock_t uidhash_lock = SPIN_LOCK_UNLOCKED; struct user_struct root_user = { __count: ATOMIC_INIT(1), processes: ATOMIC_INIT(1), files: ATOMIC_INIT(0) }; /* * These routines must be called with the uidhash spinlock held! */ static inline void uid_hash_insert(struct user_struct *up, struct user_struct **hashent) { struct user_struct *next = *hashent; up->next = next; if (next) next->pprev = &up->next; up->pprev = hashent; *hashent = up; } static inline void uid_hash_remove(struct user_struct *up) { struct user_struct *next = up->next; struct user_struct **pprev = up->pprev; if (next) next->pprev = pprev; *pprev = next; } static inline struct user_struct *uid_hash_find(uid_t uid, struct user_struct **hashent) { struct user_struct *next; next = *hashent; for (;;) { struct user_struct *up = next; if (next) { next = up->next; if (up->uid != uid) continue; atomic_inc(&up->__count); } return up; } } void free_uid(struct user_struct *up) { if (up && atomic_dec_and_lock(&up->__count, &uidhash_lock)) { uid_hash_remove(up); kmem_cache_free(uid_cachep, up); spin_unlock(&uidhash_lock); } } struct user_struct * alloc_uid(uid_t uid) { struct user_struct **hashent = uidhashentry(uid); struct user_struct *up; spin_lock(&uidhash_lock); up = uid_hash_find(uid, hashent); spin_unlock(&uidhash_lock); if (!up) { struct user_struct *new; new = kmem_cache_alloc(uid_cachep, SLAB_KERNEL); if (!new) return NULL; new->uid = uid; atomic_set(&new->__count, 1); atomic_set(&new->processes, 0); atomic_set(&new->files, 0); /* * Before adding this, check whether we raced * on adding the same user already.. */ spin_lock(&uidhash_lock); up = uid_hash_find(uid, hashent); if (up) { kmem_cache_free(uid_cachep, new); } else { uid_hash_insert(new, hashent); up = new; } spin_unlock(&uidhash_lock); } return up; } void switch_uid(struct user_struct *new_user) { struct user_struct *old_user; /* What if a process setreuid()'s and this brings the * new uid over his NPROC rlimit? We can check this now * cheaply with the new uid cache, so if it matters * we should be checking for it. -DaveM */ old_user = current->user; atomic_inc(&new_user->__count); atomic_inc(&new_user->processes); atomic_dec(&old_user->processes); current->user = new_user; free_uid(old_user); } static int __init uid_cache_init(void) { uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct), 0, SLAB_HWCACHE_ALIGN, NULL, NULL); if(!uid_cachep) panic("Cannot create uid taskcount SLAB cache\n"); /* Insert the root user immediately - init already runs with this */ uid_hash_insert(&root_user, uidhashentry(0)); return 0; } module_init(uid_cache_init);
Go to most recent revision | Compare with Previous | Blame | View Log