Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/net/sunrpc/auth.c
4 : : *
5 : : * Generic RPC client authentication API.
6 : : *
7 : : * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
8 : : */
9 : :
10 : : #include <linux/types.h>
11 : : #include <linux/sched.h>
12 : : #include <linux/cred.h>
13 : : #include <linux/module.h>
14 : : #include <linux/slab.h>
15 : : #include <linux/errno.h>
16 : : #include <linux/hash.h>
17 : : #include <linux/sunrpc/clnt.h>
18 : : #include <linux/sunrpc/gss_api.h>
19 : : #include <linux/spinlock.h>
20 : :
21 : : #include <trace/events/sunrpc.h>
22 : :
23 : : #define RPC_CREDCACHE_DEFAULT_HASHBITS (4)
24 : : struct rpc_cred_cache {
25 : : struct hlist_head *hashtable;
26 : : unsigned int hashbits;
27 : : spinlock_t lock;
28 : : };
29 : :
30 : : static unsigned int auth_hashbits = RPC_CREDCACHE_DEFAULT_HASHBITS;
31 : :
32 : : static const struct rpc_authops __rcu *auth_flavors[RPC_AUTH_MAXFLAVOR] = {
33 : : [RPC_AUTH_NULL] = (const struct rpc_authops __force __rcu *)&authnull_ops,
34 : : [RPC_AUTH_UNIX] = (const struct rpc_authops __force __rcu *)&authunix_ops,
35 : : NULL, /* others can be loadable modules */
36 : : };
37 : :
38 : : static LIST_HEAD(cred_unused);
39 : : static unsigned long number_cred_unused;
40 : :
41 : : static struct cred machine_cred = {
42 : : .usage = ATOMIC_INIT(1),
43 : : #ifdef CONFIG_DEBUG_CREDENTIALS
44 : : .magic = CRED_MAGIC,
45 : : #endif
46 : : };
47 : :
48 : : /*
49 : : * Return the machine_cred pointer to be used whenever
50 : : * the a generic machine credential is needed.
51 : : */
52 : 0 : const struct cred *rpc_machine_cred(void)
53 : : {
54 : 0 : return &machine_cred;
55 : : }
56 : : EXPORT_SYMBOL_GPL(rpc_machine_cred);
57 : :
58 : : #define MAX_HASHTABLE_BITS (14)
59 : 0 : static int param_set_hashtbl_sz(const char *val, const struct kernel_param *kp)
60 : : {
61 : 0 : unsigned long num;
62 : 0 : unsigned int nbits;
63 : 0 : int ret;
64 : :
65 [ # # ]: 0 : if (!val)
66 : 0 : goto out_inval;
67 : 0 : ret = kstrtoul(val, 0, &num);
68 [ # # ]: 0 : if (ret)
69 : 0 : goto out_inval;
70 [ # # ]: 0 : nbits = fls(num - 1);
71 [ # # ]: 0 : if (nbits > MAX_HASHTABLE_BITS || nbits < 2)
72 : 0 : goto out_inval;
73 : 0 : *(unsigned int *)kp->arg = nbits;
74 : 0 : return 0;
75 : : out_inval:
76 : : return -EINVAL;
77 : : }
78 : :
79 : 0 : static int param_get_hashtbl_sz(char *buffer, const struct kernel_param *kp)
80 : : {
81 : 0 : unsigned int nbits;
82 : :
83 : 0 : nbits = *(unsigned int *)kp->arg;
84 : 0 : return sprintf(buffer, "%u", 1U << nbits);
85 : : }
86 : :
87 : : #define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int);
88 : :
89 : : static const struct kernel_param_ops param_ops_hashtbl_sz = {
90 : : .set = param_set_hashtbl_sz,
91 : : .get = param_get_hashtbl_sz,
92 : : };
93 : :
94 : : module_param_named(auth_hashtable_size, auth_hashbits, hashtbl_sz, 0644);
95 : : MODULE_PARM_DESC(auth_hashtable_size, "RPC credential cache hashtable size");
96 : :
97 : : static unsigned long auth_max_cred_cachesize = ULONG_MAX;
98 : : module_param(auth_max_cred_cachesize, ulong, 0644);
99 : : MODULE_PARM_DESC(auth_max_cred_cachesize, "RPC credential maximum total cache size");
100 : :
101 : : static u32
102 : 0 : pseudoflavor_to_flavor(u32 flavor) {
103 : 0 : if (flavor > RPC_AUTH_MAXFLAVOR)
104 : 0 : return RPC_AUTH_GSS;
105 : : return flavor;
106 : : }
107 : :
108 : : int
109 : 30 : rpcauth_register(const struct rpc_authops *ops)
110 : : {
111 : 30 : const struct rpc_authops *old;
112 : 30 : rpc_authflavor_t flavor;
113 : :
114 [ + - ]: 30 : if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR)
115 : : return -EINVAL;
116 : 30 : old = cmpxchg((const struct rpc_authops ** __force)&auth_flavors[flavor], NULL, ops);
117 [ + - ]: 30 : if (old == NULL || old == ops)
118 : 30 : return 0;
119 : : return -EPERM;
120 : : }
121 : : EXPORT_SYMBOL_GPL(rpcauth_register);
122 : :
123 : : int
124 : 0 : rpcauth_unregister(const struct rpc_authops *ops)
125 : : {
126 : 0 : const struct rpc_authops *old;
127 : 0 : rpc_authflavor_t flavor;
128 : :
129 [ # # ]: 0 : if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR)
130 : : return -EINVAL;
131 : :
132 : 0 : old = cmpxchg((const struct rpc_authops ** __force)&auth_flavors[flavor], ops, NULL);
133 [ # # ]: 0 : if (old == ops || old == NULL)
134 : 0 : return 0;
135 : : return -EPERM;
136 : : }
137 : : EXPORT_SYMBOL_GPL(rpcauth_unregister);
138 : :
139 : : static const struct rpc_authops *
140 : 0 : rpcauth_get_authops(rpc_authflavor_t flavor)
141 : : {
142 : 0 : const struct rpc_authops *ops;
143 : :
144 [ # # ]: 0 : if (flavor >= RPC_AUTH_MAXFLAVOR)
145 : : return NULL;
146 : :
147 : 0 : rcu_read_lock();
148 [ # # ]: 0 : ops = rcu_dereference(auth_flavors[flavor]);
149 [ # # ]: 0 : if (ops == NULL) {
150 : 0 : rcu_read_unlock();
151 : 0 : request_module("rpc-auth-%u", flavor);
152 : 0 : rcu_read_lock();
153 [ # # ]: 0 : ops = rcu_dereference(auth_flavors[flavor]);
154 [ # # ]: 0 : if (ops == NULL)
155 : 0 : goto out;
156 : : }
157 [ # # ]: 0 : if (!try_module_get(ops->owner))
158 : 0 : ops = NULL;
159 : 0 : out:
160 : 0 : rcu_read_unlock();
161 : 0 : return ops;
162 : : }
163 : :
164 : : static void
165 : 0 : rpcauth_put_authops(const struct rpc_authops *ops)
166 : : {
167 : 0 : module_put(ops->owner);
168 : : }
169 : :
170 : : /**
171 : : * rpcauth_get_pseudoflavor - check if security flavor is supported
172 : : * @flavor: a security flavor
173 : : * @info: a GSS mech OID, quality of protection, and service value
174 : : *
175 : : * Verifies that an appropriate kernel module is available or already loaded.
176 : : * Returns an equivalent pseudoflavor, or RPC_AUTH_MAXFLAVOR if "flavor" is
177 : : * not supported locally.
178 : : */
179 : : rpc_authflavor_t
180 : 0 : rpcauth_get_pseudoflavor(rpc_authflavor_t flavor, struct rpcsec_gss_info *info)
181 : : {
182 : 0 : const struct rpc_authops *ops = rpcauth_get_authops(flavor);
183 : 0 : rpc_authflavor_t pseudoflavor;
184 : :
185 [ # # ]: 0 : if (!ops)
186 : : return RPC_AUTH_MAXFLAVOR;
187 : 0 : pseudoflavor = flavor;
188 [ # # ]: 0 : if (ops->info2flavor != NULL)
189 : 0 : pseudoflavor = ops->info2flavor(info);
190 : :
191 : 0 : rpcauth_put_authops(ops);
192 : 0 : return pseudoflavor;
193 : : }
194 : : EXPORT_SYMBOL_GPL(rpcauth_get_pseudoflavor);
195 : :
196 : : /**
197 : : * rpcauth_get_gssinfo - find GSS tuple matching a GSS pseudoflavor
198 : : * @pseudoflavor: GSS pseudoflavor to match
199 : : * @info: rpcsec_gss_info structure to fill in
200 : : *
201 : : * Returns zero and fills in "info" if pseudoflavor matches a
202 : : * supported mechanism.
203 : : */
204 : : int
205 : 0 : rpcauth_get_gssinfo(rpc_authflavor_t pseudoflavor, struct rpcsec_gss_info *info)
206 : : {
207 [ # # ]: 0 : rpc_authflavor_t flavor = pseudoflavor_to_flavor(pseudoflavor);
208 : 0 : const struct rpc_authops *ops;
209 : 0 : int result;
210 : :
211 : 0 : ops = rpcauth_get_authops(flavor);
212 [ # # ]: 0 : if (ops == NULL)
213 : : return -ENOENT;
214 : :
215 : 0 : result = -ENOENT;
216 [ # # ]: 0 : if (ops->flavor2info != NULL)
217 : 0 : result = ops->flavor2info(pseudoflavor, info);
218 : :
219 : 0 : rpcauth_put_authops(ops);
220 : 0 : return result;
221 : : }
222 : : EXPORT_SYMBOL_GPL(rpcauth_get_gssinfo);
223 : :
224 : : struct rpc_auth *
225 : 0 : rpcauth_create(const struct rpc_auth_create_args *args, struct rpc_clnt *clnt)
226 : : {
227 [ # # ]: 0 : struct rpc_auth *auth = ERR_PTR(-EINVAL);
228 : 0 : const struct rpc_authops *ops;
229 [ # # ]: 0 : u32 flavor = pseudoflavor_to_flavor(args->pseudoflavor);
230 : :
231 : 0 : ops = rpcauth_get_authops(flavor);
232 [ # # ]: 0 : if (ops == NULL)
233 : 0 : goto out;
234 : :
235 : 0 : auth = ops->create(args, clnt);
236 : :
237 : 0 : rpcauth_put_authops(ops);
238 [ # # ]: 0 : if (IS_ERR(auth))
239 : : return auth;
240 [ # # ]: 0 : if (clnt->cl_auth)
241 : 0 : rpcauth_release(clnt->cl_auth);
242 : 0 : clnt->cl_auth = auth;
243 : :
244 : : out:
245 : : return auth;
246 : : }
247 : : EXPORT_SYMBOL_GPL(rpcauth_create);
248 : :
249 : : void
250 : 0 : rpcauth_release(struct rpc_auth *auth)
251 : : {
252 [ # # ]: 0 : if (!refcount_dec_and_test(&auth->au_count))
253 : : return;
254 : 0 : auth->au_ops->destroy(auth);
255 : : }
256 : :
257 : : static DEFINE_SPINLOCK(rpc_credcache_lock);
258 : :
259 : : /*
260 : : * On success, the caller is responsible for freeing the reference
261 : : * held by the hashtable
262 : : */
263 : : static bool
264 : 0 : rpcauth_unhash_cred_locked(struct rpc_cred *cred)
265 : : {
266 [ # # ]: 0 : if (!test_and_clear_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags))
267 : : return false;
268 [ # # ]: 0 : hlist_del_rcu(&cred->cr_hash);
269 : 0 : return true;
270 : : }
271 : :
272 : : static bool
273 : 0 : rpcauth_unhash_cred(struct rpc_cred *cred)
274 : : {
275 : 0 : spinlock_t *cache_lock;
276 : 0 : bool ret;
277 : :
278 [ # # ]: 0 : if (!test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags))
279 : : return false;
280 : 0 : cache_lock = &cred->cr_auth->au_credcache->lock;
281 : 0 : spin_lock(cache_lock);
282 : 0 : ret = rpcauth_unhash_cred_locked(cred);
283 : 0 : spin_unlock(cache_lock);
284 : 0 : return ret;
285 : : }
286 : :
287 : : /*
288 : : * Initialize RPC credential cache
289 : : */
290 : : int
291 : 0 : rpcauth_init_credcache(struct rpc_auth *auth)
292 : : {
293 : 0 : struct rpc_cred_cache *new;
294 : 0 : unsigned int hashsize;
295 : :
296 : 0 : new = kmalloc(sizeof(*new), GFP_KERNEL);
297 [ # # ]: 0 : if (!new)
298 : 0 : goto out_nocache;
299 : 0 : new->hashbits = auth_hashbits;
300 : 0 : hashsize = 1U << new->hashbits;
301 : 0 : new->hashtable = kcalloc(hashsize, sizeof(new->hashtable[0]), GFP_KERNEL);
302 [ # # ]: 0 : if (!new->hashtable)
303 : 0 : goto out_nohashtbl;
304 : 0 : spin_lock_init(&new->lock);
305 : 0 : auth->au_credcache = new;
306 : 0 : return 0;
307 : : out_nohashtbl:
308 : 0 : kfree(new);
309 : : out_nocache:
310 : : return -ENOMEM;
311 : : }
312 : : EXPORT_SYMBOL_GPL(rpcauth_init_credcache);
313 : :
314 : : char *
315 : 0 : rpcauth_stringify_acceptor(struct rpc_cred *cred)
316 : : {
317 [ # # ]: 0 : if (!cred->cr_ops->crstringify_acceptor)
318 : : return NULL;
319 : 0 : return cred->cr_ops->crstringify_acceptor(cred);
320 : : }
321 : : EXPORT_SYMBOL_GPL(rpcauth_stringify_acceptor);
322 : :
323 : : /*
324 : : * Destroy a list of credentials
325 : : */
326 : : static inline
327 : 0 : void rpcauth_destroy_credlist(struct list_head *head)
328 : : {
329 : 0 : struct rpc_cred *cred;
330 : :
331 [ # # ]: 0 : while (!list_empty(head)) {
332 : 0 : cred = list_entry(head->next, struct rpc_cred, cr_lru);
333 : 0 : list_del_init(&cred->cr_lru);
334 : 0 : put_rpccred(cred);
335 : : }
336 : 0 : }
337 : :
338 : : static void
339 : 0 : rpcauth_lru_add_locked(struct rpc_cred *cred)
340 : : {
341 : 0 : if (!list_empty(&cred->cr_lru))
342 : : return;
343 : 0 : number_cred_unused++;
344 : 0 : list_add_tail(&cred->cr_lru, &cred_unused);
345 : : }
346 : :
347 : : static void
348 : 0 : rpcauth_lru_add(struct rpc_cred *cred)
349 : : {
350 [ # # ]: 0 : if (!list_empty(&cred->cr_lru))
351 : : return;
352 : 0 : spin_lock(&rpc_credcache_lock);
353 [ # # ]: 0 : rpcauth_lru_add_locked(cred);
354 : 0 : spin_unlock(&rpc_credcache_lock);
355 : : }
356 : :
357 : : static void
358 : 0 : rpcauth_lru_remove_locked(struct rpc_cred *cred)
359 : : {
360 : 0 : if (list_empty(&cred->cr_lru))
361 : : return;
362 : 0 : number_cred_unused--;
363 : 0 : list_del_init(&cred->cr_lru);
364 : : }
365 : :
366 : : static void
367 : 0 : rpcauth_lru_remove(struct rpc_cred *cred)
368 : : {
369 [ # # ]: 0 : if (list_empty(&cred->cr_lru))
370 : : return;
371 : 0 : spin_lock(&rpc_credcache_lock);
372 [ # # ]: 0 : rpcauth_lru_remove_locked(cred);
373 : 0 : spin_unlock(&rpc_credcache_lock);
374 : : }
375 : :
376 : : /*
377 : : * Clear the RPC credential cache, and delete those credentials
378 : : * that are not referenced.
379 : : */
380 : : void
381 : 0 : rpcauth_clear_credcache(struct rpc_cred_cache *cache)
382 : : {
383 : 0 : LIST_HEAD(free);
384 : 0 : struct hlist_head *head;
385 : 0 : struct rpc_cred *cred;
386 : 0 : unsigned int hashsize = 1U << cache->hashbits;
387 : 0 : int i;
388 : :
389 : 0 : spin_lock(&rpc_credcache_lock);
390 : 0 : spin_lock(&cache->lock);
391 [ # # ]: 0 : for (i = 0; i < hashsize; i++) {
392 : 0 : head = &cache->hashtable[i];
393 [ # # ]: 0 : while (!hlist_empty(head)) {
394 : 0 : cred = hlist_entry(head->first, struct rpc_cred, cr_hash);
395 : 0 : rpcauth_unhash_cred_locked(cred);
396 : : /* Note: We now hold a reference to cred */
397 [ # # ]: 0 : rpcauth_lru_remove_locked(cred);
398 : 0 : list_add_tail(&cred->cr_lru, &free);
399 : : }
400 : : }
401 : 0 : spin_unlock(&cache->lock);
402 : 0 : spin_unlock(&rpc_credcache_lock);
403 : 0 : rpcauth_destroy_credlist(&free);
404 : 0 : }
405 : :
406 : : /*
407 : : * Destroy the RPC credential cache
408 : : */
409 : : void
410 : 0 : rpcauth_destroy_credcache(struct rpc_auth *auth)
411 : : {
412 : 0 : struct rpc_cred_cache *cache = auth->au_credcache;
413 : :
414 [ # # ]: 0 : if (cache) {
415 : 0 : auth->au_credcache = NULL;
416 : 0 : rpcauth_clear_credcache(cache);
417 : 0 : kfree(cache->hashtable);
418 : 0 : kfree(cache);
419 : : }
420 : 0 : }
421 : : EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache);
422 : :
423 : :
424 : : #define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ)
425 : :
426 : : /*
427 : : * Remove stale credentials. Avoid sleeping inside the loop.
428 : : */
429 : : static long
430 : 0 : rpcauth_prune_expired(struct list_head *free, int nr_to_scan)
431 : : {
432 : 0 : struct rpc_cred *cred, *next;
433 : 0 : unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM;
434 : 0 : long freed = 0;
435 : :
436 [ # # ]: 0 : list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) {
437 : :
438 [ # # ]: 0 : if (nr_to_scan-- == 0)
439 : : break;
440 [ # # ]: 0 : if (refcount_read(&cred->cr_count) > 1) {
441 [ # # ]: 0 : rpcauth_lru_remove_locked(cred);
442 : 0 : continue;
443 : : }
444 : : /*
445 : : * Enforce a 60 second garbage collection moratorium
446 : : * Note that the cred_unused list must be time-ordered.
447 : : */
448 [ # # # # ]: 0 : if (!time_in_range(cred->cr_expire, expired, jiffies))
449 : 0 : continue;
450 [ # # ]: 0 : if (!rpcauth_unhash_cred(cred))
451 : 0 : continue;
452 : :
453 [ # # ]: 0 : rpcauth_lru_remove_locked(cred);
454 : 0 : freed++;
455 : 0 : list_add_tail(&cred->cr_lru, free);
456 : : }
457 [ # # ]: 0 : return freed ? freed : SHRINK_STOP;
458 : : }
459 : :
460 : : static unsigned long
461 : 0 : rpcauth_cache_do_shrink(int nr_to_scan)
462 : : {
463 : 0 : LIST_HEAD(free);
464 : 0 : unsigned long freed;
465 : :
466 : 0 : spin_lock(&rpc_credcache_lock);
467 : 0 : freed = rpcauth_prune_expired(&free, nr_to_scan);
468 : 0 : spin_unlock(&rpc_credcache_lock);
469 : 0 : rpcauth_destroy_credlist(&free);
470 : :
471 : 0 : return freed;
472 : : }
473 : :
474 : : /*
475 : : * Run memory cache shrinker.
476 : : */
477 : : static unsigned long
478 : 0 : rpcauth_cache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
479 : :
480 : : {
481 [ # # ]: 0 : if ((sc->gfp_mask & GFP_KERNEL) != GFP_KERNEL)
482 : : return SHRINK_STOP;
483 : :
484 : : /* nothing left, don't come back */
485 [ # # ]: 0 : if (list_empty(&cred_unused))
486 : : return SHRINK_STOP;
487 : :
488 : 0 : return rpcauth_cache_do_shrink(sc->nr_to_scan);
489 : : }
490 : :
491 : : static unsigned long
492 : 0 : rpcauth_cache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
493 : :
494 : : {
495 : 0 : return number_cred_unused * sysctl_vfs_cache_pressure / 100;
496 : : }
497 : :
498 : : static void
499 : 0 : rpcauth_cache_enforce_limit(void)
500 : : {
501 : 0 : unsigned long diff;
502 : 0 : unsigned int nr_to_scan;
503 : :
504 [ # # ]: 0 : if (number_cred_unused <= auth_max_cred_cachesize)
505 : : return;
506 : 0 : diff = number_cred_unused - auth_max_cred_cachesize;
507 : 0 : nr_to_scan = 100;
508 [ # # ]: 0 : if (diff < nr_to_scan)
509 : 0 : nr_to_scan = diff;
510 : 0 : rpcauth_cache_do_shrink(nr_to_scan);
511 : : }
512 : :
513 : : /*
514 : : * Look up a process' credentials in the authentication cache
515 : : */
516 : : struct rpc_cred *
517 : 0 : rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred,
518 : : int flags, gfp_t gfp)
519 : : {
520 : 0 : LIST_HEAD(free);
521 : 0 : struct rpc_cred_cache *cache = auth->au_credcache;
522 : 0 : struct rpc_cred *cred = NULL,
523 : : *entry, *new;
524 : 0 : unsigned int nr;
525 : :
526 : 0 : nr = auth->au_ops->hash_cred(acred, cache->hashbits);
527 : :
528 : 0 : rcu_read_lock();
529 [ # # # # : 0 : hlist_for_each_entry_rcu(entry, &cache->hashtable[nr], cr_hash) {
# # ]
530 [ # # ]: 0 : if (!entry->cr_ops->crmatch(acred, entry, flags))
531 : 0 : continue;
532 : 0 : cred = get_rpccred(entry);
533 : : if (cred)
534 : : break;
535 : : }
536 : 0 : rcu_read_unlock();
537 : :
538 [ # # ]: 0 : if (cred != NULL)
539 : 0 : goto found;
540 : :
541 : 0 : new = auth->au_ops->crcreate(auth, acred, flags, gfp);
542 [ # # ]: 0 : if (IS_ERR(new)) {
543 : 0 : cred = new;
544 : 0 : goto out;
545 : : }
546 : :
547 : 0 : spin_lock(&cache->lock);
548 [ # # # # : 0 : hlist_for_each_entry(entry, &cache->hashtable[nr], cr_hash) {
# # ]
549 [ # # ]: 0 : if (!entry->cr_ops->crmatch(acred, entry, flags))
550 : 0 : continue;
551 : 0 : cred = get_rpccred(entry);
552 : : if (cred)
553 : : break;
554 : : }
555 [ # # ]: 0 : if (cred == NULL) {
556 : 0 : cred = new;
557 : 0 : set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);
558 : 0 : refcount_inc(&cred->cr_count);
559 : 0 : hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]);
560 : : } else
561 : 0 : list_add_tail(&new->cr_lru, &free);
562 : 0 : spin_unlock(&cache->lock);
563 : 0 : rpcauth_cache_enforce_limit();
564 : 0 : found:
565 [ # # ]: 0 : if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) &&
566 [ # # ]: 0 : cred->cr_ops->cr_init != NULL &&
567 [ # # ]: 0 : !(flags & RPCAUTH_LOOKUP_NEW)) {
568 : 0 : int res = cred->cr_ops->cr_init(auth, cred);
569 [ # # ]: 0 : if (res < 0) {
570 : 0 : put_rpccred(cred);
571 : 0 : cred = ERR_PTR(res);
572 : : }
573 : : }
574 : 0 : rpcauth_destroy_credlist(&free);
575 : 0 : out:
576 : 0 : return cred;
577 : : }
578 : : EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache);
579 : :
580 : : struct rpc_cred *
581 : 0 : rpcauth_lookupcred(struct rpc_auth *auth, int flags)
582 : : {
583 : 0 : struct auth_cred acred;
584 : 0 : struct rpc_cred *ret;
585 : 0 : const struct cred *cred = current_cred();
586 : :
587 : 0 : memset(&acred, 0, sizeof(acred));
588 : 0 : acred.cred = cred;
589 : 0 : ret = auth->au_ops->lookup_cred(auth, &acred, flags);
590 : 0 : return ret;
591 : : }
592 : : EXPORT_SYMBOL_GPL(rpcauth_lookupcred);
593 : :
594 : : void
595 : 0 : rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred,
596 : : struct rpc_auth *auth, const struct rpc_credops *ops)
597 : : {
598 : 0 : INIT_HLIST_NODE(&cred->cr_hash);
599 : 0 : INIT_LIST_HEAD(&cred->cr_lru);
600 : 0 : refcount_set(&cred->cr_count, 1);
601 : 0 : cred->cr_auth = auth;
602 : 0 : cred->cr_flags = 0;
603 : 0 : cred->cr_ops = ops;
604 : 0 : cred->cr_expire = jiffies;
605 [ # # ]: 0 : cred->cr_cred = get_cred(acred->cred);
606 : 0 : }
607 : : EXPORT_SYMBOL_GPL(rpcauth_init_cred);
608 : :
609 : : static struct rpc_cred *
610 : : rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags)
611 : : {
612 : : struct rpc_auth *auth = task->tk_client->cl_auth;
613 : : struct auth_cred acred = {
614 : : .cred = get_task_cred(&init_task),
615 : : };
616 : : struct rpc_cred *ret;
617 : :
618 : : ret = auth->au_ops->lookup_cred(auth, &acred, lookupflags);
619 : : put_cred(acred.cred);
620 : : return ret;
621 : : }
622 : :
623 : : static struct rpc_cred *
624 : 0 : rpcauth_bind_machine_cred(struct rpc_task *task, int lookupflags)
625 : : {
626 : 0 : struct rpc_auth *auth = task->tk_client->cl_auth;
627 : 0 : struct auth_cred acred = {
628 : 0 : .principal = task->tk_client->cl_principal,
629 : 0 : .cred = init_task.cred,
630 : : };
631 : :
632 : 0 : if (!acred.principal)
633 : : return NULL;
634 : 0 : return auth->au_ops->lookup_cred(auth, &acred, lookupflags);
635 : : }
636 : :
637 : : static struct rpc_cred *
638 : 0 : rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags)
639 : : {
640 : 0 : struct rpc_auth *auth = task->tk_client->cl_auth;
641 : :
642 : 0 : return rpcauth_lookupcred(auth, lookupflags);
643 : : }
644 : :
645 : : static int
646 : 0 : rpcauth_bindcred(struct rpc_task *task, const struct cred *cred, int flags)
647 : : {
648 : 0 : struct rpc_rqst *req = task->tk_rqstp;
649 : 0 : struct rpc_cred *new = NULL;
650 : 0 : int lookupflags = 0;
651 : 0 : struct rpc_auth *auth = task->tk_client->cl_auth;
652 : 0 : struct auth_cred acred = {
653 : : .cred = cred,
654 : : };
655 : :
656 : 0 : if (flags & RPC_TASK_ASYNC)
657 : : lookupflags |= RPCAUTH_LOOKUP_NEW;
658 [ # # ]: 0 : if (task->tk_op_cred)
659 : : /* Task must use exactly this rpc_cred */
660 : 0 : new = get_rpccred(task->tk_op_cred);
661 [ # # # # ]: 0 : else if (cred != NULL && cred != &machine_cred)
662 : 0 : new = auth->au_ops->lookup_cred(auth, &acred, lookupflags);
663 [ # # ]: 0 : else if (cred == &machine_cred)
664 [ # # ]: 0 : new = rpcauth_bind_machine_cred(task, lookupflags);
665 : :
666 : : /* If machine cred couldn't be bound, try a root cred */
667 [ # # ]: 0 : if (new)
668 : : ;
669 [ # # # # ]: 0 : else if (cred == &machine_cred || (flags & RPC_TASK_ROOTCREDS))
670 : 0 : new = rpcauth_bind_root_cred(task, lookupflags);
671 [ # # ]: 0 : else if (flags & RPC_TASK_NULLCREDS)
672 : 0 : new = authnull_ops.lookup_cred(NULL, NULL, 0);
673 : : else
674 : 0 : new = rpcauth_bind_new_cred(task, lookupflags);
675 [ # # ]: 0 : if (IS_ERR(new))
676 : 0 : return PTR_ERR(new);
677 : 0 : put_rpccred(req->rq_cred);
678 : 0 : req->rq_cred = new;
679 : 0 : return 0;
680 : : }
681 : :
682 : : void
683 : 0 : put_rpccred(struct rpc_cred *cred)
684 : : {
685 [ # # ]: 0 : if (cred == NULL)
686 : : return;
687 : 0 : rcu_read_lock();
688 [ # # ]: 0 : if (refcount_dec_and_test(&cred->cr_count))
689 : 0 : goto destroy;
690 [ # # # # ]: 0 : if (refcount_read(&cred->cr_count) != 1 ||
691 : 0 : !test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags))
692 : 0 : goto out;
693 [ # # ]: 0 : if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0) {
694 : 0 : cred->cr_expire = jiffies;
695 : 0 : rpcauth_lru_add(cred);
696 : : /* Race breaker */
697 [ # # ]: 0 : if (unlikely(!test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags)))
698 : 0 : rpcauth_lru_remove(cred);
699 [ # # ]: 0 : } else if (rpcauth_unhash_cred(cred)) {
700 : 0 : rpcauth_lru_remove(cred);
701 [ # # ]: 0 : if (refcount_dec_and_test(&cred->cr_count))
702 : 0 : goto destroy;
703 : : }
704 : 0 : out:
705 : 0 : rcu_read_unlock();
706 : : return;
707 : 0 : destroy:
708 : 0 : rcu_read_unlock();
709 : 0 : cred->cr_ops->crdestroy(cred);
710 : : }
711 : : EXPORT_SYMBOL_GPL(put_rpccred);
712 : :
713 : : /**
714 : : * rpcauth_marshcred - Append RPC credential to end of @xdr
715 : : * @task: controlling RPC task
716 : : * @xdr: xdr_stream containing initial portion of RPC Call header
717 : : *
718 : : * On success, an appropriate verifier is added to @xdr, @xdr is
719 : : * updated to point past the verifier, and zero is returned.
720 : : * Otherwise, @xdr is in an undefined state and a negative errno
721 : : * is returned.
722 : : */
723 : 0 : int rpcauth_marshcred(struct rpc_task *task, struct xdr_stream *xdr)
724 : : {
725 : 0 : const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops;
726 : :
727 : 0 : return ops->crmarshal(task, xdr);
728 : : }
729 : :
730 : : /**
731 : : * rpcauth_wrap_req_encode - XDR encode the RPC procedure
732 : : * @task: controlling RPC task
733 : : * @xdr: stream where on-the-wire bytes are to be marshalled
734 : : *
735 : : * On success, @xdr contains the encoded and wrapped message.
736 : : * Otherwise, @xdr is in an undefined state.
737 : : */
738 : 0 : int rpcauth_wrap_req_encode(struct rpc_task *task, struct xdr_stream *xdr)
739 : : {
740 : 0 : kxdreproc_t encode = task->tk_msg.rpc_proc->p_encode;
741 : :
742 : 0 : encode(task->tk_rqstp, xdr, task->tk_msg.rpc_argp);
743 : 0 : return 0;
744 : : }
745 : : EXPORT_SYMBOL_GPL(rpcauth_wrap_req_encode);
746 : :
747 : : /**
748 : : * rpcauth_wrap_req - XDR encode and wrap the RPC procedure
749 : : * @task: controlling RPC task
750 : : * @xdr: stream where on-the-wire bytes are to be marshalled
751 : : *
752 : : * On success, @xdr contains the encoded and wrapped message,
753 : : * and zero is returned. Otherwise, @xdr is in an undefined
754 : : * state and a negative errno is returned.
755 : : */
756 : 0 : int rpcauth_wrap_req(struct rpc_task *task, struct xdr_stream *xdr)
757 : : {
758 : 0 : const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops;
759 : :
760 : 0 : return ops->crwrap_req(task, xdr);
761 : : }
762 : :
763 : : /**
764 : : * rpcauth_checkverf - Validate verifier in RPC Reply header
765 : : * @task: controlling RPC task
766 : : * @xdr: xdr_stream containing RPC Reply header
767 : : *
768 : : * On success, @xdr is updated to point past the verifier and
769 : : * zero is returned. Otherwise, @xdr is in an undefined state
770 : : * and a negative errno is returned.
771 : : */
772 : : int
773 : 0 : rpcauth_checkverf(struct rpc_task *task, struct xdr_stream *xdr)
774 : : {
775 : 0 : const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops;
776 : :
777 : 0 : return ops->crvalidate(task, xdr);
778 : : }
779 : :
780 : : /**
781 : : * rpcauth_unwrap_resp_decode - Invoke XDR decode function
782 : : * @task: controlling RPC task
783 : : * @xdr: stream where the Reply message resides
784 : : *
785 : : * Returns zero on success; otherwise a negative errno is returned.
786 : : */
787 : : int
788 : 0 : rpcauth_unwrap_resp_decode(struct rpc_task *task, struct xdr_stream *xdr)
789 : : {
790 : 0 : kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode;
791 : :
792 : 0 : return decode(task->tk_rqstp, xdr, task->tk_msg.rpc_resp);
793 : : }
794 : : EXPORT_SYMBOL_GPL(rpcauth_unwrap_resp_decode);
795 : :
796 : : /**
797 : : * rpcauth_unwrap_resp - Invoke unwrap and decode function for the cred
798 : : * @task: controlling RPC task
799 : : * @xdr: stream where the Reply message resides
800 : : *
801 : : * Returns zero on success; otherwise a negative errno is returned.
802 : : */
803 : : int
804 : 0 : rpcauth_unwrap_resp(struct rpc_task *task, struct xdr_stream *xdr)
805 : : {
806 : 0 : const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops;
807 : :
808 : 0 : return ops->crunwrap_resp(task, xdr);
809 : : }
810 : :
811 : : bool
812 : 0 : rpcauth_xmit_need_reencode(struct rpc_task *task)
813 : : {
814 : 0 : struct rpc_cred *cred = task->tk_rqstp->rq_cred;
815 : :
816 [ # # # # ]: 0 : if (!cred || !cred->cr_ops->crneed_reencode)
817 : : return false;
818 : 0 : return cred->cr_ops->crneed_reencode(task);
819 : : }
820 : :
821 : : int
822 : 0 : rpcauth_refreshcred(struct rpc_task *task)
823 : : {
824 : 0 : struct rpc_cred *cred;
825 : 0 : int err;
826 : :
827 : 0 : cred = task->tk_rqstp->rq_cred;
828 [ # # ]: 0 : if (cred == NULL) {
829 : 0 : err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags);
830 [ # # ]: 0 : if (err < 0)
831 : 0 : goto out;
832 : 0 : cred = task->tk_rqstp->rq_cred;
833 : : }
834 : :
835 : 0 : err = cred->cr_ops->crrefresh(task);
836 : 0 : out:
837 [ # # ]: 0 : if (err < 0)
838 : 0 : task->tk_status = err;
839 : 0 : return err;
840 : : }
841 : :
842 : : void
843 : 0 : rpcauth_invalcred(struct rpc_task *task)
844 : : {
845 : 0 : struct rpc_cred *cred = task->tk_rqstp->rq_cred;
846 : :
847 [ # # ]: 0 : if (cred)
848 : 0 : clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
849 : 0 : }
850 : :
851 : : int
852 : 0 : rpcauth_uptodatecred(struct rpc_task *task)
853 : : {
854 : 0 : struct rpc_cred *cred = task->tk_rqstp->rq_cred;
855 : :
856 [ # # # # ]: 0 : return cred == NULL ||
857 : 0 : test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0;
858 : : }
859 : :
860 : : static struct shrinker rpc_cred_shrinker = {
861 : : .count_objects = rpcauth_cache_shrink_count,
862 : : .scan_objects = rpcauth_cache_shrink_scan,
863 : : .seeks = DEFAULT_SEEKS,
864 : : };
865 : :
866 : 30 : int __init rpcauth_init_module(void)
867 : : {
868 : 30 : int err;
869 : :
870 : 30 : err = rpc_init_authunix();
871 [ - + ]: 30 : if (err < 0)
872 : 0 : goto out1;
873 : 30 : err = register_shrinker(&rpc_cred_shrinker);
874 [ - + ]: 30 : if (err < 0)
875 : 0 : goto out2;
876 : : return 0;
877 : : out2:
878 : 0 : rpc_destroy_authunix();
879 : : out1:
880 : : return err;
881 : : }
882 : :
883 : 0 : void rpcauth_remove_module(void)
884 : : {
885 : 0 : rpc_destroy_authunix();
886 : 0 : unregister_shrinker(&rpc_cred_shrinker);
887 : 0 : }
|
