blob: 2debbaba7809b640cbb95195e782800530b12e24 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/net/sunrpc/auth.c
3 *
4 * Generic RPC client authentication API.
5 *
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
7 */
8
9#include <linux/types.h>
10#include <linux/sched.h>
Ingo Molnar5b825c32017-02-02 17:54:15 +010011#include <linux/cred.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/module.h>
13#include <linux/slab.h>
14#include <linux/errno.h>
Trond Myklebust25337fd2008-03-12 14:40:14 -040015#include <linux/hash.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/sunrpc/clnt.h>
Chuck Lever6a1a1e32012-07-11 16:31:08 -040017#include <linux/sunrpc/gss_api.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/spinlock.h>
19
Jeff Laytonf895b252014-11-17 16:58:04 -050020#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Linus Torvalds1da177e2005-04-16 15:20:36 -070021# define RPCDBG_FACILITY RPCDBG_AUTH
22#endif
23
Trond Myklebust241269b2010-07-31 14:29:08 -040024#define RPC_CREDCACHE_DEFAULT_HASHBITS (4)
25struct rpc_cred_cache {
26 struct hlist_head *hashtable;
27 unsigned int hashbits;
28 spinlock_t lock;
29};
30
31static unsigned int auth_hashbits = RPC_CREDCACHE_DEFAULT_HASHBITS;
32
Trond Myklebust4e4c3be2018-09-27 13:12:44 -040033static const struct rpc_authops __rcu *auth_flavors[RPC_AUTH_MAXFLAVOR] = {
34 [RPC_AUTH_NULL] = (const struct rpc_authops __force __rcu *)&authnull_ops,
35 [RPC_AUTH_UNIX] = (const struct rpc_authops __force __rcu *)&authunix_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 NULL, /* others can be loadable modules */
37};
38
Trond Myklebuste092bdc2007-06-23 19:45:36 -040039static LIST_HEAD(cred_unused);
Trond Myklebustf5c21872007-06-25 17:11:20 -040040static unsigned long number_cred_unused;
Trond Myklebuste092bdc2007-06-23 19:45:36 -040041
NeilBrowna52458b2018-12-03 11:30:31 +110042static struct cred machine_cred = {
43 .usage = ATOMIC_INIT(1),
NeilBrown5e169232018-12-03 11:30:30 +110044};
45
46/*
47 * Return the machine_cred pointer to be used whenever
48 * the a generic machine credential is needed.
49 */
NeilBrowna52458b2018-12-03 11:30:31 +110050const struct cred *rpc_machine_cred(void)
NeilBrown5e169232018-12-03 11:30:30 +110051{
52 return &machine_cred;
53}
54EXPORT_SYMBOL_GPL(rpc_machine_cred);
55
Miquel van Smoorenburgdb5fe262010-09-12 19:55:26 -040056#define MAX_HASHTABLE_BITS (14)
Stephen Rothwell8e4e15d2010-08-04 12:11:22 +100057static int param_set_hashtbl_sz(const char *val, const struct kernel_param *kp)
Trond Myklebust241269b2010-07-31 14:29:08 -040058{
59 unsigned long num;
60 unsigned int nbits;
61 int ret;
62
63 if (!val)
64 goto out_inval;
Daniel Walter00cfaa92014-06-21 13:06:38 +010065 ret = kstrtoul(val, 0, &num);
Dan Carpenter1a54c0c2018-07-12 15:30:08 +030066 if (ret)
Trond Myklebust241269b2010-07-31 14:29:08 -040067 goto out_inval;
Frank Sorenson34ae6852016-06-27 15:17:19 -040068 nbits = fls(num - 1);
Trond Myklebust241269b2010-07-31 14:29:08 -040069 if (nbits > MAX_HASHTABLE_BITS || nbits < 2)
70 goto out_inval;
71 *(unsigned int *)kp->arg = nbits;
72 return 0;
73out_inval:
74 return -EINVAL;
75}
76
Stephen Rothwell8e4e15d2010-08-04 12:11:22 +100077static int param_get_hashtbl_sz(char *buffer, const struct kernel_param *kp)
Trond Myklebust241269b2010-07-31 14:29:08 -040078{
79 unsigned int nbits;
80
81 nbits = *(unsigned int *)kp->arg;
82 return sprintf(buffer, "%u", 1U << nbits);
83}
84
85#define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int);
86
Luis R. Rodriguez9c278472015-05-27 11:09:38 +093087static const struct kernel_param_ops param_ops_hashtbl_sz = {
Stephen Rothwell8e4e15d2010-08-04 12:11:22 +100088 .set = param_set_hashtbl_sz,
89 .get = param_get_hashtbl_sz,
90};
91
Trond Myklebust241269b2010-07-31 14:29:08 -040092module_param_named(auth_hashtable_size, auth_hashbits, hashtbl_sz, 0644);
93MODULE_PARM_DESC(auth_hashtable_size, "RPC credential cache hashtable size");
94
Trond Myklebustbae67462014-07-21 13:32:42 -040095static unsigned long auth_max_cred_cachesize = ULONG_MAX;
96module_param(auth_max_cred_cachesize, ulong, 0644);
97MODULE_PARM_DESC(auth_max_cred_cachesize, "RPC credential maximum total cache size");
98
Linus Torvalds1da177e2005-04-16 15:20:36 -070099static u32
100pseudoflavor_to_flavor(u32 flavor) {
Chuck Lever1c74a242013-03-22 12:53:08 -0400101 if (flavor > RPC_AUTH_MAXFLAVOR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 return RPC_AUTH_GSS;
103 return flavor;
104}
105
106int
Trond Myklebustf1c0a862007-06-23 20:17:58 -0400107rpcauth_register(const struct rpc_authops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108{
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400109 const struct rpc_authops *old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 rpc_authflavor_t flavor;
111
112 if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR)
113 return -EINVAL;
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400114 old = cmpxchg((const struct rpc_authops ** __force)&auth_flavors[flavor], NULL, ops);
115 if (old == NULL || old == ops)
116 return 0;
117 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400119EXPORT_SYMBOL_GPL(rpcauth_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121int
Trond Myklebustf1c0a862007-06-23 20:17:58 -0400122rpcauth_unregister(const struct rpc_authops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123{
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400124 const struct rpc_authops *old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 rpc_authflavor_t flavor;
126
127 if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR)
128 return -EINVAL;
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400129
130 old = cmpxchg((const struct rpc_authops ** __force)&auth_flavors[flavor], ops, NULL);
131 if (old == ops || old == NULL)
132 return 0;
133 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400135EXPORT_SYMBOL_GPL(rpcauth_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400137static const struct rpc_authops *
138rpcauth_get_authops(rpc_authflavor_t flavor)
139{
140 const struct rpc_authops *ops;
141
142 if (flavor >= RPC_AUTH_MAXFLAVOR)
143 return NULL;
144
145 rcu_read_lock();
146 ops = rcu_dereference(auth_flavors[flavor]);
147 if (ops == NULL) {
148 rcu_read_unlock();
149 request_module("rpc-auth-%u", flavor);
150 rcu_read_lock();
151 ops = rcu_dereference(auth_flavors[flavor]);
152 if (ops == NULL)
153 goto out;
154 }
155 if (!try_module_get(ops->owner))
156 ops = NULL;
157out:
158 rcu_read_unlock();
159 return ops;
160}
161
162static void
163rpcauth_put_authops(const struct rpc_authops *ops)
164{
165 module_put(ops->owner);
166}
167
Chuck Lever6a1a1e32012-07-11 16:31:08 -0400168/**
Chuck Lever9568c5e2013-03-16 15:54:43 -0400169 * rpcauth_get_pseudoflavor - check if security flavor is supported
170 * @flavor: a security flavor
171 * @info: a GSS mech OID, quality of protection, and service value
172 *
173 * Verifies that an appropriate kernel module is available or already loaded.
174 * Returns an equivalent pseudoflavor, or RPC_AUTH_MAXFLAVOR if "flavor" is
175 * not supported locally.
176 */
177rpc_authflavor_t
178rpcauth_get_pseudoflavor(rpc_authflavor_t flavor, struct rpcsec_gss_info *info)
179{
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400180 const struct rpc_authops *ops = rpcauth_get_authops(flavor);
Chuck Lever9568c5e2013-03-16 15:54:43 -0400181 rpc_authflavor_t pseudoflavor;
182
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400183 if (!ops)
Chuck Lever9568c5e2013-03-16 15:54:43 -0400184 return RPC_AUTH_MAXFLAVOR;
Chuck Lever9568c5e2013-03-16 15:54:43 -0400185 pseudoflavor = flavor;
186 if (ops->info2flavor != NULL)
187 pseudoflavor = ops->info2flavor(info);
188
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400189 rpcauth_put_authops(ops);
Chuck Lever9568c5e2013-03-16 15:54:43 -0400190 return pseudoflavor;
191}
192EXPORT_SYMBOL_GPL(rpcauth_get_pseudoflavor);
193
194/**
Chuck Levera77c8062013-03-16 15:55:10 -0400195 * rpcauth_get_gssinfo - find GSS tuple matching a GSS pseudoflavor
196 * @pseudoflavor: GSS pseudoflavor to match
197 * @info: rpcsec_gss_info structure to fill in
198 *
199 * Returns zero and fills in "info" if pseudoflavor matches a
200 * supported mechanism.
201 */
202int
203rpcauth_get_gssinfo(rpc_authflavor_t pseudoflavor, struct rpcsec_gss_info *info)
204{
205 rpc_authflavor_t flavor = pseudoflavor_to_flavor(pseudoflavor);
206 const struct rpc_authops *ops;
207 int result;
208
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400209 ops = rpcauth_get_authops(flavor);
Chuck Levera77c8062013-03-16 15:55:10 -0400210 if (ops == NULL)
Chuck Levera77c8062013-03-16 15:55:10 -0400211 return -ENOENT;
Chuck Levera77c8062013-03-16 15:55:10 -0400212
213 result = -ENOENT;
214 if (ops->flavor2info != NULL)
215 result = ops->flavor2info(pseudoflavor, info);
216
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400217 rpcauth_put_authops(ops);
Chuck Levera77c8062013-03-16 15:55:10 -0400218 return result;
219}
220EXPORT_SYMBOL_GPL(rpcauth_get_gssinfo);
221
222/**
Chuck Lever6a1a1e32012-07-11 16:31:08 -0400223 * rpcauth_list_flavors - discover registered flavors and pseudoflavors
224 * @array: array to fill in
225 * @size: size of "array"
226 *
227 * Returns the number of array items filled in, or a negative errno.
228 *
229 * The returned array is not sorted by any policy. Callers should not
230 * rely on the order of the items in the returned array.
231 */
232int
233rpcauth_list_flavors(rpc_authflavor_t *array, int size)
234{
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400235 const struct rpc_authops *ops;
236 rpc_authflavor_t flavor, pseudos[4];
237 int i, len, result = 0;
Chuck Lever6a1a1e32012-07-11 16:31:08 -0400238
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400239 rcu_read_lock();
Chuck Lever6a1a1e32012-07-11 16:31:08 -0400240 for (flavor = 0; flavor < RPC_AUTH_MAXFLAVOR; flavor++) {
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400241 ops = rcu_dereference(auth_flavors[flavor]);
Chuck Lever6a1a1e32012-07-11 16:31:08 -0400242 if (result >= size) {
243 result = -ENOMEM;
244 break;
245 }
246
247 if (ops == NULL)
248 continue;
249 if (ops->list_pseudoflavors == NULL) {
250 array[result++] = ops->au_flavor;
251 continue;
252 }
253 len = ops->list_pseudoflavors(pseudos, ARRAY_SIZE(pseudos));
254 if (len < 0) {
255 result = len;
256 break;
257 }
258 for (i = 0; i < len; i++) {
259 if (result >= size) {
260 result = -ENOMEM;
261 break;
262 }
263 array[result++] = pseudos[i];
264 }
265 }
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400266 rcu_read_unlock();
Chuck Lever6a1a1e32012-07-11 16:31:08 -0400267
268 dprintk("RPC: %s returns %d\n", __func__, result);
269 return result;
270}
271EXPORT_SYMBOL_GPL(rpcauth_list_flavors);
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273struct rpc_auth *
Sargun Dhillon82b98ca2018-07-05 16:48:50 +0000274rpcauth_create(const struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400276 struct rpc_auth *auth = ERR_PTR(-EINVAL);
Trond Myklebustf1c0a862007-06-23 20:17:58 -0400277 const struct rpc_authops *ops;
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400278 u32 flavor = pseudoflavor_to_flavor(args->pseudoflavor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400280 ops = rpcauth_get_authops(flavor);
281 if (ops == NULL)
Olaf Kirchf344f6d2006-03-20 13:44:08 -0500282 goto out;
283
Trond Myklebustc2190662013-08-26 19:23:04 -0400284 auth = ops->create(args, clnt);
Trond Myklebust4e4c3be2018-09-27 13:12:44 -0400285
286 rpcauth_put_authops(ops);
J. Bruce Fields6a192752005-06-22 17:16:23 +0000287 if (IS_ERR(auth))
288 return auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 if (clnt->cl_auth)
Trond Myklebustde7a8ce2007-06-23 10:46:47 -0400290 rpcauth_release(clnt->cl_auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 clnt->cl_auth = auth;
Olaf Kirchf344f6d2006-03-20 13:44:08 -0500292
293out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 return auth;
295}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400296EXPORT_SYMBOL_GPL(rpcauth_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
298void
Trond Myklebustde7a8ce2007-06-23 10:46:47 -0400299rpcauth_release(struct rpc_auth *auth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
Trond Myklebust331bc712018-10-14 10:40:29 -0400301 if (!refcount_dec_and_test(&auth->au_count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 return;
303 auth->au_ops->destroy(auth);
304}
305
306static DEFINE_SPINLOCK(rpc_credcache_lock);
307
Trond Myklebust95cd6232018-10-11 16:11:09 -0400308/*
309 * On success, the caller is responsible for freeing the reference
310 * held by the hashtable
311 */
312static bool
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400313rpcauth_unhash_cred_locked(struct rpc_cred *cred)
314{
Trond Myklebust95cd6232018-10-11 16:11:09 -0400315 if (!test_and_clear_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags))
316 return false;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400317 hlist_del_rcu(&cred->cr_hash);
Trond Myklebust95cd6232018-10-11 16:11:09 -0400318 return true;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400319}
320
Trond Myklebust95cd6232018-10-11 16:11:09 -0400321static bool
Trond Myklebust9499b432007-06-24 15:57:57 -0400322rpcauth_unhash_cred(struct rpc_cred *cred)
323{
324 spinlock_t *cache_lock;
Trond Myklebust95cd6232018-10-11 16:11:09 -0400325 bool ret;
Trond Myklebust9499b432007-06-24 15:57:57 -0400326
Trond Myklebust95cd6232018-10-11 16:11:09 -0400327 if (!test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags))
328 return false;
Trond Myklebust9499b432007-06-24 15:57:57 -0400329 cache_lock = &cred->cr_auth->au_credcache->lock;
330 spin_lock(cache_lock);
Trond Myklebust95cd6232018-10-11 16:11:09 -0400331 ret = rpcauth_unhash_cred_locked(cred);
Trond Myklebust9499b432007-06-24 15:57:57 -0400332 spin_unlock(cache_lock);
Trond Myklebustf0380f32009-12-03 08:10:17 -0500333 return ret;
Trond Myklebust9499b432007-06-24 15:57:57 -0400334}
335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336/*
337 * Initialize RPC credential cache
338 */
339int
Trond Myklebustf5c21872007-06-25 17:11:20 -0400340rpcauth_init_credcache(struct rpc_auth *auth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
342 struct rpc_cred_cache *new;
Trond Myklebust988664a2010-07-31 14:29:07 -0400343 unsigned int hashsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Kris Katterjohn8b3a7002006-01-11 15:56:43 -0800345 new = kmalloc(sizeof(*new), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 if (!new)
Trond Myklebust241269b2010-07-31 14:29:08 -0400347 goto out_nocache;
348 new->hashbits = auth_hashbits;
Trond Myklebust988664a2010-07-31 14:29:07 -0400349 hashsize = 1U << new->hashbits;
Trond Myklebust241269b2010-07-31 14:29:08 -0400350 new->hashtable = kcalloc(hashsize, sizeof(new->hashtable[0]), GFP_KERNEL);
351 if (!new->hashtable)
352 goto out_nohashtbl;
Trond Myklebust9499b432007-06-24 15:57:57 -0400353 spin_lock_init(&new->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 auth->au_credcache = new;
355 return 0;
Trond Myklebust241269b2010-07-31 14:29:08 -0400356out_nohashtbl:
357 kfree(new);
358out_nocache:
359 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400361EXPORT_SYMBOL_GPL(rpcauth_init_credcache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Jeff Laytona0337d12014-06-21 20:52:16 -0400363char *
364rpcauth_stringify_acceptor(struct rpc_cred *cred)
365{
366 if (!cred->cr_ops->crstringify_acceptor)
367 return NULL;
368 return cred->cr_ops->crstringify_acceptor(cred);
369}
370EXPORT_SYMBOL_GPL(rpcauth_stringify_acceptor);
371
Andy Adamson4de6caa2013-08-14 11:59:15 -0400372/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 * Destroy a list of credentials
374 */
375static inline
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400376void rpcauth_destroy_credlist(struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377{
378 struct rpc_cred *cred;
379
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400380 while (!list_empty(head)) {
381 cred = list_entry(head->next, struct rpc_cred, cr_lru);
382 list_del_init(&cred->cr_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 put_rpccred(cred);
384 }
385}
386
Trond Myklebust95cd6232018-10-11 16:11:09 -0400387static void
388rpcauth_lru_add_locked(struct rpc_cred *cred)
389{
390 if (!list_empty(&cred->cr_lru))
391 return;
392 number_cred_unused++;
393 list_add_tail(&cred->cr_lru, &cred_unused);
394}
395
396static void
397rpcauth_lru_add(struct rpc_cred *cred)
398{
399 if (!list_empty(&cred->cr_lru))
400 return;
401 spin_lock(&rpc_credcache_lock);
402 rpcauth_lru_add_locked(cred);
403 spin_unlock(&rpc_credcache_lock);
404}
405
406static void
407rpcauth_lru_remove_locked(struct rpc_cred *cred)
408{
409 if (list_empty(&cred->cr_lru))
410 return;
411 number_cred_unused--;
412 list_del_init(&cred->cr_lru);
413}
414
415static void
416rpcauth_lru_remove(struct rpc_cred *cred)
417{
418 if (list_empty(&cred->cr_lru))
419 return;
420 spin_lock(&rpc_credcache_lock);
421 rpcauth_lru_remove_locked(cred);
422 spin_unlock(&rpc_credcache_lock);
423}
424
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425/*
426 * Clear the RPC credential cache, and delete those credentials
427 * that are not referenced.
428 */
429void
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400430rpcauth_clear_credcache(struct rpc_cred_cache *cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431{
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400432 LIST_HEAD(free);
433 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 struct rpc_cred *cred;
Trond Myklebust988664a2010-07-31 14:29:07 -0400435 unsigned int hashsize = 1U << cache->hashbits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 int i;
437
438 spin_lock(&rpc_credcache_lock);
Trond Myklebust9499b432007-06-24 15:57:57 -0400439 spin_lock(&cache->lock);
Trond Myklebust988664a2010-07-31 14:29:07 -0400440 for (i = 0; i < hashsize; i++) {
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400441 head = &cache->hashtable[i];
442 while (!hlist_empty(head)) {
443 cred = hlist_entry(head->first, struct rpc_cred, cr_hash);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400444 rpcauth_unhash_cred_locked(cred);
Trond Myklebust95cd6232018-10-11 16:11:09 -0400445 /* Note: We now hold a reference to cred */
446 rpcauth_lru_remove_locked(cred);
447 list_add_tail(&cred->cr_lru, &free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 }
449 }
Trond Myklebust9499b432007-06-24 15:57:57 -0400450 spin_unlock(&cache->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 spin_unlock(&rpc_credcache_lock);
452 rpcauth_destroy_credlist(&free);
453}
454
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400455/*
456 * Destroy the RPC credential cache
457 */
458void
459rpcauth_destroy_credcache(struct rpc_auth *auth)
460{
461 struct rpc_cred_cache *cache = auth->au_credcache;
462
463 if (cache) {
464 auth->au_credcache = NULL;
465 rpcauth_clear_credcache(cache);
Trond Myklebust241269b2010-07-31 14:29:08 -0400466 kfree(cache->hashtable);
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400467 kfree(cache);
468 }
469}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400470EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache);
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400471
Trond Myklebustd2b83142008-04-14 18:13:37 -0400472
473#define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ)
474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475/*
476 * Remove stale credentials. Avoid sleeping inside the loop.
477 */
Dave Chinner70534a72013-08-28 10:18:14 +1000478static long
Trond Myklebustf5c21872007-06-25 17:11:20 -0400479rpcauth_prune_expired(struct list_head *free, int nr_to_scan)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
Trond Myklebusteac0d182008-10-28 15:21:41 -0400481 struct rpc_cred *cred, *next;
Trond Myklebustd2b83142008-04-14 18:13:37 -0400482 unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM;
Dave Chinner70534a72013-08-28 10:18:14 +1000483 long freed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Trond Myklebusteac0d182008-10-28 15:21:41 -0400485 list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) {
486
Trond Myklebust20673402010-05-13 12:51:06 -0400487 if (nr_to_scan-- == 0)
488 break;
Trond Myklebust79b18182018-10-14 10:34:31 -0400489 if (refcount_read(&cred->cr_count) > 1) {
Trond Myklebust95cd6232018-10-11 16:11:09 -0400490 rpcauth_lru_remove_locked(cred);
491 continue;
492 }
Trond Myklebust93a05e62010-05-13 12:51:06 -0400493 /*
494 * Enforce a 60 second garbage collection moratorium
495 * Note that the cred_unused list must be time-ordered.
496 */
Trond Myklebust95cd6232018-10-11 16:11:09 -0400497 if (!time_in_range(cred->cr_expire, expired, jiffies))
498 continue;
499 if (!rpcauth_unhash_cred(cred))
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400500 continue;
Trond Myklebusteac0d182008-10-28 15:21:41 -0400501
Trond Myklebust95cd6232018-10-11 16:11:09 -0400502 rpcauth_lru_remove_locked(cred);
503 freed++;
504 list_add_tail(&cred->cr_lru, free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 }
Trond Myklebust95cd6232018-10-11 16:11:09 -0400506 return freed ? freed : SHRINK_STOP;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400507}
508
Trond Myklebustbae67462014-07-21 13:32:42 -0400509static unsigned long
510rpcauth_cache_do_shrink(int nr_to_scan)
511{
512 LIST_HEAD(free);
513 unsigned long freed;
514
515 spin_lock(&rpc_credcache_lock);
516 freed = rpcauth_prune_expired(&free, nr_to_scan);
517 spin_unlock(&rpc_credcache_lock);
518 rpcauth_destroy_credlist(&free);
519
520 return freed;
521}
522
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400523/*
Trond Myklebustf5c21872007-06-25 17:11:20 -0400524 * Run memory cache shrinker.
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400525 */
Dave Chinner70534a72013-08-28 10:18:14 +1000526static unsigned long
527rpcauth_cache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
528
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400529{
Dave Chinner70534a72013-08-28 10:18:14 +1000530 if ((sc->gfp_mask & GFP_KERNEL) != GFP_KERNEL)
531 return SHRINK_STOP;
532
533 /* nothing left, don't come back */
Trond Myklebustf5c21872007-06-25 17:11:20 -0400534 if (list_empty(&cred_unused))
Dave Chinner70534a72013-08-28 10:18:14 +1000535 return SHRINK_STOP;
536
Trond Myklebustbae67462014-07-21 13:32:42 -0400537 return rpcauth_cache_do_shrink(sc->nr_to_scan);
Dave Chinner70534a72013-08-28 10:18:14 +1000538}
539
540static unsigned long
541rpcauth_cache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
542
543{
NeilBrown4c3ffd02017-01-06 14:19:58 +1100544 return number_cred_unused * sysctl_vfs_cache_pressure / 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545}
546
Trond Myklebustbae67462014-07-21 13:32:42 -0400547static void
548rpcauth_cache_enforce_limit(void)
549{
550 unsigned long diff;
551 unsigned int nr_to_scan;
552
553 if (number_cred_unused <= auth_max_cred_cachesize)
554 return;
555 diff = number_cred_unused - auth_max_cred_cachesize;
556 nr_to_scan = 100;
557 if (diff < nr_to_scan)
558 nr_to_scan = diff;
559 rpcauth_cache_do_shrink(nr_to_scan);
560}
561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562/*
563 * Look up a process' credentials in the authentication cache
564 */
565struct rpc_cred *
566rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred,
Jeff Layton3c6e0bc2016-04-21 20:51:54 -0400567 int flags, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400569 LIST_HEAD(free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 struct rpc_cred_cache *cache = auth->au_credcache;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400571 struct rpc_cred *cred = NULL,
572 *entry, *new;
Trond Myklebust25337fd2008-03-12 14:40:14 -0400573 unsigned int nr;
574
Frank Sorenson66cbd4b2016-09-29 10:44:41 -0500575 nr = auth->au_ops->hash_cred(acred, cache->hashbits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400577 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800578 hlist_for_each_entry_rcu(entry, &cache->hashtable[nr], cr_hash) {
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400579 if (!entry->cr_ops->crmatch(acred, entry, flags))
580 continue;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400581 cred = get_rpccred(entry);
Trond Myklebust07d02a62018-10-12 13:28:26 -0400582 if (cred)
583 break;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400584 }
585 rcu_read_unlock();
586
Trond Myklebust9499b432007-06-24 15:57:57 -0400587 if (cred != NULL)
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400588 goto found;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400589
Jeff Layton3c6e0bc2016-04-21 20:51:54 -0400590 new = auth->au_ops->crcreate(auth, acred, flags, gfp);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400591 if (IS_ERR(new)) {
592 cred = new;
593 goto out;
594 }
595
Trond Myklebust9499b432007-06-24 15:57:57 -0400596 spin_lock(&cache->lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800597 hlist_for_each_entry(entry, &cache->hashtable[nr], cr_hash) {
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400598 if (!entry->cr_ops->crmatch(acred, entry, flags))
599 continue;
600 cred = get_rpccred(entry);
Trond Myklebust07d02a62018-10-12 13:28:26 -0400601 if (cred)
602 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 }
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400604 if (cred == NULL) {
Trond Myklebust5fe47552007-06-23 19:55:31 -0400605 cred = new;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400606 set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);
Trond Myklebust79b18182018-10-14 10:34:31 -0400607 refcount_inc(&cred->cr_count);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400608 hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]);
609 } else
610 list_add_tail(&new->cr_lru, &free);
Trond Myklebust9499b432007-06-24 15:57:57 -0400611 spin_unlock(&cache->lock);
Trond Myklebustbae67462014-07-21 13:32:42 -0400612 rpcauth_cache_enforce_limit();
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400613found:
Joe Perchesf64f9e72009-11-29 16:55:45 -0800614 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
615 cred->cr_ops->cr_init != NULL &&
616 !(flags & RPCAUTH_LOOKUP_NEW)) {
Trond Myklebustfba3bad2006-02-01 12:19:27 -0500617 int res = cred->cr_ops->cr_init(auth, cred);
618 if (res < 0) {
619 put_rpccred(cred);
620 cred = ERR_PTR(res);
621 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 }
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400623 rpcauth_destroy_credlist(&free);
624out:
625 return cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400627EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629struct rpc_cred *
Trond Myklebust8a317762006-02-01 12:18:36 -0500630rpcauth_lookupcred(struct rpc_auth *auth, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
David Howells86a264a2008-11-14 10:39:18 +1100632 struct auth_cred acred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 struct rpc_cred *ret;
David Howells86a264a2008-11-14 10:39:18 +1100634 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Chuck Lever46121cf2007-01-31 12:14:08 -0500636 dprintk("RPC: looking up %s cred\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 auth->au_ops->au_name);
David Howells86a264a2008-11-14 10:39:18 +1100638
639 memset(&acred, 0, sizeof(acred));
NeilBrown97f68c6b2018-12-03 11:30:30 +1100640 acred.cred = cred;
Trond Myklebust8a317762006-02-01 12:18:36 -0500641 ret = auth->au_ops->lookup_cred(auth, &acred, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return ret;
643}
Andy Adamson66b06862014-06-12 15:02:32 -0400644EXPORT_SYMBOL_GPL(rpcauth_lookupcred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
Trond Myklebust5fe47552007-06-23 19:55:31 -0400646void
647rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,
648 struct rpc_auth *auth, const struct rpc_credops *ops)
649{
650 INIT_HLIST_NODE(&cred->cr_hash);
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400651 INIT_LIST_HEAD(&cred->cr_lru);
Trond Myklebust79b18182018-10-14 10:34:31 -0400652 refcount_set(&cred->cr_count, 1);
Trond Myklebust5fe47552007-06-23 19:55:31 -0400653 cred->cr_auth = auth;
654 cred->cr_ops = ops;
655 cred->cr_expire = jiffies;
NeilBrown97f68c6b2018-12-03 11:30:30 +1100656 cred->cr_cred = get_cred(acred->cred);
NeilBrown8276c902018-12-03 11:30:30 +1100657 cred->cr_uid = acred->cred->fsuid;
Trond Myklebust5fe47552007-06-23 19:55:31 -0400658}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400659EXPORT_SYMBOL_GPL(rpcauth_init_cred);
Trond Myklebust5fe47552007-06-23 19:55:31 -0400660
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400661struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400662rpcauth_generic_bind_cred(struct rpc_task *task, struct rpc_cred *cred, int lookupflags)
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400663{
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400664 dprintk("RPC: %5u holding %s cred %p\n", task->tk_pid,
665 cred->cr_auth->au_ops->au_name, cred);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400666 return get_rpccred(cred);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400667}
Trond Myklebust5c691042008-03-12 16:21:07 -0400668EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400669
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400670static struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400671rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672{
Trond Myklebust1be27f32007-06-27 14:29:04 -0400673 struct rpc_auth *auth = task->tk_client->cl_auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 struct auth_cred acred = {
NeilBrown97f68c6b2018-12-03 11:30:30 +1100675 .cred = get_task_cred(&init_task),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 };
NeilBrown97f68c6b2018-12-03 11:30:30 +1100677 struct rpc_cred *ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Chuck Lever46121cf2007-01-31 12:14:08 -0500679 dprintk("RPC: %5u looking up %s cred\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400680 task->tk_pid, task->tk_client->cl_auth->au_ops->au_name);
NeilBrown97f68c6b2018-12-03 11:30:30 +1100681 ret = auth->au_ops->lookup_cred(auth, &acred, lookupflags);
682 put_cred(acred.cred);
683 return ret;
Trond Myklebustaf093832008-03-12 12:12:16 -0400684}
685
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400686static struct rpc_cred *
NeilBrown5e169232018-12-03 11:30:30 +1100687rpcauth_bind_machine_cred(struct rpc_task *task, int lookupflags)
688{
689 struct rpc_auth *auth = task->tk_client->cl_auth;
690 struct auth_cred acred = {
691 .principal = task->tk_client->cl_principal,
692 .cred = init_task.cred,
693 };
694
695 if (!acred.principal)
696 return NULL;
697 dprintk("RPC: %5u looking up %s machine cred\n",
698 task->tk_pid, task->tk_client->cl_auth->au_ops->au_name);
699 return auth->au_ops->lookup_cred(auth, &acred, lookupflags);
700}
701
702static struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400703rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags)
Trond Myklebustaf093832008-03-12 12:12:16 -0400704{
705 struct rpc_auth *auth = task->tk_client->cl_auth;
Trond Myklebustaf093832008-03-12 12:12:16 -0400706
707 dprintk("RPC: %5u looking up %s cred\n",
708 task->tk_pid, auth->au_ops->au_name);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400709 return rpcauth_lookupcred(auth, lookupflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
711
Trond Myklebusta17c2152010-07-31 14:29:08 -0400712static int
NeilBrowna52458b2018-12-03 11:30:31 +1100713rpcauth_bindcred(struct rpc_task *task, const struct cred *cred, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400715 struct rpc_rqst *req = task->tk_rqstp;
NeilBrown5e169232018-12-03 11:30:30 +1100716 struct rpc_cred *new = NULL;
Trond Myklebust5d351752009-09-15 13:32:13 -0400717 int lookupflags = 0;
NeilBrowna52458b2018-12-03 11:30:31 +1100718 struct rpc_auth *auth = task->tk_client->cl_auth;
719 struct auth_cred acred = {
720 .cred = cred,
721 };
Trond Myklebust5d351752009-09-15 13:32:13 -0400722
723 if (flags & RPC_TASK_ASYNC)
724 lookupflags |= RPCAUTH_LOOKUP_NEW;
NeilBrown1de7eea2018-12-03 11:30:30 +1100725 if (task->tk_op_cred)
726 /* Task must use exactly this rpc_cred */
727 new = task->tk_op_cred->cr_ops->crbind(task, task->tk_op_cred,
728 lookupflags);
729 else if (cred != NULL && cred != &machine_cred)
NeilBrowna52458b2018-12-03 11:30:31 +1100730 new = auth->au_ops->lookup_cred(auth, &acred, lookupflags);
NeilBrown5e169232018-12-03 11:30:30 +1100731 else if (cred == &machine_cred)
732 new = rpcauth_bind_machine_cred(task, lookupflags);
733
734 /* If machine cred couldn't be bound, try a root cred */
735 if (new)
736 ;
737 else if (cred == &machine_cred || (flags & RPC_TASK_ROOTCREDS))
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400738 new = rpcauth_bind_root_cred(task, lookupflags);
NeilBrowna68a72e2018-12-03 11:30:30 +1100739 else if (flags & RPC_TASK_NULLCREDS)
740 new = authnull_ops.lookup_cred(NULL, NULL, 0);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400741 else
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400742 new = rpcauth_bind_new_cred(task, lookupflags);
743 if (IS_ERR(new))
744 return PTR_ERR(new);
Trond Myklebust9a8f6b52016-05-16 17:42:42 -0400745 put_rpccred(req->rq_cred);
Trond Myklebusta17c2152010-07-31 14:29:08 -0400746 req->rq_cred = new;
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400747 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748}
749
750void
751put_rpccred(struct rpc_cred *cred)
752{
Trond Myklebust9a8f6b52016-05-16 17:42:42 -0400753 if (cred == NULL)
754 return;
Trond Myklebust95cd6232018-10-11 16:11:09 -0400755 rcu_read_lock();
Trond Myklebust79b18182018-10-14 10:34:31 -0400756 if (refcount_dec_and_test(&cred->cr_count))
Trond Myklebust95cd6232018-10-11 16:11:09 -0400757 goto destroy;
Trond Myklebust79b18182018-10-14 10:34:31 -0400758 if (refcount_read(&cred->cr_count) != 1 ||
Trond Myklebust95cd6232018-10-11 16:11:09 -0400759 !test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags))
760 goto out;
761 if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0) {
762 cred->cr_expire = jiffies;
763 rpcauth_lru_add(cred);
764 /* Race breaker */
765 if (unlikely(!test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags)))
766 rpcauth_lru_remove(cred);
767 } else if (rpcauth_unhash_cred(cred)) {
768 rpcauth_lru_remove(cred);
Trond Myklebust79b18182018-10-14 10:34:31 -0400769 if (refcount_dec_and_test(&cred->cr_count))
Trond Myklebust95cd6232018-10-11 16:11:09 -0400770 goto destroy;
Trond Myklebustf0380f32009-12-03 08:10:17 -0500771 }
Trond Myklebust95cd6232018-10-11 16:11:09 -0400772out:
773 rcu_read_unlock();
Trond Myklebustf0380f32009-12-03 08:10:17 -0500774 return;
Trond Myklebust95cd6232018-10-11 16:11:09 -0400775destroy:
776 rcu_read_unlock();
777 cred->cr_ops->crdestroy(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400779EXPORT_SYMBOL_GPL(put_rpccred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700781__be32 *
782rpcauth_marshcred(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400784 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Chuck Lever46121cf2007-01-31 12:14:08 -0500786 dprintk("RPC: %5u marshaling %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400787 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 return cred->cr_ops->crmarshal(task, p);
790}
791
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700792__be32 *
793rpcauth_checkverf(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400795 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Chuck Lever46121cf2007-01-31 12:14:08 -0500797 dprintk("RPC: %5u validating %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400798 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 return cred->cr_ops->crvalidate(task, p);
801}
802
Chuck Lever9f06c712010-12-14 14:59:18 +0000803static void rpcauth_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp,
804 __be32 *data, void *obj)
805{
806 struct xdr_stream xdr;
807
808 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, data);
809 encode(rqstp, &xdr, obj);
810}
811
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812int
Chuck Lever9f06c712010-12-14 14:59:18 +0000813rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700814 __be32 *data, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400816 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Chuck Lever46121cf2007-01-31 12:14:08 -0500818 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 task->tk_pid, cred->cr_ops->cr_name, cred);
820 if (cred->cr_ops->crwrap_req)
821 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
822 /* By default, we encode the arguments normally. */
Chuck Lever9f06c712010-12-14 14:59:18 +0000823 rpcauth_wrap_req_encode(encode, rqstp, data, obj);
824 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825}
826
Chuck Leverbf269552010-12-14 14:59:29 +0000827static int
828rpcauth_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp,
829 __be32 *data, void *obj)
830{
831 struct xdr_stream xdr;
832
833 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, data);
834 return decode(rqstp, &xdr, obj);
835}
836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837int
Chuck Leverbf269552010-12-14 14:59:29 +0000838rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700839 __be32 *data, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400841 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Chuck Lever46121cf2007-01-31 12:14:08 -0500843 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 task->tk_pid, cred->cr_ops->cr_name, cred);
845 if (cred->cr_ops->crunwrap_resp)
846 return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
847 data, obj);
848 /* By default, we decode the arguments normally. */
Chuck Leverbf269552010-12-14 14:59:29 +0000849 return rpcauth_unwrap_req_decode(decode, rqstp, data, obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850}
851
Trond Myklebust3021a5bb2018-08-14 13:50:21 -0400852bool
853rpcauth_xmit_need_reencode(struct rpc_task *task)
854{
855 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
856
857 if (!cred || !cred->cr_ops->crneed_reencode)
858 return false;
859 return cred->cr_ops->crneed_reencode(task);
860}
861
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862int
863rpcauth_refreshcred(struct rpc_task *task)
864{
Trond Myklebust9a84d382010-10-24 18:00:46 -0400865 struct rpc_cred *cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 int err;
867
Trond Myklebusta17c2152010-07-31 14:29:08 -0400868 cred = task->tk_rqstp->rq_cred;
869 if (cred == NULL) {
870 err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags);
871 if (err < 0)
872 goto out;
873 cred = task->tk_rqstp->rq_cred;
Joe Perchesf81c6222011-06-03 11:51:19 +0000874 }
Chuck Lever46121cf2007-01-31 12:14:08 -0500875 dprintk("RPC: %5u refreshing %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400876 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500877
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 err = cred->cr_ops->crrefresh(task);
Trond Myklebusta17c2152010-07-31 14:29:08 -0400879out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 if (err < 0)
881 task->tk_status = err;
882 return err;
883}
884
885void
886rpcauth_invalcred(struct rpc_task *task)
887{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400888 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400889
Chuck Lever46121cf2007-01-31 12:14:08 -0500890 dprintk("RPC: %5u invalidating %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400891 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400892 if (cred)
893 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894}
895
896int
897rpcauth_uptodatecred(struct rpc_task *task)
898{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400899 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400900
901 return cred == NULL ||
902 test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903}
Trond Myklebustf5c21872007-06-25 17:11:20 -0400904
Rusty Russell8e1f9362007-07-17 04:03:17 -0700905static struct shrinker rpc_cred_shrinker = {
Dave Chinner70534a72013-08-28 10:18:14 +1000906 .count_objects = rpcauth_cache_shrink_count,
907 .scan_objects = rpcauth_cache_shrink_scan,
Rusty Russell8e1f9362007-07-17 04:03:17 -0700908 .seeks = DEFAULT_SEEKS,
909};
Trond Myklebustf5c21872007-06-25 17:11:20 -0400910
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400911int __init rpcauth_init_module(void)
Trond Myklebustf5c21872007-06-25 17:11:20 -0400912{
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400913 int err;
914
915 err = rpc_init_authunix();
916 if (err < 0)
917 goto out1;
Kinglong Mee28644862017-02-07 21:46:39 +0800918 err = register_shrinker(&rpc_cred_shrinker);
919 if (err < 0)
NeilBrown89a4f752018-12-03 11:30:31 +1100920 goto out2;
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400921 return 0;
922out2:
923 rpc_destroy_authunix();
924out1:
925 return err;
Trond Myklebustf5c21872007-06-25 17:11:20 -0400926}
927
Stephen Rothwellc135e842010-09-29 14:16:57 +1000928void rpcauth_remove_module(void)
Trond Myklebustf5c21872007-06-25 17:11:20 -0400929{
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400930 rpc_destroy_authunix();
Rusty Russell8e1f9362007-07-17 04:03:17 -0700931 unregister_shrinker(&rpc_cred_shrinker);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400932}