blob: 02f53674dc39d6973d374f18b43bd0b1b93952c7 [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
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;
NeilBrownbd956082014-07-14 11:28:20 +1000560 if (flags & RPCAUTH_LOOKUP_RCU) {
561 if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) &&
562 !test_bit(RPCAUTH_CRED_NEW, &entry->cr_flags))
563 cred = entry;
564 break;
565 }
Trond Myklebust9499b432007-06-24 15:57:57 -0400566 spin_lock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400567 if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) == 0) {
Trond Myklebust9499b432007-06-24 15:57:57 -0400568 spin_unlock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400569 continue;
570 }
571 cred = get_rpccred(entry);
Trond Myklebust9499b432007-06-24 15:57:57 -0400572 spin_unlock(&cache->lock);
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400573 break;
574 }
575 rcu_read_unlock();
576
Trond Myklebust9499b432007-06-24 15:57:57 -0400577 if (cred != NULL)
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400578 goto found;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400579
NeilBrownbd956082014-07-14 11:28:20 +1000580 if (flags & RPCAUTH_LOOKUP_RCU)
581 return ERR_PTR(-ECHILD);
582
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400583 new = auth->au_ops->crcreate(auth, acred, flags);
584 if (IS_ERR(new)) {
585 cred = new;
586 goto out;
587 }
588
Trond Myklebust9499b432007-06-24 15:57:57 -0400589 spin_lock(&cache->lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800590 hlist_for_each_entry(entry, &cache->hashtable[nr], cr_hash) {
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400591 if (!entry->cr_ops->crmatch(acred, entry, flags))
592 continue;
593 cred = get_rpccred(entry);
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400594 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 }
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400596 if (cred == NULL) {
Trond Myklebust5fe47552007-06-23 19:55:31 -0400597 cred = new;
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400598 set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);
599 hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]);
600 } else
601 list_add_tail(&new->cr_lru, &free);
Trond Myklebust9499b432007-06-24 15:57:57 -0400602 spin_unlock(&cache->lock);
Trond Myklebustbae67462014-07-21 13:32:42 -0400603 rpcauth_cache_enforce_limit();
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400604found:
Joe Perchesf64f9e72009-11-29 16:55:45 -0800605 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
606 cred->cr_ops->cr_init != NULL &&
607 !(flags & RPCAUTH_LOOKUP_NEW)) {
Trond Myklebustfba3bad2006-02-01 12:19:27 -0500608 int res = cred->cr_ops->cr_init(auth, cred);
609 if (res < 0) {
610 put_rpccred(cred);
611 cred = ERR_PTR(res);
612 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 }
Trond Myklebust31be5bf2007-06-24 15:55:26 -0400614 rpcauth_destroy_credlist(&free);
615out:
616 return cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400618EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
620struct rpc_cred *
Trond Myklebust8a317762006-02-01 12:18:36 -0500621rpcauth_lookupcred(struct rpc_auth *auth, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622{
David Howells86a264a2008-11-14 10:39:18 +1100623 struct auth_cred acred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 struct rpc_cred *ret;
David Howells86a264a2008-11-14 10:39:18 +1100625 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626
Chuck Lever46121cf2007-01-31 12:14:08 -0500627 dprintk("RPC: looking up %s cred\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 auth->au_ops->au_name);
David Howells86a264a2008-11-14 10:39:18 +1100629
630 memset(&acred, 0, sizeof(acred));
631 acred.uid = cred->fsuid;
632 acred.gid = cred->fsgid;
NeilBrown122a8cd2014-08-04 16:24:00 +1000633 acred.group_info = cred->group_info;
Trond Myklebust8a317762006-02-01 12:18:36 -0500634 ret = auth->au_ops->lookup_cred(auth, &acred, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 return ret;
636}
Andy Adamson66b06862014-06-12 15:02:32 -0400637EXPORT_SYMBOL_GPL(rpcauth_lookupcred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
Trond Myklebust5fe47552007-06-23 19:55:31 -0400639void
640rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,
641 struct rpc_auth *auth, const struct rpc_credops *ops)
642{
643 INIT_HLIST_NODE(&cred->cr_hash);
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400644 INIT_LIST_HEAD(&cred->cr_lru);
Trond Myklebust5fe47552007-06-23 19:55:31 -0400645 atomic_set(&cred->cr_count, 1);
646 cred->cr_auth = auth;
647 cred->cr_ops = ops;
648 cred->cr_expire = jiffies;
Jeff Laytonf895b252014-11-17 16:58:04 -0500649#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Trond Myklebust5fe47552007-06-23 19:55:31 -0400650 cred->cr_magic = RPCAUTH_CRED_MAGIC;
651#endif
652 cred->cr_uid = acred->uid;
653}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400654EXPORT_SYMBOL_GPL(rpcauth_init_cred);
Trond Myklebust5fe47552007-06-23 19:55:31 -0400655
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400656struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400657rpcauth_generic_bind_cred(struct rpc_task *task, struct rpc_cred *cred, int lookupflags)
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400658{
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400659 dprintk("RPC: %5u holding %s cred %p\n", task->tk_pid,
660 cred->cr_auth->au_ops->au_name, cred);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400661 return get_rpccred(cred);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400662}
Trond Myklebust5c691042008-03-12 16:21:07 -0400663EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400664
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400665static struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400666rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
Trond Myklebust1be27f32007-06-27 14:29:04 -0400668 struct rpc_auth *auth = task->tk_client->cl_auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 struct auth_cred acred = {
Eric W. Biedermanbf37f792013-02-01 15:55:38 -0800670 .uid = GLOBAL_ROOT_UID,
671 .gid = GLOBAL_ROOT_GID,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Chuck Lever46121cf2007-01-31 12:14:08 -0500674 dprintk("RPC: %5u looking up %s cred\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400675 task->tk_pid, task->tk_client->cl_auth->au_ops->au_name);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400676 return auth->au_ops->lookup_cred(auth, &acred, lookupflags);
Trond Myklebustaf093832008-03-12 12:12:16 -0400677}
678
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400679static struct rpc_cred *
Trond Myklebust5d351752009-09-15 13:32:13 -0400680rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags)
Trond Myklebustaf093832008-03-12 12:12:16 -0400681{
682 struct rpc_auth *auth = task->tk_client->cl_auth;
Trond Myklebustaf093832008-03-12 12:12:16 -0400683
684 dprintk("RPC: %5u looking up %s cred\n",
685 task->tk_pid, auth->au_ops->au_name);
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400686 return rpcauth_lookupcred(auth, lookupflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687}
688
Trond Myklebusta17c2152010-07-31 14:29:08 -0400689static int
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400690rpcauth_bindcred(struct rpc_task *task, struct rpc_cred *cred, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400692 struct rpc_rqst *req = task->tk_rqstp;
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400693 struct rpc_cred *new;
Trond Myklebust5d351752009-09-15 13:32:13 -0400694 int lookupflags = 0;
695
696 if (flags & RPC_TASK_ASYNC)
697 lookupflags |= RPCAUTH_LOOKUP_NEW;
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400698 if (cred != NULL)
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400699 new = cred->cr_ops->crbind(task, cred, lookupflags);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400700 else if (flags & RPC_TASK_ROOTCREDS)
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400701 new = rpcauth_bind_root_cred(task, lookupflags);
Trond Myklebust4ccda2c2008-03-12 16:20:55 -0400702 else
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400703 new = rpcauth_bind_new_cred(task, lookupflags);
704 if (IS_ERR(new))
705 return PTR_ERR(new);
Trond Myklebusta17c2152010-07-31 14:29:08 -0400706 if (req->rq_cred != NULL)
707 put_rpccred(req->rq_cred);
708 req->rq_cred = new;
Trond Myklebust8572b8e2010-07-31 14:29:08 -0400709 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
711
712void
713put_rpccred(struct rpc_cred *cred)
714{
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400715 /* Fast path for unhashed credentials */
Trond Myklebustf0380f32009-12-03 08:10:17 -0500716 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) == 0) {
717 if (atomic_dec_and_test(&cred->cr_count))
718 cred->cr_ops->crdestroy(cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 return;
Trond Myklebustf0380f32009-12-03 08:10:17 -0500720 }
721
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400722 if (!atomic_dec_and_lock(&cred->cr_count, &rpc_credcache_lock))
723 return;
Trond Myklebustf5c21872007-06-25 17:11:20 -0400724 if (!list_empty(&cred->cr_lru)) {
725 number_cred_unused--;
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400726 list_del_init(&cred->cr_lru);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400727 }
Trond Myklebust5f707eb2008-10-28 15:21:42 -0400728 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0) {
Trond Myklebustf0380f32009-12-03 08:10:17 -0500729 if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0) {
730 cred->cr_expire = jiffies;
731 list_add_tail(&cred->cr_lru, &cred_unused);
732 number_cred_unused++;
733 goto out_nodestroy;
734 }
735 if (!rpcauth_unhash_cred(cred)) {
736 /* We were hashed and someone looked us up... */
737 goto out_nodestroy;
738 }
Trond Myklebuste092bdc2007-06-23 19:45:36 -0400739 }
740 spin_unlock(&rpc_credcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 cred->cr_ops->crdestroy(cred);
Trond Myklebustf0380f32009-12-03 08:10:17 -0500742 return;
743out_nodestroy:
744 spin_unlock(&rpc_credcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}
Trond Myklebuste8914c62007-07-14 15:39:59 -0400746EXPORT_SYMBOL_GPL(put_rpccred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700748__be32 *
749rpcauth_marshcred(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400751 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
Chuck Lever46121cf2007-01-31 12:14:08 -0500753 dprintk("RPC: %5u marshaling %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400754 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 return cred->cr_ops->crmarshal(task, p);
757}
758
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700759__be32 *
760rpcauth_checkverf(struct rpc_task *task, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400762 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Chuck Lever46121cf2007-01-31 12:14:08 -0500764 dprintk("RPC: %5u validating %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400765 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500766
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 return cred->cr_ops->crvalidate(task, p);
768}
769
Chuck Lever9f06c712010-12-14 14:59:18 +0000770static void rpcauth_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp,
771 __be32 *data, void *obj)
772{
773 struct xdr_stream xdr;
774
775 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, data);
776 encode(rqstp, &xdr, obj);
777}
778
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779int
Chuck Lever9f06c712010-12-14 14:59:18 +0000780rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700781 __be32 *data, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400783 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Chuck Lever46121cf2007-01-31 12:14:08 -0500785 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 task->tk_pid, cred->cr_ops->cr_name, cred);
787 if (cred->cr_ops->crwrap_req)
788 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj);
789 /* By default, we encode the arguments normally. */
Chuck Lever9f06c712010-12-14 14:59:18 +0000790 rpcauth_wrap_req_encode(encode, rqstp, data, obj);
791 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792}
793
Chuck Leverbf269552010-12-14 14:59:29 +0000794static int
795rpcauth_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp,
796 __be32 *data, void *obj)
797{
798 struct xdr_stream xdr;
799
800 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, data);
801 return decode(rqstp, &xdr, obj);
802}
803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804int
Chuck Leverbf269552010-12-14 14:59:29 +0000805rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp,
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700806 __be32 *data, void *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400808 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
Chuck Lever46121cf2007-01-31 12:14:08 -0500810 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 task->tk_pid, cred->cr_ops->cr_name, cred);
812 if (cred->cr_ops->crunwrap_resp)
813 return cred->cr_ops->crunwrap_resp(task, decode, rqstp,
814 data, obj);
815 /* By default, we decode the arguments normally. */
Chuck Leverbf269552010-12-14 14:59:29 +0000816 return rpcauth_unwrap_req_decode(decode, rqstp, data, obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817}
818
819int
820rpcauth_refreshcred(struct rpc_task *task)
821{
Trond Myklebust9a84d382010-10-24 18:00:46 -0400822 struct rpc_cred *cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 int err;
824
Trond Myklebusta17c2152010-07-31 14:29:08 -0400825 cred = task->tk_rqstp->rq_cred;
826 if (cred == NULL) {
827 err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags);
828 if (err < 0)
829 goto out;
830 cred = task->tk_rqstp->rq_cred;
Joe Perchesf81c6222011-06-03 11:51:19 +0000831 }
Chuck Lever46121cf2007-01-31 12:14:08 -0500832 dprintk("RPC: %5u refreshing %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400833 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Chuck Lever0bbacc42005-11-01 16:53:32 -0500834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 err = cred->cr_ops->crrefresh(task);
Trond Myklebusta17c2152010-07-31 14:29:08 -0400836out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 if (err < 0)
838 task->tk_status = err;
839 return err;
840}
841
842void
843rpcauth_invalcred(struct rpc_task *task)
844{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400845 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400846
Chuck Lever46121cf2007-01-31 12:14:08 -0500847 dprintk("RPC: %5u invalidating %s cred %p\n",
Trond Myklebust1be27f32007-06-27 14:29:04 -0400848 task->tk_pid, cred->cr_auth->au_ops->au_name, cred);
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400849 if (cred)
850 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851}
852
853int
854rpcauth_uptodatecred(struct rpc_task *task)
855{
Trond Myklebusta17c2152010-07-31 14:29:08 -0400856 struct rpc_cred *cred = task->tk_rqstp->rq_cred;
Trond Myklebustfc432dd2007-06-25 10:15:15 -0400857
858 return cred == NULL ||
859 test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860}
Trond Myklebustf5c21872007-06-25 17:11:20 -0400861
Rusty Russell8e1f9362007-07-17 04:03:17 -0700862static struct shrinker rpc_cred_shrinker = {
Dave Chinner70534a72013-08-28 10:18:14 +1000863 .count_objects = rpcauth_cache_shrink_count,
864 .scan_objects = rpcauth_cache_shrink_scan,
Rusty Russell8e1f9362007-07-17 04:03:17 -0700865 .seeks = DEFAULT_SEEKS,
866};
Trond Myklebustf5c21872007-06-25 17:11:20 -0400867
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400868int __init rpcauth_init_module(void)
Trond Myklebustf5c21872007-06-25 17:11:20 -0400869{
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400870 int err;
871
872 err = rpc_init_authunix();
873 if (err < 0)
874 goto out1;
875 err = rpc_init_generic_auth();
876 if (err < 0)
877 goto out2;
Rusty Russell8e1f9362007-07-17 04:03:17 -0700878 register_shrinker(&rpc_cred_shrinker);
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400879 return 0;
880out2:
881 rpc_destroy_authunix();
882out1:
883 return err;
Trond Myklebustf5c21872007-06-25 17:11:20 -0400884}
885
Stephen Rothwellc135e842010-09-29 14:16:57 +1000886void rpcauth_remove_module(void)
Trond Myklebustf5c21872007-06-25 17:11:20 -0400887{
Trond Myklebust5d8d9a42010-07-31 14:29:07 -0400888 rpc_destroy_authunix();
889 rpc_destroy_generic_auth();
Rusty Russell8e1f9362007-07-17 04:03:17 -0700890 unregister_shrinker(&rpc_cred_shrinker);
Trond Myklebustf5c21872007-06-25 17:11:20 -0400891}