blob: 360decdddc783405b9527f32dcf240f9878809fe [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
19#ifdef RPC_DEBUG
20# 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
Stephen Rothwell8e4e15d2010-08-04 12:11:22 +100075static struct kernel_param_ops param_ops_hashtbl_sz = {
76 .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
362rpcauth_cred_key_to_expire(struct rpc_cred *cred)
363{
364 if (!cred->cr_ops->crkey_to_expire)
365 return false;
366 return cred->cr_ops->crkey_to_expire(cred);
367}
368EXPORT_SYMBOL_GPL(rpcauth_cred_key_to_expire);
369
Jeff Laytona0337d12014-06-21 20:52:16 -0400370char *
371rpcauth_stringify_acceptor(struct rpc_cred *cred)
372{
373 if (!cred->cr_ops->crstringify_acceptor)
374 return NULL;
375 return cred->cr_ops->crstringify_acceptor(cred);
376}
377EXPORT_SYMBOL_GPL(rpcauth_stringify_acceptor);
378
Andy Adamson4de6caa2013-08-14 11:59:15 -0400379/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 * Destroy a list of credentials
381 */
382static inline
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400383void rpcauth_destroy_credlist(struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
385 struct rpc_cred *cred;
386
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400387 while (!list_empty(head)) {
388 cred = list_entry(head->next, struct rpc_cred, cr_lru);
389 list_del_init(&cred->cr_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 put_rpccred(cred);
391 }
392}
393
394/*
395 * Clear the RPC credential cache, and delete those credentials
396 * that are not referenced.
397 */
398void
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400399rpcauth_clear_credcache(struct rpc_cred_cache *cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400401 LIST_HEAD(free);
402 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 struct rpc_cred *cred;
Trond Myklebust988664a2010-07-31 14:29:07 -0400404 unsigned int hashsize = 1U << cache->hashbits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 int i;
406
407 spin_lock(&rpc_credcache_lock);
Trond Myklebust9499b432007-06-24 15:57:57 -0400408 spin_lock(&cache->lock);
Trond Myklebust988664a2010-07-31 14:29:07 -0400409 for (i = 0; i < hashsize; i++) {
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400410 head = &cache->hashtable[i];
411 while (!hlist_empty(head)) {
412 cred = hlist_entry(head->first, struct rpc_cred, cr_hash);
413 get_rpccred(cred);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400414 if (!list_empty(&cred->cr_lru)) {
415 list_del(&cred->cr_lru);
416 number_cred_unused--;
417 }
418 list_add_tail(&cred->cr_lru, &free);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400419 rpcauth_unhash_cred_locked(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 }
421 }
Trond Myklebust9499b432007-06-24 15:57:57 -0400422 spin_unlock(&cache->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 spin_unlock(&rpc_credcache_lock);
424 rpcauth_destroy_credlist(&free);
425}
426
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400427/*
428 * Destroy the RPC credential cache
429 */
430void
431rpcauth_destroy_credcache(struct rpc_auth *auth)
432{
433 struct rpc_cred_cache *cache = auth->au_credcache;
434
435 if (cache) {
436 auth->au_credcache = NULL;
437 rpcauth_clear_credcache(cache);
Trond Myklebust241269b2010-07-31 14:29:08 -0400438 kfree(cache->hashtable);
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400439 kfree(cache);
440 }
441}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400442EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache);
Trond Myklebust3ab9bb72007-06-09 15:41:42 -0400443
Trond Myklebustd2b83142008-04-14 18:13:37 -0400444
445#define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ)
446
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447/*
448 * Remove stale credentials. Avoid sleeping inside the loop.
449 */
Dave Chinner70534a72013-08-28 10:18:14 +1000450static long
Trond Myklebustf5c21872007-06-25 17:11:20 -0400451rpcauth_prune_expired(struct list_head *free, int nr_to_scan)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
Trond Myklebust9499b432007-06-24 15:57:57 -0400453 spinlock_t *cache_lock;
Trond Myklebusteac0d182008-10-28 15:21:41 -0400454 struct rpc_cred *cred, *next;
Trond Myklebustd2b83142008-04-14 18:13:37 -0400455 unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM;
Dave Chinner70534a72013-08-28 10:18:14 +1000456 long freed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
Trond Myklebusteac0d182008-10-28 15:21:41 -0400458 list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) {
459
Trond Myklebust20673402010-05-13 12:51:06 -0400460 if (nr_to_scan-- == 0)
461 break;
Trond Myklebust93a05e62010-05-13 12:51:06 -0400462 /*
463 * Enforce a 60 second garbage collection moratorium
464 * Note that the cred_unused list must be time-ordered.
465 */
Trond Myklebust3d7b0892010-04-22 15:35:55 -0400466 if (time_in_range(cred->cr_expire, expired, jiffies) &&
Trond Myklebusteac0d182008-10-28 15:21:41 -0400467 test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0)
Dave Chinner70534a72013-08-28 10:18:14 +1000468 break;
Trond Myklebusteac0d182008-10-28 15:21:41 -0400469
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400470 list_del_init(&cred->cr_lru);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400471 number_cred_unused--;
Dave Chinner70534a72013-08-28 10:18:14 +1000472 freed++;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400473 if (atomic_read(&cred->cr_count) != 0)
474 continue;
Trond Myklebusteac0d182008-10-28 15:21:41 -0400475
Trond Myklebust9499b432007-06-24 15:57:57 -0400476 cache_lock = &cred->cr_auth->au_credcache->lock;
477 spin_lock(cache_lock);
478 if (atomic_read(&cred->cr_count) == 0) {
479 get_rpccred(cred);
480 list_add_tail(&cred->cr_lru, free);
481 rpcauth_unhash_cred_locked(cred);
482 }
483 spin_unlock(cache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 }
Dave Chinner70534a72013-08-28 10:18:14 +1000485 return freed;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400486}
487
Trond Myklebustbae67462014-07-21 13:32:42 -0400488static unsigned long
489rpcauth_cache_do_shrink(int nr_to_scan)
490{
491 LIST_HEAD(free);
492 unsigned long freed;
493
494 spin_lock(&rpc_credcache_lock);
495 freed = rpcauth_prune_expired(&free, nr_to_scan);
496 spin_unlock(&rpc_credcache_lock);
497 rpcauth_destroy_credlist(&free);
498
499 return freed;
500}
501
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400502/*
Trond Myklebustf5c21872007-06-25 17:11:20 -0400503 * Run memory cache shrinker.
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400504 */
Dave Chinner70534a72013-08-28 10:18:14 +1000505static unsigned long
506rpcauth_cache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
507
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400508{
Dave Chinner70534a72013-08-28 10:18:14 +1000509 if ((sc->gfp_mask & GFP_KERNEL) != GFP_KERNEL)
510 return SHRINK_STOP;
511
512 /* nothing left, don't come back */
Trond Myklebustf5c21872007-06-25 17:11:20 -0400513 if (list_empty(&cred_unused))
Dave Chinner70534a72013-08-28 10:18:14 +1000514 return SHRINK_STOP;
515
Trond Myklebustbae67462014-07-21 13:32:42 -0400516 return rpcauth_cache_do_shrink(sc->nr_to_scan);
Dave Chinner70534a72013-08-28 10:18:14 +1000517}
518
519static unsigned long
520rpcauth_cache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
521
522{
523 return (number_cred_unused / 100) * sysctl_vfs_cache_pressure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
Trond Myklebustbae67462014-07-21 13:32:42 -0400526static void
527rpcauth_cache_enforce_limit(void)
528{
529 unsigned long diff;
530 unsigned int nr_to_scan;
531
532 if (number_cred_unused <= auth_max_cred_cachesize)
533 return;
534 diff = number_cred_unused - auth_max_cred_cachesize;
535 nr_to_scan = 100;
536 if (diff < nr_to_scan)
537 nr_to_scan = diff;
538 rpcauth_cache_do_shrink(nr_to_scan);
539}
540
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541/*
542 * Look up a process' credentials in the authentication cache
543 */
544struct rpc_cred *
545rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred,
Trond Myklebust8a317762006-02-01 12:18:36 -0500546 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400548 LIST_HEAD(free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 struct rpc_cred_cache *cache = auth->au_credcache;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400550 struct rpc_cred *cred = NULL,
551 *entry, *new;
Trond Myklebust25337fd2008-03-12 14:40:14 -0400552 unsigned int nr;
553
Eric W. Biederman9e469e32013-02-02 01:57:30 -0800554 nr = hash_long(from_kuid(&init_user_ns, acred->uid), cache->hashbits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400556 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800557 hlist_for_each_entry_rcu(entry, &cache->hashtable[nr], cr_hash) {
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400558 if (!entry->cr_ops->crmatch(acred, entry, flags))
559 continue;
Trond Myklebust9499b432007-06-24 15:57:57 -0400560 spin_lock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400561 if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) == 0) {
Trond Myklebust9499b432007-06-24 15:57:57 -0400562 spin_unlock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400563 continue;
564 }
565 cred = get_rpccred(entry);
Trond Myklebust9499b432007-06-24 15:57:57 -0400566 spin_unlock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400567 break;
568 }
569 rcu_read_unlock();
570
Trond Myklebust9499b432007-06-24 15:57:57 -0400571 if (cred != NULL)
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400572 goto found;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400573
574 new = auth->au_ops->crcreate(auth, acred, flags);
575 if (IS_ERR(new)) {
576 cred = new;
577 goto out;
578 }
579
Trond Myklebust9499b432007-06-24 15:57:57 -0400580 spin_lock(&cache->lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800581 hlist_for_each_entry(entry, &cache->hashtable[nr], cr_hash) {
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400582 if (!entry->cr_ops->crmatch(acred, entry, flags))
583 continue;
584 cred = get_rpccred(entry);
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400585 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 }
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400587 if (cred == NULL) {
Trond Myklebust5fe47552007-06-23 19:55:31 -0400588 cred = new;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400589 set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);
590 hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]);
591 } else
592 list_add_tail(&new->cr_lru, &free);
Trond Myklebust9499b432007-06-24 15:57:57 -0400593 spin_unlock(&cache->lock);
Trond Myklebustbae67462014-07-21 13:32:42 -0400594 rpcauth_cache_enforce_limit();
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400595found:
Joe Perchesf64f9e72009-11-29 16:55:45 -0800596 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
597 cred->cr_ops->cr_init != NULL &&
598 !(flags & RPCAUTH_LOOKUP_NEW)) {
Trond Myklebustfba3bad2006-02-01 12:19:27 -0500599 int res = cred->cr_ops->cr_init(auth, cred);
600 if (res < 0) {
601 put_rpccred(cred);
602 cred = ERR_PTR(res);
603 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 }
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400605 rpcauth_destroy_credlist(&free);
606out:
607 return cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400609EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611struct rpc_cred *
Trond Myklebust8a317762006-02-01 12:18:36 -0500612rpcauth_lookupcred(struct rpc_auth *auth, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613{
David Howells86a264a2008-11-14 10:39:18 +1100614 struct auth_cred acred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 struct rpc_cred *ret;
David Howells86a264a2008-11-14 10:39:18 +1100616 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Chuck Lever46121cf2007-01-31 12:14:08 -0500618 dprintk("RPC: looking up %s cred\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 auth->au_ops->au_name);
David Howells86a264a2008-11-14 10:39:18 +1100620
621 memset(&acred, 0, sizeof(acred));
622 acred.uid = cred->fsuid;
623 acred.gid = cred->fsgid;
624 acred.group_info = get_group_info(((struct cred *)cred)->group_info);
625
Trond Myklebust8a317762006-02-01 12:18:36 -0500626 ret = auth->au_ops->lookup_cred(auth, &acred, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 put_group_info(acred.group_info);
628 return ret;
629}
Andy Adamson66b06862014-06-12 15:02:32 -0400630EXPORT_SYMBOL_GPL(rpcauth_lookupcred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
Trond Myklebust5fe47552007-06-23 19:55:31 -0400632void
633rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,
634 struct rpc_auth *auth, const struct rpc_credops *ops)
635{
636 INIT_HLIST_NODE(&cred->cr_hash);
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400637 INIT_LIST_HEAD(&cred->cr_lru);
Trond Myklebust5fe47552007-06-23 19:55:31 -0400638 atomic_set(&cred->cr_count, 1);
639 cred->cr_auth = auth;
640 cred->cr_ops = ops;
641 cred->cr_expire = jiffies;
642#ifdef RPC_DEBUG
643 cred->cr_magic = RPCAUTH_CRED_MAGIC;
644#endif
645 cred->cr_uid = acred->uid;
646}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400647EXPORT_SYMBOL_GPL(rpcauth_init_cred);
Trond Myklebust5fe47552007-06-23 19:55:31 -0400648
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400649struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400650rpcauth_generic_bind_cred(struct rpc_task *task, struct rpc_cred *cred, int lookupflags)
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400651{
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400652 dprintk("RPC: %5u holding %s cred %p\n", task->tk_pid,
653 cred->cr_auth->au_ops->au_name, cred);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400654 return get_rpccred(cred);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400655}
Trond Myklebust5c691042008-03-12 16:21:07 -0400656EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400657
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400658static struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400659rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660{
Trond Myklebust1be27f32007-06-27 14:29:04 -0400661 struct rpc_auth *auth = task->tk_client->cl_auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 struct auth_cred acred = {
Eric W. Biedermanbf37f792013-02-01 15:55:38 -0800663 .uid = GLOBAL_ROOT_UID,
664 .gid = GLOBAL_ROOT_GID,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
Chuck Lever46121cf2007-01-31 12:14:08 -0500667 dprintk("RPC: %5u looking up %s cred\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400668 task->tk_pid, task->tk_client->cl_auth->au_ops->au_name);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400669 return auth->au_ops->lookup_cred(auth, &acred, lookupflags);
Trond Myklebustaf093832008-03-12 12:12:16 -0400670}
671
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400672static struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400673rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags)
Trond Myklebustaf093832008-03-12 12:12:16 -0400674{
675 struct rpc_auth *auth = task->tk_client->cl_auth;
Trond Myklebustaf093832008-03-12 12:12:16 -0400676
677 dprintk("RPC: %5u looking up %s cred\n",
678 task->tk_pid, auth->au_ops->au_name);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400679 return rpcauth_lookupcred(auth, lookupflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680}
681
Trond Myklebusta17c2152010-07-31 14:29:08 -0400682static int
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400683rpcauth_bindcred(struct rpc_task *task, struct rpc_cred *cred, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400685 struct rpc_rqst *req = task->tk_rqstp;
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400686 struct rpc_cred *new;
Trond Myklebust5d351752009-09-15 13:32:13 -0400687 int lookupflags = 0;
688
689 if (flags & RPC_TASK_ASYNC)
690 lookupflags |= RPCAUTH_LOOKUP_NEW;
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400691 if (cred != NULL)
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400692 new = cred->cr_ops->crbind(task, cred, lookupflags);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400693 else if (flags & RPC_TASK_ROOTCREDS)
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400694 new = rpcauth_bind_root_cred(task, lookupflags);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400695 else
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400696 new = rpcauth_bind_new_cred(task, lookupflags);
697 if (IS_ERR(new))
698 return PTR_ERR(new);
Trond Myklebusta17c2152010-07-31 14:29:08 -0400699 if (req->rq_cred != NULL)
700 put_rpccred(req->rq_cred);
701 req->rq_cred = new;
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400702 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}
704
705void
706put_rpccred(struct rpc_cred *cred)
707{
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400708 /* Fast path for unhashed credentials */
Trond Myklebustf0380f32009-12-03 08:10:17 -0500709 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) == 0) {
710 if (atomic_dec_and_test(&cred->cr_count))
711 cred->cr_ops->crdestroy(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 return;
Trond Myklebustf0380f32009-12-03 08:10:17 -0500713 }
714
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400715 if (!atomic_dec_and_lock(&cred->cr_count, &rpc_credcache_lock))
716 return;
Trond Myklebustf5c21872007-06-25 17:11:20 -0400717 if (!list_empty(&cred->cr_lru)) {
718 number_cred_unused--;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400719 list_del_init(&cred->cr_lru);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400720 }
Trond Myklebust5f707eb2008-10-28 15:21:42 -0400721 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0) {
Trond Myklebustf0380f32009-12-03 08:10:17 -0500722 if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0) {
723 cred->cr_expire = jiffies;
724 list_add_tail(&cred->cr_lru, &cred_unused);
725 number_cred_unused++;
726 goto out_nodestroy;
727 }
728 if (!rpcauth_unhash_cred(cred)) {
729 /* We were hashed and someone looked us up... */
730 goto out_nodestroy;
731 }
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400732 }
733 spin_unlock(&rpc_credcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 cred->cr_ops->crdestroy(cred);
Trond Myklebustf0380f32009-12-03 08:10:17 -0500735 return;
736out_nodestroy:
737 spin_unlock(&rpc_credcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400739EXPORT_SYMBOL_GPL(put_rpccred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700741__be32 *
742rpcauth_marshcred(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400744 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
Chuck Lever46121cf2007-01-31 12:14:08 -0500746 dprintk("RPC: %5u marshaling %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400747 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 return cred->cr_ops->crmarshal(task, p);
750}
751
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700752__be32 *
753rpcauth_checkverf(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400755 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Chuck Lever46121cf2007-01-31 12:14:08 -0500757 dprintk("RPC: %5u validating %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400758 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 return cred->cr_ops->crvalidate(task, p);
761}
762
Chuck Lever9f06c712010-12-14 14:59:18 +0000763static void rpcauth_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp,
764 __be32 *data, void *obj)
765{
766 struct xdr_stream xdr;
767
768 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, data);
769 encode(rqstp, &xdr, obj);
770}
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772int
Chuck Lever9f06c712010-12-14 14:59:18 +0000773rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700774 __be32 *data, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400776 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Chuck Lever46121cf2007-01-31 12:14:08 -0500778 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 task->tk_pid, cred->cr_ops->cr_name, cred);
780 if (cred->cr_ops->crwrap_req)
781 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
782 /* By default, we encode the arguments normally. */
Chuck Lever9f06c712010-12-14 14:59:18 +0000783 rpcauth_wrap_req_encode(encode, rqstp, data, obj);
784 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785}
786
Chuck Leverbf269552010-12-14 14:59:29 +0000787static int
788rpcauth_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp,
789 __be32 *data, void *obj)
790{
791 struct xdr_stream xdr;
792
793 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, data);
794 return decode(rqstp, &xdr, obj);
795}
796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797int
Chuck Leverbf269552010-12-14 14:59:29 +0000798rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700799 __be32 *data, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400801 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Chuck Lever46121cf2007-01-31 12:14:08 -0500803 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 task->tk_pid, cred->cr_ops->cr_name, cred);
805 if (cred->cr_ops->crunwrap_resp)
806 return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
807 data, obj);
808 /* By default, we decode the arguments normally. */
Chuck Leverbf269552010-12-14 14:59:29 +0000809 return rpcauth_unwrap_req_decode(decode, rqstp, data, obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810}
811
812int
813rpcauth_refreshcred(struct rpc_task *task)
814{
Trond Myklebust9a84d382010-10-24 18:00:46 -0400815 struct rpc_cred *cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 int err;
817
Trond Myklebusta17c2152010-07-31 14:29:08 -0400818 cred = task->tk_rqstp->rq_cred;
819 if (cred == NULL) {
820 err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags);
821 if (err < 0)
822 goto out;
823 cred = task->tk_rqstp->rq_cred;
Joe Perchesf81c6222011-06-03 11:51:19 +0000824 }
Chuck Lever46121cf2007-01-31 12:14:08 -0500825 dprintk("RPC: %5u refreshing %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400826 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500827
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 err = cred->cr_ops->crrefresh(task);
Trond Myklebusta17c2152010-07-31 14:29:08 -0400829out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 if (err < 0)
831 task->tk_status = err;
832 return err;
833}
834
835void
836rpcauth_invalcred(struct rpc_task *task)
837{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400838 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400839
Chuck Lever46121cf2007-01-31 12:14:08 -0500840 dprintk("RPC: %5u invalidating %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400841 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400842 if (cred)
843 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844}
845
846int
847rpcauth_uptodatecred(struct rpc_task *task)
848{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400849 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400850
851 return cred == NULL ||
852 test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853}
Trond Myklebustf5c21872007-06-25 17:11:20 -0400854
Rusty Russell8e1f9362007-07-17 04:03:17 -0700855static struct shrinker rpc_cred_shrinker = {
Dave Chinner70534a72013-08-28 10:18:14 +1000856 .count_objects = rpcauth_cache_shrink_count,
857 .scan_objects = rpcauth_cache_shrink_scan,
Rusty Russell8e1f9362007-07-17 04:03:17 -0700858 .seeks = DEFAULT_SEEKS,
859};
Trond Myklebustf5c21872007-06-25 17:11:20 -0400860
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400861int __init rpcauth_init_module(void)
Trond Myklebustf5c21872007-06-25 17:11:20 -0400862{
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400863 int err;
864
865 err = rpc_init_authunix();
866 if (err < 0)
867 goto out1;
868 err = rpc_init_generic_auth();
869 if (err < 0)
870 goto out2;
Rusty Russell8e1f9362007-07-17 04:03:17 -0700871 register_shrinker(&rpc_cred_shrinker);
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400872 return 0;
873out2:
874 rpc_destroy_authunix();
875out1:
876 return err;
Trond Myklebustf5c21872007-06-25 17:11:20 -0400877}
878
Stephen Rothwellc135e842010-09-29 14:16:57 +1000879void rpcauth_remove_module(void)
Trond Myklebustf5c21872007-06-25 17:11:20 -0400880{
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400881 rpc_destroy_authunix();
882 rpc_destroy_generic_auth();
Rusty Russell8e1f9362007-07-17 04:03:17 -0700883 unregister_shrinker(&rpc_cred_shrinker);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400884}