1 // SPDX-License-Identifier: GPL-2.0-only
3 * linux/net/sunrpc/auth.c
5 * Generic RPC client authentication API.
7 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
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>
21 #include <trace/events/sunrpc.h>
23 #define RPC_CREDCACHE_DEFAULT_HASHBITS (4)
24 struct rpc_cred_cache
{
25 struct hlist_head
*hashtable
;
26 unsigned int hashbits
;
30 static unsigned int auth_hashbits
= RPC_CREDCACHE_DEFAULT_HASHBITS
;
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 */
38 static LIST_HEAD(cred_unused
);
39 static unsigned long number_cred_unused
;
41 static struct cred machine_cred
= {
42 .usage
= ATOMIC_INIT(1),
43 #ifdef CONFIG_DEBUG_CREDENTIALS
49 * Return the machine_cred pointer to be used whenever
50 * the a generic machine credential is needed.
52 const struct cred
*rpc_machine_cred(void)
56 EXPORT_SYMBOL_GPL(rpc_machine_cred
);
58 #define MAX_HASHTABLE_BITS (14)
59 static int param_set_hashtbl_sz(const char *val
, const struct kernel_param
*kp
)
67 ret
= kstrtoul(val
, 0, &num
);
71 if (nbits
> MAX_HASHTABLE_BITS
|| nbits
< 2)
73 *(unsigned int *)kp
->arg
= nbits
;
79 static int param_get_hashtbl_sz(char *buffer
, const struct kernel_param
*kp
)
83 nbits
= *(unsigned int *)kp
->arg
;
84 return sprintf(buffer
, "%u", 1U << nbits
);
87 #define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int);
89 static const struct kernel_param_ops param_ops_hashtbl_sz
= {
90 .set
= param_set_hashtbl_sz
,
91 .get
= param_get_hashtbl_sz
,
94 module_param_named(auth_hashtable_size
, auth_hashbits
, hashtbl_sz
, 0644);
95 MODULE_PARM_DESC(auth_hashtable_size
, "RPC credential cache hashtable size");
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");
102 pseudoflavor_to_flavor(u32 flavor
) {
103 if (flavor
> RPC_AUTH_MAXFLAVOR
)
109 rpcauth_register(const struct rpc_authops
*ops
)
111 const struct rpc_authops
*old
;
112 rpc_authflavor_t flavor
;
114 if ((flavor
= ops
->au_flavor
) >= RPC_AUTH_MAXFLAVOR
)
116 old
= cmpxchg((const struct rpc_authops
** __force
)&auth_flavors
[flavor
], NULL
, ops
);
117 if (old
== NULL
|| old
== ops
)
121 EXPORT_SYMBOL_GPL(rpcauth_register
);
124 rpcauth_unregister(const struct rpc_authops
*ops
)
126 const struct rpc_authops
*old
;
127 rpc_authflavor_t flavor
;
129 if ((flavor
= ops
->au_flavor
) >= RPC_AUTH_MAXFLAVOR
)
132 old
= cmpxchg((const struct rpc_authops
** __force
)&auth_flavors
[flavor
], ops
, NULL
);
133 if (old
== ops
|| old
== NULL
)
137 EXPORT_SYMBOL_GPL(rpcauth_unregister
);
139 static const struct rpc_authops
*
140 rpcauth_get_authops(rpc_authflavor_t flavor
)
142 const struct rpc_authops
*ops
;
144 if (flavor
>= RPC_AUTH_MAXFLAVOR
)
148 ops
= rcu_dereference(auth_flavors
[flavor
]);
151 request_module("rpc-auth-%u", flavor
);
153 ops
= rcu_dereference(auth_flavors
[flavor
]);
157 if (!try_module_get(ops
->owner
))
165 rpcauth_put_authops(const struct rpc_authops
*ops
)
167 module_put(ops
->owner
);
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
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.
180 rpcauth_get_pseudoflavor(rpc_authflavor_t flavor
, struct rpcsec_gss_info
*info
)
182 const struct rpc_authops
*ops
= rpcauth_get_authops(flavor
);
183 rpc_authflavor_t pseudoflavor
;
186 return RPC_AUTH_MAXFLAVOR
;
187 pseudoflavor
= flavor
;
188 if (ops
->info2flavor
!= NULL
)
189 pseudoflavor
= ops
->info2flavor(info
);
191 rpcauth_put_authops(ops
);
194 EXPORT_SYMBOL_GPL(rpcauth_get_pseudoflavor
);
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
201 * Returns zero and fills in "info" if pseudoflavor matches a
202 * supported mechanism.
205 rpcauth_get_gssinfo(rpc_authflavor_t pseudoflavor
, struct rpcsec_gss_info
*info
)
207 rpc_authflavor_t flavor
= pseudoflavor_to_flavor(pseudoflavor
);
208 const struct rpc_authops
*ops
;
211 ops
= rpcauth_get_authops(flavor
);
216 if (ops
->flavor2info
!= NULL
)
217 result
= ops
->flavor2info(pseudoflavor
, info
);
219 rpcauth_put_authops(ops
);
222 EXPORT_SYMBOL_GPL(rpcauth_get_gssinfo
);
225 * rpcauth_list_flavors - discover registered flavors and pseudoflavors
226 * @array: array to fill in
227 * @size: size of "array"
229 * Returns the number of array items filled in, or a negative errno.
231 * The returned array is not sorted by any policy. Callers should not
232 * rely on the order of the items in the returned array.
235 rpcauth_list_flavors(rpc_authflavor_t
*array
, int size
)
237 const struct rpc_authops
*ops
;
238 rpc_authflavor_t flavor
, pseudos
[4];
239 int i
, len
, result
= 0;
242 for (flavor
= 0; flavor
< RPC_AUTH_MAXFLAVOR
; flavor
++) {
243 ops
= rcu_dereference(auth_flavors
[flavor
]);
244 if (result
>= size
) {
251 if (ops
->list_pseudoflavors
== NULL
) {
252 array
[result
++] = ops
->au_flavor
;
255 len
= ops
->list_pseudoflavors(pseudos
, ARRAY_SIZE(pseudos
));
260 for (i
= 0; i
< len
; i
++) {
261 if (result
>= size
) {
265 array
[result
++] = pseudos
[i
];
271 EXPORT_SYMBOL_GPL(rpcauth_list_flavors
);
274 rpcauth_create(const struct rpc_auth_create_args
*args
, struct rpc_clnt
*clnt
)
276 struct rpc_auth
*auth
= ERR_PTR(-EINVAL
);
277 const struct rpc_authops
*ops
;
278 u32 flavor
= pseudoflavor_to_flavor(args
->pseudoflavor
);
280 ops
= rpcauth_get_authops(flavor
);
284 auth
= ops
->create(args
, clnt
);
286 rpcauth_put_authops(ops
);
290 rpcauth_release(clnt
->cl_auth
);
291 clnt
->cl_auth
= auth
;
296 EXPORT_SYMBOL_GPL(rpcauth_create
);
299 rpcauth_release(struct rpc_auth
*auth
)
301 if (!refcount_dec_and_test(&auth
->au_count
))
303 auth
->au_ops
->destroy(auth
);
306 static DEFINE_SPINLOCK(rpc_credcache_lock
);
309 * On success, the caller is responsible for freeing the reference
310 * held by the hashtable
313 rpcauth_unhash_cred_locked(struct rpc_cred
*cred
)
315 if (!test_and_clear_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
))
317 hlist_del_rcu(&cred
->cr_hash
);
322 rpcauth_unhash_cred(struct rpc_cred
*cred
)
324 spinlock_t
*cache_lock
;
327 if (!test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
))
329 cache_lock
= &cred
->cr_auth
->au_credcache
->lock
;
330 spin_lock(cache_lock
);
331 ret
= rpcauth_unhash_cred_locked(cred
);
332 spin_unlock(cache_lock
);
337 * Initialize RPC credential cache
340 rpcauth_init_credcache(struct rpc_auth
*auth
)
342 struct rpc_cred_cache
*new;
343 unsigned int hashsize
;
345 new = kmalloc(sizeof(*new), GFP_KERNEL
);
348 new->hashbits
= auth_hashbits
;
349 hashsize
= 1U << new->hashbits
;
350 new->hashtable
= kcalloc(hashsize
, sizeof(new->hashtable
[0]), GFP_KERNEL
);
353 spin_lock_init(&new->lock
);
354 auth
->au_credcache
= new;
361 EXPORT_SYMBOL_GPL(rpcauth_init_credcache
);
364 rpcauth_stringify_acceptor(struct rpc_cred
*cred
)
366 if (!cred
->cr_ops
->crstringify_acceptor
)
368 return cred
->cr_ops
->crstringify_acceptor(cred
);
370 EXPORT_SYMBOL_GPL(rpcauth_stringify_acceptor
);
373 * Destroy a list of credentials
376 void rpcauth_destroy_credlist(struct list_head
*head
)
378 struct rpc_cred
*cred
;
380 while (!list_empty(head
)) {
381 cred
= list_entry(head
->next
, struct rpc_cred
, cr_lru
);
382 list_del_init(&cred
->cr_lru
);
388 rpcauth_lru_add_locked(struct rpc_cred
*cred
)
390 if (!list_empty(&cred
->cr_lru
))
392 number_cred_unused
++;
393 list_add_tail(&cred
->cr_lru
, &cred_unused
);
397 rpcauth_lru_add(struct rpc_cred
*cred
)
399 if (!list_empty(&cred
->cr_lru
))
401 spin_lock(&rpc_credcache_lock
);
402 rpcauth_lru_add_locked(cred
);
403 spin_unlock(&rpc_credcache_lock
);
407 rpcauth_lru_remove_locked(struct rpc_cred
*cred
)
409 if (list_empty(&cred
->cr_lru
))
411 number_cred_unused
--;
412 list_del_init(&cred
->cr_lru
);
416 rpcauth_lru_remove(struct rpc_cred
*cred
)
418 if (list_empty(&cred
->cr_lru
))
420 spin_lock(&rpc_credcache_lock
);
421 rpcauth_lru_remove_locked(cred
);
422 spin_unlock(&rpc_credcache_lock
);
426 * Clear the RPC credential cache, and delete those credentials
427 * that are not referenced.
430 rpcauth_clear_credcache(struct rpc_cred_cache
*cache
)
433 struct hlist_head
*head
;
434 struct rpc_cred
*cred
;
435 unsigned int hashsize
= 1U << cache
->hashbits
;
438 spin_lock(&rpc_credcache_lock
);
439 spin_lock(&cache
->lock
);
440 for (i
= 0; i
< hashsize
; i
++) {
441 head
= &cache
->hashtable
[i
];
442 while (!hlist_empty(head
)) {
443 cred
= hlist_entry(head
->first
, struct rpc_cred
, cr_hash
);
444 rpcauth_unhash_cred_locked(cred
);
445 /* Note: We now hold a reference to cred */
446 rpcauth_lru_remove_locked(cred
);
447 list_add_tail(&cred
->cr_lru
, &free
);
450 spin_unlock(&cache
->lock
);
451 spin_unlock(&rpc_credcache_lock
);
452 rpcauth_destroy_credlist(&free
);
456 * Destroy the RPC credential cache
459 rpcauth_destroy_credcache(struct rpc_auth
*auth
)
461 struct rpc_cred_cache
*cache
= auth
->au_credcache
;
464 auth
->au_credcache
= NULL
;
465 rpcauth_clear_credcache(cache
);
466 kfree(cache
->hashtable
);
470 EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache
);
473 #define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ)
476 * Remove stale credentials. Avoid sleeping inside the loop.
479 rpcauth_prune_expired(struct list_head
*free
, int nr_to_scan
)
481 struct rpc_cred
*cred
, *next
;
482 unsigned long expired
= jiffies
- RPC_AUTH_EXPIRY_MORATORIUM
;
485 list_for_each_entry_safe(cred
, next
, &cred_unused
, cr_lru
) {
487 if (nr_to_scan
-- == 0)
489 if (refcount_read(&cred
->cr_count
) > 1) {
490 rpcauth_lru_remove_locked(cred
);
494 * Enforce a 60 second garbage collection moratorium
495 * Note that the cred_unused list must be time-ordered.
497 if (!time_in_range(cred
->cr_expire
, expired
, jiffies
))
499 if (!rpcauth_unhash_cred(cred
))
502 rpcauth_lru_remove_locked(cred
);
504 list_add_tail(&cred
->cr_lru
, free
);
506 return freed
? freed
: SHRINK_STOP
;
510 rpcauth_cache_do_shrink(int nr_to_scan
)
515 spin_lock(&rpc_credcache_lock
);
516 freed
= rpcauth_prune_expired(&free
, nr_to_scan
);
517 spin_unlock(&rpc_credcache_lock
);
518 rpcauth_destroy_credlist(&free
);
524 * Run memory cache shrinker.
527 rpcauth_cache_shrink_scan(struct shrinker
*shrink
, struct shrink_control
*sc
)
530 if ((sc
->gfp_mask
& GFP_KERNEL
) != GFP_KERNEL
)
533 /* nothing left, don't come back */
534 if (list_empty(&cred_unused
))
537 return rpcauth_cache_do_shrink(sc
->nr_to_scan
);
541 rpcauth_cache_shrink_count(struct shrinker
*shrink
, struct shrink_control
*sc
)
544 return number_cred_unused
* sysctl_vfs_cache_pressure
/ 100;
548 rpcauth_cache_enforce_limit(void)
551 unsigned int nr_to_scan
;
553 if (number_cred_unused
<= auth_max_cred_cachesize
)
555 diff
= number_cred_unused
- auth_max_cred_cachesize
;
557 if (diff
< nr_to_scan
)
559 rpcauth_cache_do_shrink(nr_to_scan
);
563 * Look up a process' credentials in the authentication cache
566 rpcauth_lookup_credcache(struct rpc_auth
*auth
, struct auth_cred
* acred
,
567 int flags
, gfp_t gfp
)
570 struct rpc_cred_cache
*cache
= auth
->au_credcache
;
571 struct rpc_cred
*cred
= NULL
,
575 nr
= auth
->au_ops
->hash_cred(acred
, cache
->hashbits
);
578 hlist_for_each_entry_rcu(entry
, &cache
->hashtable
[nr
], cr_hash
) {
579 if (!entry
->cr_ops
->crmatch(acred
, entry
, flags
))
581 cred
= get_rpccred(entry
);
590 new = auth
->au_ops
->crcreate(auth
, acred
, flags
, gfp
);
596 spin_lock(&cache
->lock
);
597 hlist_for_each_entry(entry
, &cache
->hashtable
[nr
], cr_hash
) {
598 if (!entry
->cr_ops
->crmatch(acred
, entry
, flags
))
600 cred
= get_rpccred(entry
);
606 set_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
);
607 refcount_inc(&cred
->cr_count
);
608 hlist_add_head_rcu(&cred
->cr_hash
, &cache
->hashtable
[nr
]);
610 list_add_tail(&new->cr_lru
, &free
);
611 spin_unlock(&cache
->lock
);
612 rpcauth_cache_enforce_limit();
614 if (test_bit(RPCAUTH_CRED_NEW
, &cred
->cr_flags
) &&
615 cred
->cr_ops
->cr_init
!= NULL
&&
616 !(flags
& RPCAUTH_LOOKUP_NEW
)) {
617 int res
= cred
->cr_ops
->cr_init(auth
, cred
);
623 rpcauth_destroy_credlist(&free
);
627 EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache
);
630 rpcauth_lookupcred(struct rpc_auth
*auth
, int flags
)
632 struct auth_cred acred
;
633 struct rpc_cred
*ret
;
634 const struct cred
*cred
= current_cred();
636 memset(&acred
, 0, sizeof(acred
));
638 ret
= auth
->au_ops
->lookup_cred(auth
, &acred
, flags
);
641 EXPORT_SYMBOL_GPL(rpcauth_lookupcred
);
644 rpcauth_init_cred(struct rpc_cred
*cred
, const struct auth_cred
*acred
,
645 struct rpc_auth
*auth
, const struct rpc_credops
*ops
)
647 INIT_HLIST_NODE(&cred
->cr_hash
);
648 INIT_LIST_HEAD(&cred
->cr_lru
);
649 refcount_set(&cred
->cr_count
, 1);
650 cred
->cr_auth
= auth
;
653 cred
->cr_expire
= jiffies
;
654 cred
->cr_cred
= get_cred(acred
->cred
);
656 EXPORT_SYMBOL_GPL(rpcauth_init_cred
);
658 static struct rpc_cred
*
659 rpcauth_bind_root_cred(struct rpc_task
*task
, int lookupflags
)
661 struct rpc_auth
*auth
= task
->tk_client
->cl_auth
;
662 struct auth_cred acred
= {
663 .cred
= get_task_cred(&init_task
),
665 struct rpc_cred
*ret
;
667 ret
= auth
->au_ops
->lookup_cred(auth
, &acred
, lookupflags
);
668 put_cred(acred
.cred
);
672 static struct rpc_cred
*
673 rpcauth_bind_machine_cred(struct rpc_task
*task
, int lookupflags
)
675 struct rpc_auth
*auth
= task
->tk_client
->cl_auth
;
676 struct auth_cred acred
= {
677 .principal
= task
->tk_client
->cl_principal
,
678 .cred
= init_task
.cred
,
681 if (!acred
.principal
)
683 return auth
->au_ops
->lookup_cred(auth
, &acred
, lookupflags
);
686 static struct rpc_cred
*
687 rpcauth_bind_new_cred(struct rpc_task
*task
, int lookupflags
)
689 struct rpc_auth
*auth
= task
->tk_client
->cl_auth
;
691 return rpcauth_lookupcred(auth
, lookupflags
);
695 rpcauth_bindcred(struct rpc_task
*task
, const struct cred
*cred
, int flags
)
697 struct rpc_rqst
*req
= task
->tk_rqstp
;
698 struct rpc_cred
*new = NULL
;
700 struct rpc_auth
*auth
= task
->tk_client
->cl_auth
;
701 struct auth_cred acred
= {
705 if (flags
& RPC_TASK_ASYNC
)
706 lookupflags
|= RPCAUTH_LOOKUP_NEW
;
707 if (task
->tk_op_cred
)
708 /* Task must use exactly this rpc_cred */
709 new = get_rpccred(task
->tk_op_cred
);
710 else if (cred
!= NULL
&& cred
!= &machine_cred
)
711 new = auth
->au_ops
->lookup_cred(auth
, &acred
, lookupflags
);
712 else if (cred
== &machine_cred
)
713 new = rpcauth_bind_machine_cred(task
, lookupflags
);
715 /* If machine cred couldn't be bound, try a root cred */
718 else if (cred
== &machine_cred
|| (flags
& RPC_TASK_ROOTCREDS
))
719 new = rpcauth_bind_root_cred(task
, lookupflags
);
720 else if (flags
& RPC_TASK_NULLCREDS
)
721 new = authnull_ops
.lookup_cred(NULL
, NULL
, 0);
723 new = rpcauth_bind_new_cred(task
, lookupflags
);
726 put_rpccred(req
->rq_cred
);
732 put_rpccred(struct rpc_cred
*cred
)
737 if (refcount_dec_and_test(&cred
->cr_count
))
739 if (refcount_read(&cred
->cr_count
) != 1 ||
740 !test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
))
742 if (test_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
) != 0) {
743 cred
->cr_expire
= jiffies
;
744 rpcauth_lru_add(cred
);
746 if (unlikely(!test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
)))
747 rpcauth_lru_remove(cred
);
748 } else if (rpcauth_unhash_cred(cred
)) {
749 rpcauth_lru_remove(cred
);
750 if (refcount_dec_and_test(&cred
->cr_count
))
758 cred
->cr_ops
->crdestroy(cred
);
760 EXPORT_SYMBOL_GPL(put_rpccred
);
763 * rpcauth_marshcred - Append RPC credential to end of @xdr
764 * @task: controlling RPC task
765 * @xdr: xdr_stream containing initial portion of RPC Call header
767 * On success, an appropriate verifier is added to @xdr, @xdr is
768 * updated to point past the verifier, and zero is returned.
769 * Otherwise, @xdr is in an undefined state and a negative errno
772 int rpcauth_marshcred(struct rpc_task
*task
, struct xdr_stream
*xdr
)
774 const struct rpc_credops
*ops
= task
->tk_rqstp
->rq_cred
->cr_ops
;
776 return ops
->crmarshal(task
, xdr
);
780 * rpcauth_wrap_req_encode - XDR encode the RPC procedure
781 * @task: controlling RPC task
782 * @xdr: stream where on-the-wire bytes are to be marshalled
784 * On success, @xdr contains the encoded and wrapped message.
785 * Otherwise, @xdr is in an undefined state.
787 int rpcauth_wrap_req_encode(struct rpc_task
*task
, struct xdr_stream
*xdr
)
789 kxdreproc_t encode
= task
->tk_msg
.rpc_proc
->p_encode
;
791 encode(task
->tk_rqstp
, xdr
, task
->tk_msg
.rpc_argp
);
794 EXPORT_SYMBOL_GPL(rpcauth_wrap_req_encode
);
797 * rpcauth_wrap_req - XDR encode and wrap the RPC procedure
798 * @task: controlling RPC task
799 * @xdr: stream where on-the-wire bytes are to be marshalled
801 * On success, @xdr contains the encoded and wrapped message,
802 * and zero is returned. Otherwise, @xdr is in an undefined
803 * state and a negative errno is returned.
805 int rpcauth_wrap_req(struct rpc_task
*task
, struct xdr_stream
*xdr
)
807 const struct rpc_credops
*ops
= task
->tk_rqstp
->rq_cred
->cr_ops
;
809 return ops
->crwrap_req(task
, xdr
);
813 * rpcauth_checkverf - Validate verifier in RPC Reply header
814 * @task: controlling RPC task
815 * @xdr: xdr_stream containing RPC Reply header
817 * On success, @xdr is updated to point past the verifier and
818 * zero is returned. Otherwise, @xdr is in an undefined state
819 * and a negative errno is returned.
822 rpcauth_checkverf(struct rpc_task
*task
, struct xdr_stream
*xdr
)
824 const struct rpc_credops
*ops
= task
->tk_rqstp
->rq_cred
->cr_ops
;
826 return ops
->crvalidate(task
, xdr
);
830 * rpcauth_unwrap_resp_decode - Invoke XDR decode function
831 * @task: controlling RPC task
832 * @xdr: stream where the Reply message resides
834 * Returns zero on success; otherwise a negative errno is returned.
837 rpcauth_unwrap_resp_decode(struct rpc_task
*task
, struct xdr_stream
*xdr
)
839 kxdrdproc_t decode
= task
->tk_msg
.rpc_proc
->p_decode
;
841 return decode(task
->tk_rqstp
, xdr
, task
->tk_msg
.rpc_resp
);
843 EXPORT_SYMBOL_GPL(rpcauth_unwrap_resp_decode
);
846 * rpcauth_unwrap_resp - Invoke unwrap and decode function for the cred
847 * @task: controlling RPC task
848 * @xdr: stream where the Reply message resides
850 * Returns zero on success; otherwise a negative errno is returned.
853 rpcauth_unwrap_resp(struct rpc_task
*task
, struct xdr_stream
*xdr
)
855 const struct rpc_credops
*ops
= task
->tk_rqstp
->rq_cred
->cr_ops
;
857 return ops
->crunwrap_resp(task
, xdr
);
861 rpcauth_xmit_need_reencode(struct rpc_task
*task
)
863 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
865 if (!cred
|| !cred
->cr_ops
->crneed_reencode
)
867 return cred
->cr_ops
->crneed_reencode(task
);
871 rpcauth_refreshcred(struct rpc_task
*task
)
873 struct rpc_cred
*cred
;
876 cred
= task
->tk_rqstp
->rq_cred
;
878 err
= rpcauth_bindcred(task
, task
->tk_msg
.rpc_cred
, task
->tk_flags
);
881 cred
= task
->tk_rqstp
->rq_cred
;
884 err
= cred
->cr_ops
->crrefresh(task
);
887 task
->tk_status
= err
;
892 rpcauth_invalcred(struct rpc_task
*task
)
894 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
897 clear_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
);
901 rpcauth_uptodatecred(struct rpc_task
*task
)
903 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
905 return cred
== NULL
||
906 test_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
) != 0;
909 static struct shrinker rpc_cred_shrinker
= {
910 .count_objects
= rpcauth_cache_shrink_count
,
911 .scan_objects
= rpcauth_cache_shrink_scan
,
912 .seeks
= DEFAULT_SEEKS
,
915 int __init
rpcauth_init_module(void)
919 err
= rpc_init_authunix();
922 err
= register_shrinker(&rpc_cred_shrinker
);
927 rpc_destroy_authunix();
932 void rpcauth_remove_module(void)
934 rpc_destroy_authunix();
935 unregister_shrinker(&rpc_cred_shrinker
);