blob: 696eb39fc1cb44978c27b47d20775eb2ceac4ba8 [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>
11#include <linux/module.h>
12#include <linux/slab.h>
13#include <linux/errno.h>
Trond Myklebust25337fd2008-03-12 14:40:14 -040014#include <linux/hash.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/sunrpc/clnt.h>
Chuck Lever6a1a1e32012-07-11 16:31:08 -040016#include <linux/sunrpc/gss_api.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/spinlock.h>
18
Jeff Laytonf895b252014-11-17 16:58:04 -050019#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Linus Torvalds1da177e2005-04-16 15:20:36 -070020# define RPCDBG_FACILITY RPCDBG_AUTH
21#endif
22
Trond Myklebust241269b2010-07-31 14:29:08 -040023#define RPC_CREDCACHE_DEFAULT_HASHBITS (4)
24struct rpc_cred_cache {
25 struct hlist_head *hashtable;
26 unsigned int hashbits;
27 spinlock_t lock;
28};
29
30static unsigned int auth_hashbits = RPC_CREDCACHE_DEFAULT_HASHBITS;
31
Trond Myklebustfc1b3562007-06-09 16:15:46 -040032static DEFINE_SPINLOCK(rpc_authflavor_lock);
Trond Myklebustf1c0a862007-06-23 20:17:58 -040033static const struct rpc_authops *auth_flavors[RPC_AUTH_MAXFLAVOR] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 &authnull_ops, /* AUTH_NULL */
35 &authunix_ops, /* AUTH_UNIX */
36 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
Miquel van Smoorenburgdb5fe262010-09-12 19:55:26 -040042#define MAX_HASHTABLE_BITS (14)
Stephen Rothwell8e4e15d2010-08-04 12:11:22 +100043static int param_set_hashtbl_sz(const char *val, const struct kernel_param *kp)
Trond Myklebust241269b2010-07-31 14:29:08 -040044{
45 unsigned long num;
46 unsigned int nbits;
47 int ret;
48
49 if (!val)
50 goto out_inval;
Daniel Walter00cfaa92014-06-21 13:06:38 +010051 ret = kstrtoul(val, 0, &num);
Trond Myklebust241269b2010-07-31 14:29:08 -040052 if (ret == -EINVAL)
53 goto out_inval;
54 nbits = fls(num);
55 if (num > (1U << nbits))
56 nbits++;
57 if (nbits > MAX_HASHTABLE_BITS || nbits < 2)
58 goto out_inval;
59 *(unsigned int *)kp->arg = nbits;
60 return 0;
61out_inval:
62 return -EINVAL;
63}
64
Stephen Rothwell8e4e15d2010-08-04 12:11:22 +100065static int param_get_hashtbl_sz(char *buffer, const struct kernel_param *kp)
Trond Myklebust241269b2010-07-31 14:29:08 -040066{
67 unsigned int nbits;
68
69 nbits = *(unsigned int *)kp->arg;
70 return sprintf(buffer, "%u", 1U << nbits);
71}
72
73#define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int);
74
Luis R. Rodriguez9c278472015-05-27 11:09:38 +093075static const struct kernel_param_ops param_ops_hashtbl_sz = {
Stephen Rothwell8e4e15d2010-08-04 12:11:22 +100076 .set = param_set_hashtbl_sz,
77 .get = param_get_hashtbl_sz,
78};
79
Trond Myklebust241269b2010-07-31 14:29:08 -040080module_param_named(auth_hashtable_size, auth_hashbits, hashtbl_sz, 0644);
81MODULE_PARM_DESC(auth_hashtable_size, "RPC credential cache hashtable size");
82
Trond Myklebustbae67462014-07-21 13:32:42 -040083static unsigned long auth_max_cred_cachesize = ULONG_MAX;
84module_param(auth_max_cred_cachesize, ulong, 0644);
85MODULE_PARM_DESC(auth_max_cred_cachesize, "RPC credential maximum total cache size");
86
Linus Torvalds1da177e2005-04-16 15:20:36 -070087static u32
88pseudoflavor_to_flavor(u32 flavor) {
Chuck Lever1c74a242013-03-22 12:53:08 -040089 if (flavor > RPC_AUTH_MAXFLAVOR)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 return RPC_AUTH_GSS;
91 return flavor;
92}
93
94int
Trond Myklebustf1c0a862007-06-23 20:17:58 -040095rpcauth_register(const struct rpc_authops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096{
97 rpc_authflavor_t flavor;
Trond Myklebustfc1b3562007-06-09 16:15:46 -040098 int ret = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100 if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR)
101 return -EINVAL;
Trond Myklebustfc1b3562007-06-09 16:15:46 -0400102 spin_lock(&rpc_authflavor_lock);
103 if (auth_flavors[flavor] == NULL) {
104 auth_flavors[flavor] = ops;
105 ret = 0;
106 }
107 spin_unlock(&rpc_authflavor_lock);
108 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400110EXPORT_SYMBOL_GPL(rpcauth_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
112int
Trond Myklebustf1c0a862007-06-23 20:17:58 -0400113rpcauth_unregister(const struct rpc_authops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
115 rpc_authflavor_t flavor;
Trond Myklebustfc1b3562007-06-09 16:15:46 -0400116 int ret = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118 if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR)
119 return -EINVAL;
Trond Myklebustfc1b3562007-06-09 16:15:46 -0400120 spin_lock(&rpc_authflavor_lock);
121 if (auth_flavors[flavor] == ops) {
122 auth_flavors[flavor] = NULL;
123 ret = 0;
124 }
125 spin_unlock(&rpc_authflavor_lock);
126 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400128EXPORT_SYMBOL_GPL(rpcauth_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
Chuck Lever6a1a1e32012-07-11 16:31:08 -0400130/**
Chuck Lever9568c5e2013-03-16 15:54:43 -0400131 * rpcauth_get_pseudoflavor - check if security flavor is supported
132 * @flavor: a security flavor
133 * @info: a GSS mech OID, quality of protection, and service value
134 *
135 * Verifies that an appropriate kernel module is available or already loaded.
136 * Returns an equivalent pseudoflavor, or RPC_AUTH_MAXFLAVOR if "flavor" is
137 * not supported locally.
138 */
139rpc_authflavor_t
140rpcauth_get_pseudoflavor(rpc_authflavor_t flavor, struct rpcsec_gss_info *info)
141{
142 const struct rpc_authops *ops;
143 rpc_authflavor_t pseudoflavor;
144
145 ops = auth_flavors[flavor];
146 if (ops == NULL)
147 request_module("rpc-auth-%u", flavor);
148 spin_lock(&rpc_authflavor_lock);
149 ops = auth_flavors[flavor];
150 if (ops == NULL || !try_module_get(ops->owner)) {
151 spin_unlock(&rpc_authflavor_lock);
152 return RPC_AUTH_MAXFLAVOR;
153 }
154 spin_unlock(&rpc_authflavor_lock);
155
156 pseudoflavor = flavor;
157 if (ops->info2flavor != NULL)
158 pseudoflavor = ops->info2flavor(info);
159
160 module_put(ops->owner);
161 return pseudoflavor;
162}
163EXPORT_SYMBOL_GPL(rpcauth_get_pseudoflavor);
164
165/**
Chuck Levera77c8062013-03-16 15:55:10 -0400166 * rpcauth_get_gssinfo - find GSS tuple matching a GSS pseudoflavor
167 * @pseudoflavor: GSS pseudoflavor to match
168 * @info: rpcsec_gss_info structure to fill in
169 *
170 * Returns zero and fills in "info" if pseudoflavor matches a
171 * supported mechanism.
172 */
173int
174rpcauth_get_gssinfo(rpc_authflavor_t pseudoflavor, struct rpcsec_gss_info *info)
175{
176 rpc_authflavor_t flavor = pseudoflavor_to_flavor(pseudoflavor);
177 const struct rpc_authops *ops;
178 int result;
179
Chuck Lever1c74a242013-03-22 12:53:08 -0400180 if (flavor >= RPC_AUTH_MAXFLAVOR)
181 return -EINVAL;
182
Chuck Levera77c8062013-03-16 15:55:10 -0400183 ops = auth_flavors[flavor];
184 if (ops == NULL)
185 request_module("rpc-auth-%u", flavor);
186 spin_lock(&rpc_authflavor_lock);
187 ops = auth_flavors[flavor];
188 if (ops == NULL || !try_module_get(ops->owner)) {
189 spin_unlock(&rpc_authflavor_lock);
190 return -ENOENT;
191 }
192 spin_unlock(&rpc_authflavor_lock);
193
194 result = -ENOENT;
195 if (ops->flavor2info != NULL)
196 result = ops->flavor2info(pseudoflavor, info);
197
198 module_put(ops->owner);
199 return result;
200}
201EXPORT_SYMBOL_GPL(rpcauth_get_gssinfo);
202
203/**
Chuck Lever6a1a1e32012-07-11 16:31:08 -0400204 * rpcauth_list_flavors - discover registered flavors and pseudoflavors
205 * @array: array to fill in
206 * @size: size of "array"
207 *
208 * Returns the number of array items filled in, or a negative errno.
209 *
210 * The returned array is not sorted by any policy. Callers should not
211 * rely on the order of the items in the returned array.
212 */
213int
214rpcauth_list_flavors(rpc_authflavor_t *array, int size)
215{
216 rpc_authflavor_t flavor;
217 int result = 0;
218
219 spin_lock(&rpc_authflavor_lock);
220 for (flavor = 0; flavor < RPC_AUTH_MAXFLAVOR; flavor++) {
221 const struct rpc_authops *ops = auth_flavors[flavor];
222 rpc_authflavor_t pseudos[4];
223 int i, len;
224
225 if (result >= size) {
226 result = -ENOMEM;
227 break;
228 }
229
230 if (ops == NULL)
231 continue;
232 if (ops->list_pseudoflavors == NULL) {
233 array[result++] = ops->au_flavor;
234 continue;
235 }
236 len = ops->list_pseudoflavors(pseudos, ARRAY_SIZE(pseudos));
237 if (len < 0) {
238 result = len;
239 break;
240 }
241 for (i = 0; i < len; i++) {
242 if (result >= size) {
243 result = -ENOMEM;
244 break;
245 }
246 array[result++] = pseudos[i];
247 }
248 }
249 spin_unlock(&rpc_authflavor_lock);
250
251 dprintk("RPC: %s returns %d\n", __func__, result);
252 return result;
253}
254EXPORT_SYMBOL_GPL(rpcauth_list_flavors);
255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256struct rpc_auth *
Trond Myklebustc2190662013-08-26 19:23:04 -0400257rpcauth_create(struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258{
259 struct rpc_auth *auth;
Trond Myklebustf1c0a862007-06-23 20:17:58 -0400260 const struct rpc_authops *ops;
Trond Myklebustc2190662013-08-26 19:23:04 -0400261 u32 flavor = pseudoflavor_to_flavor(args->pseudoflavor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Olaf Kirchf344f6d2006-03-20 13:44:08 -0500263 auth = ERR_PTR(-EINVAL);
264 if (flavor >= RPC_AUTH_MAXFLAVOR)
265 goto out;
266
Olaf Kirchf344f6d2006-03-20 13:44:08 -0500267 if ((ops = auth_flavors[flavor]) == NULL)
268 request_module("rpc-auth-%u", flavor);
Trond Myklebustfc1b3562007-06-09 16:15:46 -0400269 spin_lock(&rpc_authflavor_lock);
270 ops = auth_flavors[flavor];
271 if (ops == NULL || !try_module_get(ops->owner)) {
272 spin_unlock(&rpc_authflavor_lock);
Olaf Kirchf344f6d2006-03-20 13:44:08 -0500273 goto out;
Trond Myklebustfc1b3562007-06-09 16:15:46 -0400274 }
275 spin_unlock(&rpc_authflavor_lock);
Trond Myklebustc2190662013-08-26 19:23:04 -0400276 auth = ops->create(args, clnt);
Trond Myklebustfc1b3562007-06-09 16:15:46 -0400277 module_put(ops->owner);
J. Bruce Fields6a192752005-06-22 17:16:23 +0000278 if (IS_ERR(auth))
279 return auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 if (clnt->cl_auth)
Trond Myklebustde7a8ce2007-06-23 10:46:47 -0400281 rpcauth_release(clnt->cl_auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 clnt->cl_auth = auth;
Olaf Kirchf344f6d2006-03-20 13:44:08 -0500283
284out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return auth;
286}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400287EXPORT_SYMBOL_GPL(rpcauth_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289void
Trond Myklebustde7a8ce2007-06-23 10:46:47 -0400290rpcauth_release(struct rpc_auth *auth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291{
292 if (!atomic_dec_and_test(&auth->au_count))
293 return;
294 auth->au_ops->destroy(auth);
295}
296
297static DEFINE_SPINLOCK(rpc_credcache_lock);
298
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400299static void
300rpcauth_unhash_cred_locked(struct rpc_cred *cred)
301{
302 hlist_del_rcu(&cred->cr_hash);
Peter Zijlstra4e857c52014-03-17 18:06:10 +0100303 smp_mb__before_atomic();
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400304 clear_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);
305}
306
Trond Myklebustf0380f32009-12-03 08:10:17 -0500307static int
Trond Myklebust9499b432007-06-24 15:57:57 -0400308rpcauth_unhash_cred(struct rpc_cred *cred)
309{
310 spinlock_t *cache_lock;
Trond Myklebustf0380f32009-12-03 08:10:17 -0500311 int ret;
Trond Myklebust9499b432007-06-24 15:57:57 -0400312
313 cache_lock = &cred->cr_auth->au_credcache->lock;
314 spin_lock(cache_lock);
Trond Myklebustf0380f32009-12-03 08:10:17 -0500315 ret = atomic_read(&cred->cr_count) == 0;
316 if (ret)
Trond Myklebust9499b432007-06-24 15:57:57 -0400317 rpcauth_unhash_cred_locked(cred);
318 spin_unlock(cache_lock);
Trond Myklebustf0380f32009-12-03 08:10:17 -0500319 return ret;
Trond Myklebust9499b432007-06-24 15:57:57 -0400320}
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322/*
323 * Initialize RPC credential cache
324 */
325int
Trond Myklebustf5c21872007-06-25 17:11:20 -0400326rpcauth_init_credcache(struct rpc_auth *auth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
328 struct rpc_cred_cache *new;
Trond Myklebust988664a2010-07-31 14:29:07 -0400329 unsigned int hashsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
Kris Katterjohn8b3a7002006-01-11 15:56:43 -0800331 new = kmalloc(sizeof(*new), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 if (!new)
Trond Myklebust241269b2010-07-31 14:29:08 -0400333 goto out_nocache;
334 new->hashbits = auth_hashbits;
Trond Myklebust988664a2010-07-31 14:29:07 -0400335 hashsize = 1U << new->hashbits;
Trond Myklebust241269b2010-07-31 14:29:08 -0400336 new->hashtable = kcalloc(hashsize, sizeof(new->hashtable[0]), GFP_KERNEL);
337 if (!new->hashtable)
338 goto out_nohashtbl;
Trond Myklebust9499b432007-06-24 15:57:57 -0400339 spin_lock_init(&new->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 auth->au_credcache = new;
341 return 0;
Trond Myklebust241269b2010-07-31 14:29:08 -0400342out_nohashtbl:
343 kfree(new);
344out_nocache:
345 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400347EXPORT_SYMBOL_GPL(rpcauth_init_credcache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349/*
Andy Adamson4de6caa2013-08-14 11:59:15 -0400350 * Setup a credential key lifetime timeout notification
351 */
352int
353rpcauth_key_timeout_notify(struct rpc_auth *auth, struct rpc_cred *cred)
354{
355 if (!cred->cr_auth->au_ops->key_timeout)
356 return 0;
357 return cred->cr_auth->au_ops->key_timeout(auth, cred);
358}
359EXPORT_SYMBOL_GPL(rpcauth_key_timeout_notify);
360
361bool
Scott Mayhewce52914e2016-06-07 15:14:48 -0400362rpcauth_cred_key_to_expire(struct rpc_auth *auth, struct rpc_cred *cred)
Andy Adamson4de6caa2013-08-14 11:59:15 -0400363{
Scott Mayhewce52914e2016-06-07 15:14:48 -0400364 if (auth->au_flags & RPCAUTH_AUTH_NO_CRKEY_TIMEOUT)
365 return false;
Andy Adamson4de6caa2013-08-14 11:59:15 -0400366 if (!cred->cr_ops->crkey_to_expire)
367 return false;
368 return cred->cr_ops->crkey_to_expire(cred);
369}
370EXPORT_SYMBOL_GPL(rpcauth_cred_key_to_expire);
371
Jeff Laytona0337d12014-06-21 20:52:16 -0400372char *
373rpcauth_stringify_acceptor(struct rpc_cred *cred)
374{
375 if (!cred->cr_ops->crstringify_acceptor)
376 return NULL;
377 return cred->cr_ops->crstringify_acceptor(cred);
378}
379EXPORT_SYMBOL_GPL(rpcauth_stringify_acceptor);
380
Andy Adamson4de6caa2013-08-14 11:59:15 -0400381/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 * Destroy a list of credentials
383 */
384static inline
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400385void rpcauth_destroy_credlist(struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
387 struct rpc_cred *cred;
388
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400389 while (!list_empty(head)) {
390 cred = list_entry(head->next, struct rpc_cred, cr_lru);
391 list_del_init(&cred->cr_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 put_rpccred(cred);
393 }
394}
395
396/*
397 * Clear the RPC credential cache, and delete those credentials
398 * that are not referenced.
399 */
400void
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400401rpcauth_clear_credcache(struct rpc_cred_cache *cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402{
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400403 LIST_HEAD(free);
404 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 struct rpc_cred *cred;
Trond Myklebust988664a2010-07-31 14:29:07 -0400406 unsigned int hashsize = 1U << cache->hashbits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 int i;
408
409 spin_lock(&rpc_credcache_lock);
Trond Myklebust9499b432007-06-24 15:57:57 -0400410 spin_lock(&cache->lock);
Trond Myklebust988664a2010-07-31 14:29:07 -0400411 for (i = 0; i < hashsize; i++) {
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400412 head = &cache->hashtable[i];
413 while (!hlist_empty(head)) {
414 cred = hlist_entry(head->first, struct rpc_cred, cr_hash);
415 get_rpccred(cred);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400416 if (!list_empty(&cred->cr_lru)) {
417 list_del(&cred->cr_lru);
418 number_cred_unused--;
419 }
420 list_add_tail(&cred->cr_lru, &free);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400421 rpcauth_unhash_cred_locked(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
423 }
Trond Myklebust9499b432007-06-24 15:57:57 -0400424 spin_unlock(&cache->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 spin_unlock(&rpc_credcache_lock);
426 rpcauth_destroy_credlist(&free);
427}
428
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400429/*
430 * Destroy the RPC credential cache
431 */
432void
433rpcauth_destroy_credcache(struct rpc_auth *auth)
434{
435 struct rpc_cred_cache *cache = auth->au_credcache;
436
437 if (cache) {
438 auth->au_credcache = NULL;
439 rpcauth_clear_credcache(cache);
Trond Myklebust241269b2010-07-31 14:29:08 -0400440 kfree(cache->hashtable);
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400441 kfree(cache);
442 }
443}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400444EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache);
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400445
Trond Myklebustd2b83142008-04-14 18:13:37 -0400446
447#define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ)
448
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449/*
450 * Remove stale credentials. Avoid sleeping inside the loop.
451 */
Dave Chinner70534a72013-08-28 10:18:14 +1000452static long
Trond Myklebustf5c21872007-06-25 17:11:20 -0400453rpcauth_prune_expired(struct list_head *free, int nr_to_scan)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454{
Trond Myklebust9499b432007-06-24 15:57:57 -0400455 spinlock_t *cache_lock;
Trond Myklebusteac0d182008-10-28 15:21:41 -0400456 struct rpc_cred *cred, *next;
Trond Myklebustd2b83142008-04-14 18:13:37 -0400457 unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM;
Dave Chinner70534a72013-08-28 10:18:14 +1000458 long freed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Trond Myklebusteac0d182008-10-28 15:21:41 -0400460 list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) {
461
Trond Myklebust20673402010-05-13 12:51:06 -0400462 if (nr_to_scan-- == 0)
463 break;
Trond Myklebust93a05e62010-05-13 12:51:06 -0400464 /*
465 * Enforce a 60 second garbage collection moratorium
466 * Note that the cred_unused list must be time-ordered.
467 */
Trond Myklebust3d7b0892010-04-22 15:35:55 -0400468 if (time_in_range(cred->cr_expire, expired, jiffies) &&
Trond Myklebusteac0d182008-10-28 15:21:41 -0400469 test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0)
Dave Chinner70534a72013-08-28 10:18:14 +1000470 break;
Trond Myklebusteac0d182008-10-28 15:21:41 -0400471
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400472 list_del_init(&cred->cr_lru);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400473 number_cred_unused--;
Dave Chinner70534a72013-08-28 10:18:14 +1000474 freed++;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400475 if (atomic_read(&cred->cr_count) != 0)
476 continue;
Trond Myklebusteac0d182008-10-28 15:21:41 -0400477
Trond Myklebust9499b432007-06-24 15:57:57 -0400478 cache_lock = &cred->cr_auth->au_credcache->lock;
479 spin_lock(cache_lock);
480 if (atomic_read(&cred->cr_count) == 0) {
481 get_rpccred(cred);
482 list_add_tail(&cred->cr_lru, free);
483 rpcauth_unhash_cred_locked(cred);
484 }
485 spin_unlock(cache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 }
Dave Chinner70534a72013-08-28 10:18:14 +1000487 return freed;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400488}
489
Trond Myklebustbae67462014-07-21 13:32:42 -0400490static unsigned long
491rpcauth_cache_do_shrink(int nr_to_scan)
492{
493 LIST_HEAD(free);
494 unsigned long freed;
495
496 spin_lock(&rpc_credcache_lock);
497 freed = rpcauth_prune_expired(&free, nr_to_scan);
498 spin_unlock(&rpc_credcache_lock);
499 rpcauth_destroy_credlist(&free);
500
501 return freed;
502}
503
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400504/*
Trond Myklebustf5c21872007-06-25 17:11:20 -0400505 * Run memory cache shrinker.
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400506 */
Dave Chinner70534a72013-08-28 10:18:14 +1000507static unsigned long
508rpcauth_cache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
509
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400510{
Dave Chinner70534a72013-08-28 10:18:14 +1000511 if ((sc->gfp_mask & GFP_KERNEL) != GFP_KERNEL)
512 return SHRINK_STOP;
513
514 /* nothing left, don't come back */
Trond Myklebustf5c21872007-06-25 17:11:20 -0400515 if (list_empty(&cred_unused))
Dave Chinner70534a72013-08-28 10:18:14 +1000516 return SHRINK_STOP;
517
Trond Myklebustbae67462014-07-21 13:32:42 -0400518 return rpcauth_cache_do_shrink(sc->nr_to_scan);
Dave Chinner70534a72013-08-28 10:18:14 +1000519}
520
521static unsigned long
522rpcauth_cache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
523
524{
525 return (number_cred_unused / 100) * sysctl_vfs_cache_pressure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526}
527
Trond Myklebustbae67462014-07-21 13:32:42 -0400528static void
529rpcauth_cache_enforce_limit(void)
530{
531 unsigned long diff;
532 unsigned int nr_to_scan;
533
534 if (number_cred_unused <= auth_max_cred_cachesize)
535 return;
536 diff = number_cred_unused - auth_max_cred_cachesize;
537 nr_to_scan = 100;
538 if (diff < nr_to_scan)
539 nr_to_scan = diff;
540 rpcauth_cache_do_shrink(nr_to_scan);
541}
542
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543/*
544 * Look up a process' credentials in the authentication cache
545 */
546struct rpc_cred *
547rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred,
Jeff Layton3c6e0bc2016-04-21 20:51:54 -0400548 int flags, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549{
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400550 LIST_HEAD(free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 struct rpc_cred_cache *cache = auth->au_credcache;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400552 struct rpc_cred *cred = NULL,
553 *entry, *new;
Trond Myklebust25337fd2008-03-12 14:40:14 -0400554 unsigned int nr;
555
Eric W. Biederman9e469e32013-02-02 01:57:30 -0800556 nr = hash_long(from_kuid(&init_user_ns, acred->uid), cache->hashbits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400558 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800559 hlist_for_each_entry_rcu(entry, &cache->hashtable[nr], cr_hash) {
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400560 if (!entry->cr_ops->crmatch(acred, entry, flags))
561 continue;
NeilBrownbd956082014-07-14 11:28:20 +1000562 if (flags & RPCAUTH_LOOKUP_RCU) {
563 if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) &&
564 !test_bit(RPCAUTH_CRED_NEW, &entry->cr_flags))
565 cred = entry;
566 break;
567 }
Trond Myklebust9499b432007-06-24 15:57:57 -0400568 spin_lock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400569 if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) == 0) {
Trond Myklebust9499b432007-06-24 15:57:57 -0400570 spin_unlock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400571 continue;
572 }
573 cred = get_rpccred(entry);
Trond Myklebust9499b432007-06-24 15:57:57 -0400574 spin_unlock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400575 break;
576 }
577 rcu_read_unlock();
578
Trond Myklebust9499b432007-06-24 15:57:57 -0400579 if (cred != NULL)
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400580 goto found;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400581
NeilBrownbd956082014-07-14 11:28:20 +1000582 if (flags & RPCAUTH_LOOKUP_RCU)
583 return ERR_PTR(-ECHILD);
584
Jeff Layton3c6e0bc2016-04-21 20:51:54 -0400585 new = auth->au_ops->crcreate(auth, acred, flags, gfp);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400586 if (IS_ERR(new)) {
587 cred = new;
588 goto out;
589 }
590
Trond Myklebust9499b432007-06-24 15:57:57 -0400591 spin_lock(&cache->lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800592 hlist_for_each_entry(entry, &cache->hashtable[nr], cr_hash) {
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400593 if (!entry->cr_ops->crmatch(acred, entry, flags))
594 continue;
595 cred = get_rpccred(entry);
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400596 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 }
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400598 if (cred == NULL) {
Trond Myklebust5fe47552007-06-23 19:55:31 -0400599 cred = new;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400600 set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);
601 hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]);
602 } else
603 list_add_tail(&new->cr_lru, &free);
Trond Myklebust9499b432007-06-24 15:57:57 -0400604 spin_unlock(&cache->lock);
Trond Myklebustbae67462014-07-21 13:32:42 -0400605 rpcauth_cache_enforce_limit();
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400606found:
Joe Perchesf64f9e72009-11-29 16:55:45 -0800607 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
608 cred->cr_ops->cr_init != NULL &&
609 !(flags & RPCAUTH_LOOKUP_NEW)) {
Trond Myklebustfba3bad2006-02-01 12:19:27 -0500610 int res = cred->cr_ops->cr_init(auth, cred);
611 if (res < 0) {
612 put_rpccred(cred);
613 cred = ERR_PTR(res);
614 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 }
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400616 rpcauth_destroy_credlist(&free);
617out:
618 return cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400620EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
622struct rpc_cred *
Trond Myklebust8a317762006-02-01 12:18:36 -0500623rpcauth_lookupcred(struct rpc_auth *auth, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624{
David Howells86a264a2008-11-14 10:39:18 +1100625 struct auth_cred acred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 struct rpc_cred *ret;
David Howells86a264a2008-11-14 10:39:18 +1100627 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
Chuck Lever46121cf2007-01-31 12:14:08 -0500629 dprintk("RPC: looking up %s cred\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 auth->au_ops->au_name);
David Howells86a264a2008-11-14 10:39:18 +1100631
632 memset(&acred, 0, sizeof(acred));
633 acred.uid = cred->fsuid;
634 acred.gid = cred->fsgid;
NeilBrown122a8cd2014-08-04 16:24:00 +1000635 acred.group_info = cred->group_info;
Trond Myklebust8a317762006-02-01 12:18:36 -0500636 ret = auth->au_ops->lookup_cred(auth, &acred, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 return ret;
638}
Andy Adamson66b06862014-06-12 15:02:32 -0400639EXPORT_SYMBOL_GPL(rpcauth_lookupcred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
Trond Myklebust5fe47552007-06-23 19:55:31 -0400641void
642rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,
643 struct rpc_auth *auth, const struct rpc_credops *ops)
644{
645 INIT_HLIST_NODE(&cred->cr_hash);
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400646 INIT_LIST_HEAD(&cred->cr_lru);
Trond Myklebust5fe47552007-06-23 19:55:31 -0400647 atomic_set(&cred->cr_count, 1);
648 cred->cr_auth = auth;
649 cred->cr_ops = ops;
650 cred->cr_expire = jiffies;
Jeff Laytonf895b252014-11-17 16:58:04 -0500651#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Trond Myklebust5fe47552007-06-23 19:55:31 -0400652 cred->cr_magic = RPCAUTH_CRED_MAGIC;
653#endif
654 cred->cr_uid = acred->uid;
655}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400656EXPORT_SYMBOL_GPL(rpcauth_init_cred);
Trond Myklebust5fe47552007-06-23 19:55:31 -0400657
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400658struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400659rpcauth_generic_bind_cred(struct rpc_task *task, struct rpc_cred *cred, int lookupflags)
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400660{
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400661 dprintk("RPC: %5u holding %s cred %p\n", task->tk_pid,
662 cred->cr_auth->au_ops->au_name, cred);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400663 return get_rpccred(cred);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400664}
Trond Myklebust5c691042008-03-12 16:21:07 -0400665EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400666
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400667static struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400668rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
Trond Myklebust1be27f32007-06-27 14:29:04 -0400670 struct rpc_auth *auth = task->tk_client->cl_auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 struct auth_cred acred = {
Eric W. Biedermanbf37f792013-02-01 15:55:38 -0800672 .uid = GLOBAL_ROOT_UID,
673 .gid = GLOBAL_ROOT_GID,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Chuck Lever46121cf2007-01-31 12:14:08 -0500676 dprintk("RPC: %5u looking up %s cred\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400677 task->tk_pid, task->tk_client->cl_auth->au_ops->au_name);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400678 return auth->au_ops->lookup_cred(auth, &acred, lookupflags);
Trond Myklebustaf093832008-03-12 12:12:16 -0400679}
680
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400681static struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400682rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags)
Trond Myklebustaf093832008-03-12 12:12:16 -0400683{
684 struct rpc_auth *auth = task->tk_client->cl_auth;
Trond Myklebustaf093832008-03-12 12:12:16 -0400685
686 dprintk("RPC: %5u looking up %s cred\n",
687 task->tk_pid, auth->au_ops->au_name);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400688 return rpcauth_lookupcred(auth, lookupflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689}
690
Trond Myklebusta17c2152010-07-31 14:29:08 -0400691static int
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400692rpcauth_bindcred(struct rpc_task *task, struct rpc_cred *cred, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400694 struct rpc_rqst *req = task->tk_rqstp;
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400695 struct rpc_cred *new;
Trond Myklebust5d351752009-09-15 13:32:13 -0400696 int lookupflags = 0;
697
698 if (flags & RPC_TASK_ASYNC)
699 lookupflags |= RPCAUTH_LOOKUP_NEW;
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400700 if (cred != NULL)
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400701 new = cred->cr_ops->crbind(task, cred, lookupflags);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400702 else if (flags & RPC_TASK_ROOTCREDS)
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400703 new = rpcauth_bind_root_cred(task, lookupflags);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400704 else
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400705 new = rpcauth_bind_new_cred(task, lookupflags);
706 if (IS_ERR(new))
707 return PTR_ERR(new);
Trond Myklebust9a8f6b52016-05-16 17:42:42 -0400708 put_rpccred(req->rq_cred);
Trond Myklebusta17c2152010-07-31 14:29:08 -0400709 req->rq_cred = new;
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400710 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
713void
714put_rpccred(struct rpc_cred *cred)
715{
Trond Myklebust9a8f6b52016-05-16 17:42:42 -0400716 if (cred == NULL)
717 return;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400718 /* Fast path for unhashed credentials */
Trond Myklebustf0380f32009-12-03 08:10:17 -0500719 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) == 0) {
720 if (atomic_dec_and_test(&cred->cr_count))
721 cred->cr_ops->crdestroy(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 return;
Trond Myklebustf0380f32009-12-03 08:10:17 -0500723 }
724
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400725 if (!atomic_dec_and_lock(&cred->cr_count, &rpc_credcache_lock))
726 return;
Trond Myklebustf5c21872007-06-25 17:11:20 -0400727 if (!list_empty(&cred->cr_lru)) {
728 number_cred_unused--;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400729 list_del_init(&cred->cr_lru);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400730 }
Trond Myklebust5f707eb2008-10-28 15:21:42 -0400731 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0) {
Trond Myklebustf0380f32009-12-03 08:10:17 -0500732 if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0) {
733 cred->cr_expire = jiffies;
734 list_add_tail(&cred->cr_lru, &cred_unused);
735 number_cred_unused++;
736 goto out_nodestroy;
737 }
738 if (!rpcauth_unhash_cred(cred)) {
739 /* We were hashed and someone looked us up... */
740 goto out_nodestroy;
741 }
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400742 }
743 spin_unlock(&rpc_credcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 cred->cr_ops->crdestroy(cred);
Trond Myklebustf0380f32009-12-03 08:10:17 -0500745 return;
746out_nodestroy:
747 spin_unlock(&rpc_credcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400749EXPORT_SYMBOL_GPL(put_rpccred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700751__be32 *
752rpcauth_marshcred(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400754 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Chuck Lever46121cf2007-01-31 12:14:08 -0500756 dprintk("RPC: %5u marshaling %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400757 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 return cred->cr_ops->crmarshal(task, p);
760}
761
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700762__be32 *
763rpcauth_checkverf(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400765 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Chuck Lever46121cf2007-01-31 12:14:08 -0500767 dprintk("RPC: %5u validating %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400768 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 return cred->cr_ops->crvalidate(task, p);
771}
772
Chuck Lever9f06c712010-12-14 14:59:18 +0000773static void rpcauth_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp,
774 __be32 *data, void *obj)
775{
776 struct xdr_stream xdr;
777
778 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, data);
779 encode(rqstp, &xdr, obj);
780}
781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782int
Chuck Lever9f06c712010-12-14 14:59:18 +0000783rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700784 __be32 *data, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400786 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
Chuck Lever46121cf2007-01-31 12:14:08 -0500788 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 task->tk_pid, cred->cr_ops->cr_name, cred);
790 if (cred->cr_ops->crwrap_req)
791 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
792 /* By default, we encode the arguments normally. */
Chuck Lever9f06c712010-12-14 14:59:18 +0000793 rpcauth_wrap_req_encode(encode, rqstp, data, obj);
794 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795}
796
Chuck Leverbf269552010-12-14 14:59:29 +0000797static int
798rpcauth_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp,
799 __be32 *data, void *obj)
800{
801 struct xdr_stream xdr;
802
803 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, data);
804 return decode(rqstp, &xdr, obj);
805}
806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807int
Chuck Leverbf269552010-12-14 14:59:29 +0000808rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700809 __be32 *data, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400811 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
Chuck Lever46121cf2007-01-31 12:14:08 -0500813 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 task->tk_pid, cred->cr_ops->cr_name, cred);
815 if (cred->cr_ops->crunwrap_resp)
816 return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
817 data, obj);
818 /* By default, we decode the arguments normally. */
Chuck Leverbf269552010-12-14 14:59:29 +0000819 return rpcauth_unwrap_req_decode(decode, rqstp, data, obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820}
821
822int
823rpcauth_refreshcred(struct rpc_task *task)
824{
Trond Myklebust9a84d382010-10-24 18:00:46 -0400825 struct rpc_cred *cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 int err;
827
Trond Myklebusta17c2152010-07-31 14:29:08 -0400828 cred = task->tk_rqstp->rq_cred;
829 if (cred == NULL) {
830 err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags);
831 if (err < 0)
832 goto out;
833 cred = task->tk_rqstp->rq_cred;
Joe Perchesf81c6222011-06-03 11:51:19 +0000834 }
Chuck Lever46121cf2007-01-31 12:14:08 -0500835 dprintk("RPC: %5u refreshing %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400836 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 err = cred->cr_ops->crrefresh(task);
Trond Myklebusta17c2152010-07-31 14:29:08 -0400839out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 if (err < 0)
841 task->tk_status = err;
842 return err;
843}
844
845void
846rpcauth_invalcred(struct rpc_task *task)
847{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400848 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400849
Chuck Lever46121cf2007-01-31 12:14:08 -0500850 dprintk("RPC: %5u invalidating %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400851 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400852 if (cred)
853 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854}
855
856int
857rpcauth_uptodatecred(struct rpc_task *task)
858{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400859 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400860
861 return cred == NULL ||
862 test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863}
Trond Myklebustf5c21872007-06-25 17:11:20 -0400864
Rusty Russell8e1f9362007-07-17 04:03:17 -0700865static struct shrinker rpc_cred_shrinker = {
Dave Chinner70534a72013-08-28 10:18:14 +1000866 .count_objects = rpcauth_cache_shrink_count,
867 .scan_objects = rpcauth_cache_shrink_scan,
Rusty Russell8e1f9362007-07-17 04:03:17 -0700868 .seeks = DEFAULT_SEEKS,
869};
Trond Myklebustf5c21872007-06-25 17:11:20 -0400870
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400871int __init rpcauth_init_module(void)
Trond Myklebustf5c21872007-06-25 17:11:20 -0400872{
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400873 int err;
874
875 err = rpc_init_authunix();
876 if (err < 0)
877 goto out1;
878 err = rpc_init_generic_auth();
879 if (err < 0)
880 goto out2;
Rusty Russell8e1f9362007-07-17 04:03:17 -0700881 register_shrinker(&rpc_cred_shrinker);
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400882 return 0;
883out2:
884 rpc_destroy_authunix();
885out1:
886 return err;
Trond Myklebustf5c21872007-06-25 17:11:20 -0400887}
888
Stephen Rothwellc135e842010-09-29 14:16:57 +1000889void rpcauth_remove_module(void)
Trond Myklebustf5c21872007-06-25 17:11:20 -0400890{
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400891 rpc_destroy_authunix();
892 rpc_destroy_generic_auth();
Rusty Russell8e1f9362007-07-17 04:03:17 -0700893 unregister_shrinker(&rpc_cred_shrinker);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400894}