688 lines · 15.9 KB · C
RawDownload
/* * linux/net/sunrpc/auth.c * * Generic RPC client authentication API. * * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> */ #include <linux/types.h>#include <linux/sched.h>#include <linux/module.h>#include <linux/slab.h>#include <linux/errno.h>#include <linux/hash.h>#include <linux/sunrpc/clnt.h>#include <linux/spinlock.h> #ifdef RPC_DEBUG# define RPCDBG_FACILITY	RPCDBG_AUTH#endif #define RPC_CREDCACHE_DEFAULT_HASHBITS	(4)struct rpc_cred_cache {	struct hlist_head	*hashtable;	unsigned int		hashbits;	spinlock_t		lock;}; static unsigned int auth_hashbits = RPC_CREDCACHE_DEFAULT_HASHBITS; static DEFINE_SPINLOCK(rpc_authflavor_lock);static const struct rpc_authops *auth_flavors[RPC_AUTH_MAXFLAVOR] = {	&authnull_ops,		/* AUTH_NULL */	&authunix_ops,		/* AUTH_UNIX */	NULL,			/* others can be loadable modules */}; static LIST_HEAD(cred_unused);static unsigned long number_cred_unused; #define MAX_HASHTABLE_BITS (14)static int param_set_hashtbl_sz(const char *val, const struct kernel_param *kp){	unsigned long num;	unsigned int nbits;	int ret; 	if (!val)		goto out_inval;	ret = strict_strtoul(val, 0, &num);	if (ret == -EINVAL)		goto out_inval;	nbits = fls(num);	if (num > (1U << nbits))		nbits++;	if (nbits > MAX_HASHTABLE_BITS || nbits < 2)		goto out_inval;	*(unsigned int *)kp->arg = nbits;	return 0;out_inval:	return -EINVAL;} static int param_get_hashtbl_sz(char *buffer, const struct kernel_param *kp){	unsigned int nbits; 	nbits = *(unsigned int *)kp->arg;	return sprintf(buffer, "%u", 1U << nbits);} #define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int); static struct kernel_param_ops param_ops_hashtbl_sz = {	.set = param_set_hashtbl_sz,	.get = param_get_hashtbl_sz,}; module_param_named(auth_hashtable_size, auth_hashbits, hashtbl_sz, 0644);MODULE_PARM_DESC(auth_hashtable_size, "RPC credential cache hashtable size"); static u32pseudoflavor_to_flavor(u32 flavor) {	if (flavor >= RPC_AUTH_MAXFLAVOR)		return RPC_AUTH_GSS;	return flavor;} intrpcauth_register(const struct rpc_authops *ops){	rpc_authflavor_t flavor;	int ret = -EPERM; 	if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR)		return -EINVAL;	spin_lock(&rpc_authflavor_lock);	if (auth_flavors[flavor] == NULL) {		auth_flavors[flavor] = ops;		ret = 0;	}	spin_unlock(&rpc_authflavor_lock);	return ret;}EXPORT_SYMBOL_GPL(rpcauth_register); intrpcauth_unregister(const struct rpc_authops *ops){	rpc_authflavor_t flavor;	int ret = -EPERM; 	if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR)		return -EINVAL;	spin_lock(&rpc_authflavor_lock);	if (auth_flavors[flavor] == ops) {		auth_flavors[flavor] = NULL;		ret = 0;	}	spin_unlock(&rpc_authflavor_lock);	return ret;}EXPORT_SYMBOL_GPL(rpcauth_unregister); struct rpc_auth *rpcauth_create(rpc_authflavor_t pseudoflavor, struct rpc_clnt *clnt){	struct rpc_auth		*auth;	const struct rpc_authops *ops;	u32			flavor = pseudoflavor_to_flavor(pseudoflavor); 	auth = ERR_PTR(-EINVAL);	if (flavor >= RPC_AUTH_MAXFLAVOR)		goto out; 	if ((ops = auth_flavors[flavor]) == NULL)		request_module("rpc-auth-%u", flavor);	spin_lock(&rpc_authflavor_lock);	ops = auth_flavors[flavor];	if (ops == NULL || !try_module_get(ops->owner)) {		spin_unlock(&rpc_authflavor_lock);		goto out;	}	spin_unlock(&rpc_authflavor_lock);	auth = ops->create(clnt, pseudoflavor);	module_put(ops->owner);	if (IS_ERR(auth))		return auth;	if (clnt->cl_auth)		rpcauth_release(clnt->cl_auth);	clnt->cl_auth = auth; out:	return auth;}EXPORT_SYMBOL_GPL(rpcauth_create); voidrpcauth_release(struct rpc_auth *auth){	if (!atomic_dec_and_test(&auth->au_count))		return;	auth->au_ops->destroy(auth);} static DEFINE_SPINLOCK(rpc_credcache_lock); static voidrpcauth_unhash_cred_locked(struct rpc_cred *cred){	hlist_del_rcu(&cred->cr_hash);	smp_mb__before_clear_bit();	clear_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);} static intrpcauth_unhash_cred(struct rpc_cred *cred){	spinlock_t *cache_lock;	int ret; 	cache_lock = &cred->cr_auth->au_credcache->lock;	spin_lock(cache_lock);	ret = atomic_read(&cred->cr_count) == 0;	if (ret)		rpcauth_unhash_cred_locked(cred);	spin_unlock(cache_lock);	return ret;} /* * Initialize RPC credential cache */intrpcauth_init_credcache(struct rpc_auth *auth){	struct rpc_cred_cache *new;	unsigned int hashsize; 	new = kmalloc(sizeof(*new), GFP_KERNEL);	if (!new)		goto out_nocache;	new->hashbits = auth_hashbits;	hashsize = 1U << new->hashbits;	new->hashtable = kcalloc(hashsize, sizeof(new->hashtable[0]), GFP_KERNEL);	if (!new->hashtable)		goto out_nohashtbl;	spin_lock_init(&new->lock);	auth->au_credcache = new;	return 0;out_nohashtbl:	kfree(new);out_nocache:	return -ENOMEM;}EXPORT_SYMBOL_GPL(rpcauth_init_credcache); /* * Destroy a list of credentials */static inlinevoid rpcauth_destroy_credlist(struct list_head *head){	struct rpc_cred *cred; 	while (!list_empty(head)) {		cred = list_entry(head->next, struct rpc_cred, cr_lru);		list_del_init(&cred->cr_lru);		put_rpccred(cred);	}} /* * Clear the RPC credential cache, and delete those credentials * that are not referenced. */voidrpcauth_clear_credcache(struct rpc_cred_cache *cache){	LIST_HEAD(free);	struct hlist_head *head;	struct rpc_cred	*cred;	unsigned int hashsize = 1U << cache->hashbits;	int		i; 	spin_lock(&rpc_credcache_lock);	spin_lock(&cache->lock);	for (i = 0; i < hashsize; i++) {		head = &cache->hashtable[i];		while (!hlist_empty(head)) {			cred = hlist_entry(head->first, struct rpc_cred, cr_hash);			get_rpccred(cred);			if (!list_empty(&cred->cr_lru)) {				list_del(&cred->cr_lru);				number_cred_unused--;			}			list_add_tail(&cred->cr_lru, &free);			rpcauth_unhash_cred_locked(cred);		}	}	spin_unlock(&cache->lock);	spin_unlock(&rpc_credcache_lock);	rpcauth_destroy_credlist(&free);} /* * Destroy the RPC credential cache */voidrpcauth_destroy_credcache(struct rpc_auth *auth){	struct rpc_cred_cache *cache = auth->au_credcache; 	if (cache) {		auth->au_credcache = NULL;		rpcauth_clear_credcache(cache);		kfree(cache->hashtable);		kfree(cache);	}}EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache);  #define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ) /* * Remove stale credentials. Avoid sleeping inside the loop. */static intrpcauth_prune_expired(struct list_head *free, int nr_to_scan){	spinlock_t *cache_lock;	struct rpc_cred *cred, *next;	unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM; 	list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) { 		if (nr_to_scan-- == 0)			break;		/*		 * Enforce a 60 second garbage collection moratorium		 * Note that the cred_unused list must be time-ordered.		 */		if (time_in_range(cred->cr_expire, expired, jiffies) &&		    test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0)			return 0; 		list_del_init(&cred->cr_lru);		number_cred_unused--;		if (atomic_read(&cred->cr_count) != 0)			continue; 		cache_lock = &cred->cr_auth->au_credcache->lock;		spin_lock(cache_lock);		if (atomic_read(&cred->cr_count) == 0) {			get_rpccred(cred);			list_add_tail(&cred->cr_lru, free);			rpcauth_unhash_cred_locked(cred);		}		spin_unlock(cache_lock);	}	return (number_cred_unused / 100) * sysctl_vfs_cache_pressure;} /* * Run memory cache shrinker. */static intrpcauth_cache_shrinker(struct shrinker *shrink, struct shrink_control *sc){	LIST_HEAD(free);	int res;	int nr_to_scan = sc->nr_to_scan;	gfp_t gfp_mask = sc->gfp_mask; 	if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL)		return (nr_to_scan == 0) ? 0 : -1;	if (list_empty(&cred_unused))		return 0;	spin_lock(&rpc_credcache_lock);	res = rpcauth_prune_expired(&free, nr_to_scan);	spin_unlock(&rpc_credcache_lock);	rpcauth_destroy_credlist(&free);	return res;} /* * Look up a process' credentials in the authentication cache */struct rpc_cred *rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred,		int flags){	LIST_HEAD(free);	struct rpc_cred_cache *cache = auth->au_credcache;	struct hlist_node *pos;	struct rpc_cred	*cred = NULL,			*entry, *new;	unsigned int nr; 	nr = hash_long(acred->uid, cache->hashbits); 	rcu_read_lock();	hlist_for_each_entry_rcu(entry, pos, &cache->hashtable[nr], cr_hash) {		if (!entry->cr_ops->crmatch(acred, entry, flags))			continue;		spin_lock(&cache->lock);		if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) == 0) {			spin_unlock(&cache->lock);			continue;		}		cred = get_rpccred(entry);		spin_unlock(&cache->lock);		break;	}	rcu_read_unlock(); 	if (cred != NULL)		goto found; 	new = auth->au_ops->crcreate(auth, acred, flags);	if (IS_ERR(new)) {		cred = new;		goto out;	} 	spin_lock(&cache->lock);	hlist_for_each_entry(entry, pos, &cache->hashtable[nr], cr_hash) {		if (!entry->cr_ops->crmatch(acred, entry, flags))			continue;		cred = get_rpccred(entry);		break;	}	if (cred == NULL) {		cred = new;		set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);		hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]);	} else		list_add_tail(&new->cr_lru, &free);	spin_unlock(&cache->lock);found:	if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&	    cred->cr_ops->cr_init != NULL &&	    !(flags & RPCAUTH_LOOKUP_NEW)) {		int res = cred->cr_ops->cr_init(auth, cred);		if (res < 0) {			put_rpccred(cred);			cred = ERR_PTR(res);		}	}	rpcauth_destroy_credlist(&free);out:	return cred;}EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache); struct rpc_cred *rpcauth_lookupcred(struct rpc_auth *auth, int flags){	struct auth_cred acred;	struct rpc_cred *ret;	const struct cred *cred = current_cred(); 	dprintk("RPC:       looking up %s cred\n",		auth->au_ops->au_name); 	memset(&acred, 0, sizeof(acred));	acred.uid = cred->fsuid;	acred.gid = cred->fsgid;	acred.group_info = get_group_info(((struct cred *)cred)->group_info); 	ret = auth->au_ops->lookup_cred(auth, &acred, flags);	put_group_info(acred.group_info);	return ret;} voidrpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,		  struct rpc_auth *auth, const struct rpc_credops *ops){	INIT_HLIST_NODE(&cred->cr_hash);	INIT_LIST_HEAD(&cred->cr_lru);	atomic_set(&cred->cr_count, 1);	cred->cr_auth = auth;	cred->cr_ops = ops;	cred->cr_expire = jiffies;#ifdef RPC_DEBUG	cred->cr_magic = RPCAUTH_CRED_MAGIC;#endif	cred->cr_uid = acred->uid;}EXPORT_SYMBOL_GPL(rpcauth_init_cred); struct rpc_cred *rpcauth_generic_bind_cred(struct rpc_task *task, struct rpc_cred *cred, int lookupflags){	dprintk("RPC: %5u holding %s cred %p\n", task->tk_pid,			cred->cr_auth->au_ops->au_name, cred);	return get_rpccred(cred);}EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred); static struct rpc_cred *rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags){	struct rpc_auth *auth = task->tk_client->cl_auth;	struct auth_cred acred = {		.uid = 0,		.gid = 0,	}; 	dprintk("RPC: %5u looking up %s cred\n",		task->tk_pid, task->tk_client->cl_auth->au_ops->au_name);	return auth->au_ops->lookup_cred(auth, &acred, lookupflags);} static struct rpc_cred *rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags){	struct rpc_auth *auth = task->tk_client->cl_auth; 	dprintk("RPC: %5u looking up %s cred\n",		task->tk_pid, auth->au_ops->au_name);	return rpcauth_lookupcred(auth, lookupflags);} static intrpcauth_bindcred(struct rpc_task *task, struct rpc_cred *cred, int flags){	struct rpc_rqst *req = task->tk_rqstp;	struct rpc_cred *new;	int lookupflags = 0; 	if (flags & RPC_TASK_ASYNC)		lookupflags |= RPCAUTH_LOOKUP_NEW;	if (cred != NULL)		new = cred->cr_ops->crbind(task, cred, lookupflags);	else if (flags & RPC_TASK_ROOTCREDS)		new = rpcauth_bind_root_cred(task, lookupflags);	else

Lines 1–500 of 688.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t