2 * linux/net/sunrpc/auth.c
4 * Generic RPC client authentication API.
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
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>
14 #include <linux/hash.h>
15 #include <linux/sunrpc/clnt.h>
16 #include <linux/sunrpc/gss_api.h>
17 #include <linux/spinlock.h>
20 # define RPCDBG_FACILITY RPCDBG_AUTH
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 DEFINE_SPINLOCK(rpc_authflavor_lock
);
33 static const struct rpc_authops
*auth_flavors
[RPC_AUTH_MAXFLAVOR
] = {
34 &authnull_ops
, /* AUTH_NULL */
35 &authunix_ops
, /* AUTH_UNIX */
36 NULL
, /* others can be loadable modules */
39 static LIST_HEAD(cred_unused
);
40 static unsigned long number_cred_unused
;
42 #define MAX_HASHTABLE_BITS (14)
43 static int param_set_hashtbl_sz(const char *val
, const struct kernel_param
*kp
)
51 ret
= strict_strtoul(val
, 0, &num
);
55 if (num
> (1U << nbits
))
57 if (nbits
> MAX_HASHTABLE_BITS
|| nbits
< 2)
59 *(unsigned int *)kp
->arg
= nbits
;
65 static int param_get_hashtbl_sz(char *buffer
, const struct kernel_param
*kp
)
69 nbits
= *(unsigned int *)kp
->arg
;
70 return sprintf(buffer
, "%u", 1U << nbits
);
73 #define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int);
75 static struct kernel_param_ops param_ops_hashtbl_sz
= {
76 .set
= param_set_hashtbl_sz
,
77 .get
= param_get_hashtbl_sz
,
80 module_param_named(auth_hashtable_size
, auth_hashbits
, hashtbl_sz
, 0644);
81 MODULE_PARM_DESC(auth_hashtable_size
, "RPC credential cache hashtable size");
84 pseudoflavor_to_flavor(u32 flavor
) {
85 if (flavor
> RPC_AUTH_MAXFLAVOR
)
91 rpcauth_register(const struct rpc_authops
*ops
)
93 rpc_authflavor_t flavor
;
96 if ((flavor
= ops
->au_flavor
) >= RPC_AUTH_MAXFLAVOR
)
98 spin_lock(&rpc_authflavor_lock
);
99 if (auth_flavors
[flavor
] == NULL
) {
100 auth_flavors
[flavor
] = ops
;
103 spin_unlock(&rpc_authflavor_lock
);
106 EXPORT_SYMBOL_GPL(rpcauth_register
);
109 rpcauth_unregister(const struct rpc_authops
*ops
)
111 rpc_authflavor_t flavor
;
114 if ((flavor
= ops
->au_flavor
) >= RPC_AUTH_MAXFLAVOR
)
116 spin_lock(&rpc_authflavor_lock
);
117 if (auth_flavors
[flavor
] == ops
) {
118 auth_flavors
[flavor
] = NULL
;
121 spin_unlock(&rpc_authflavor_lock
);
124 EXPORT_SYMBOL_GPL(rpcauth_unregister
);
127 * rpcauth_get_pseudoflavor - check if security flavor is supported
128 * @flavor: a security flavor
129 * @info: a GSS mech OID, quality of protection, and service value
131 * Verifies that an appropriate kernel module is available or already loaded.
132 * Returns an equivalent pseudoflavor, or RPC_AUTH_MAXFLAVOR if "flavor" is
133 * not supported locally.
136 rpcauth_get_pseudoflavor(rpc_authflavor_t flavor
, struct rpcsec_gss_info
*info
)
138 const struct rpc_authops
*ops
;
139 rpc_authflavor_t pseudoflavor
;
141 ops
= auth_flavors
[flavor
];
143 request_module("rpc-auth-%u", flavor
);
144 spin_lock(&rpc_authflavor_lock
);
145 ops
= auth_flavors
[flavor
];
146 if (ops
== NULL
|| !try_module_get(ops
->owner
)) {
147 spin_unlock(&rpc_authflavor_lock
);
148 return RPC_AUTH_MAXFLAVOR
;
150 spin_unlock(&rpc_authflavor_lock
);
152 pseudoflavor
= flavor
;
153 if (ops
->info2flavor
!= NULL
)
154 pseudoflavor
= ops
->info2flavor(info
);
156 module_put(ops
->owner
);
159 EXPORT_SYMBOL_GPL(rpcauth_get_pseudoflavor
);
162 * rpcauth_get_gssinfo - find GSS tuple matching a GSS pseudoflavor
163 * @pseudoflavor: GSS pseudoflavor to match
164 * @info: rpcsec_gss_info structure to fill in
166 * Returns zero and fills in "info" if pseudoflavor matches a
167 * supported mechanism.
170 rpcauth_get_gssinfo(rpc_authflavor_t pseudoflavor
, struct rpcsec_gss_info
*info
)
172 rpc_authflavor_t flavor
= pseudoflavor_to_flavor(pseudoflavor
);
173 const struct rpc_authops
*ops
;
176 if (flavor
>= RPC_AUTH_MAXFLAVOR
)
179 ops
= auth_flavors
[flavor
];
181 request_module("rpc-auth-%u", flavor
);
182 spin_lock(&rpc_authflavor_lock
);
183 ops
= auth_flavors
[flavor
];
184 if (ops
== NULL
|| !try_module_get(ops
->owner
)) {
185 spin_unlock(&rpc_authflavor_lock
);
188 spin_unlock(&rpc_authflavor_lock
);
191 if (ops
->flavor2info
!= NULL
)
192 result
= ops
->flavor2info(pseudoflavor
, info
);
194 module_put(ops
->owner
);
197 EXPORT_SYMBOL_GPL(rpcauth_get_gssinfo
);
200 * rpcauth_list_flavors - discover registered flavors and pseudoflavors
201 * @array: array to fill in
202 * @size: size of "array"
204 * Returns the number of array items filled in, or a negative errno.
206 * The returned array is not sorted by any policy. Callers should not
207 * rely on the order of the items in the returned array.
210 rpcauth_list_flavors(rpc_authflavor_t
*array
, int size
)
212 rpc_authflavor_t flavor
;
215 spin_lock(&rpc_authflavor_lock
);
216 for (flavor
= 0; flavor
< RPC_AUTH_MAXFLAVOR
; flavor
++) {
217 const struct rpc_authops
*ops
= auth_flavors
[flavor
];
218 rpc_authflavor_t pseudos
[4];
221 if (result
>= size
) {
228 if (ops
->list_pseudoflavors
== NULL
) {
229 array
[result
++] = ops
->au_flavor
;
232 len
= ops
->list_pseudoflavors(pseudos
, ARRAY_SIZE(pseudos
));
237 for (i
= 0; i
< len
; i
++) {
238 if (result
>= size
) {
242 array
[result
++] = pseudos
[i
];
245 spin_unlock(&rpc_authflavor_lock
);
247 dprintk("RPC: %s returns %d\n", __func__
, result
);
250 EXPORT_SYMBOL_GPL(rpcauth_list_flavors
);
253 rpcauth_create(struct rpc_auth_create_args
*args
, struct rpc_clnt
*clnt
)
255 struct rpc_auth
*auth
;
256 const struct rpc_authops
*ops
;
257 u32 flavor
= pseudoflavor_to_flavor(args
->pseudoflavor
);
259 auth
= ERR_PTR(-EINVAL
);
260 if (flavor
>= RPC_AUTH_MAXFLAVOR
)
263 if ((ops
= auth_flavors
[flavor
]) == NULL
)
264 request_module("rpc-auth-%u", flavor
);
265 spin_lock(&rpc_authflavor_lock
);
266 ops
= auth_flavors
[flavor
];
267 if (ops
== NULL
|| !try_module_get(ops
->owner
)) {
268 spin_unlock(&rpc_authflavor_lock
);
271 spin_unlock(&rpc_authflavor_lock
);
272 auth
= ops
->create(args
, clnt
);
273 module_put(ops
->owner
);
277 rpcauth_release(clnt
->cl_auth
);
278 clnt
->cl_auth
= auth
;
283 EXPORT_SYMBOL_GPL(rpcauth_create
);
286 rpcauth_release(struct rpc_auth
*auth
)
288 if (!atomic_dec_and_test(&auth
->au_count
))
290 auth
->au_ops
->destroy(auth
);
293 static DEFINE_SPINLOCK(rpc_credcache_lock
);
296 rpcauth_unhash_cred_locked(struct rpc_cred
*cred
)
298 hlist_del_rcu(&cred
->cr_hash
);
299 smp_mb__before_atomic();
300 clear_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
);
304 rpcauth_unhash_cred(struct rpc_cred
*cred
)
306 spinlock_t
*cache_lock
;
309 cache_lock
= &cred
->cr_auth
->au_credcache
->lock
;
310 spin_lock(cache_lock
);
311 ret
= atomic_read(&cred
->cr_count
) == 0;
313 rpcauth_unhash_cred_locked(cred
);
314 spin_unlock(cache_lock
);
319 * Initialize RPC credential cache
322 rpcauth_init_credcache(struct rpc_auth
*auth
)
324 struct rpc_cred_cache
*new;
325 unsigned int hashsize
;
327 new = kmalloc(sizeof(*new), GFP_KERNEL
);
330 new->hashbits
= auth_hashbits
;
331 hashsize
= 1U << new->hashbits
;
332 new->hashtable
= kcalloc(hashsize
, sizeof(new->hashtable
[0]), GFP_KERNEL
);
335 spin_lock_init(&new->lock
);
336 auth
->au_credcache
= new;
343 EXPORT_SYMBOL_GPL(rpcauth_init_credcache
);
346 * Setup a credential key lifetime timeout notification
349 rpcauth_key_timeout_notify(struct rpc_auth
*auth
, struct rpc_cred
*cred
)
351 if (!cred
->cr_auth
->au_ops
->key_timeout
)
353 return cred
->cr_auth
->au_ops
->key_timeout(auth
, cred
);
355 EXPORT_SYMBOL_GPL(rpcauth_key_timeout_notify
);
358 rpcauth_cred_key_to_expire(struct rpc_cred
*cred
)
360 if (!cred
->cr_ops
->crkey_to_expire
)
362 return cred
->cr_ops
->crkey_to_expire(cred
);
364 EXPORT_SYMBOL_GPL(rpcauth_cred_key_to_expire
);
367 rpcauth_stringify_acceptor(struct rpc_cred
*cred
)
369 if (!cred
->cr_ops
->crstringify_acceptor
)
371 return cred
->cr_ops
->crstringify_acceptor(cred
);
373 EXPORT_SYMBOL_GPL(rpcauth_stringify_acceptor
);
376 * Destroy a list of credentials
379 void rpcauth_destroy_credlist(struct list_head
*head
)
381 struct rpc_cred
*cred
;
383 while (!list_empty(head
)) {
384 cred
= list_entry(head
->next
, struct rpc_cred
, cr_lru
);
385 list_del_init(&cred
->cr_lru
);
391 * Clear the RPC credential cache, and delete those credentials
392 * that are not referenced.
395 rpcauth_clear_credcache(struct rpc_cred_cache
*cache
)
398 struct hlist_head
*head
;
399 struct rpc_cred
*cred
;
400 unsigned int hashsize
= 1U << cache
->hashbits
;
403 spin_lock(&rpc_credcache_lock
);
404 spin_lock(&cache
->lock
);
405 for (i
= 0; i
< hashsize
; i
++) {
406 head
= &cache
->hashtable
[i
];
407 while (!hlist_empty(head
)) {
408 cred
= hlist_entry(head
->first
, struct rpc_cred
, cr_hash
);
410 if (!list_empty(&cred
->cr_lru
)) {
411 list_del(&cred
->cr_lru
);
412 number_cred_unused
--;
414 list_add_tail(&cred
->cr_lru
, &free
);
415 rpcauth_unhash_cred_locked(cred
);
418 spin_unlock(&cache
->lock
);
419 spin_unlock(&rpc_credcache_lock
);
420 rpcauth_destroy_credlist(&free
);
424 * Destroy the RPC credential cache
427 rpcauth_destroy_credcache(struct rpc_auth
*auth
)
429 struct rpc_cred_cache
*cache
= auth
->au_credcache
;
432 auth
->au_credcache
= NULL
;
433 rpcauth_clear_credcache(cache
);
434 kfree(cache
->hashtable
);
438 EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache
);
441 #define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ)
444 * Remove stale credentials. Avoid sleeping inside the loop.
447 rpcauth_prune_expired(struct list_head
*free
, int nr_to_scan
)
449 spinlock_t
*cache_lock
;
450 struct rpc_cred
*cred
, *next
;
451 unsigned long expired
= jiffies
- RPC_AUTH_EXPIRY_MORATORIUM
;
454 list_for_each_entry_safe(cred
, next
, &cred_unused
, cr_lru
) {
456 if (nr_to_scan
-- == 0)
459 * Enforce a 60 second garbage collection moratorium
460 * Note that the cred_unused list must be time-ordered.
462 if (time_in_range(cred
->cr_expire
, expired
, jiffies
) &&
463 test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
) != 0)
466 list_del_init(&cred
->cr_lru
);
467 number_cred_unused
--;
469 if (atomic_read(&cred
->cr_count
) != 0)
472 cache_lock
= &cred
->cr_auth
->au_credcache
->lock
;
473 spin_lock(cache_lock
);
474 if (atomic_read(&cred
->cr_count
) == 0) {
476 list_add_tail(&cred
->cr_lru
, free
);
477 rpcauth_unhash_cred_locked(cred
);
479 spin_unlock(cache_lock
);
485 * Run memory cache shrinker.
488 rpcauth_cache_shrink_scan(struct shrinker
*shrink
, struct shrink_control
*sc
)
494 if ((sc
->gfp_mask
& GFP_KERNEL
) != GFP_KERNEL
)
497 /* nothing left, don't come back */
498 if (list_empty(&cred_unused
))
501 spin_lock(&rpc_credcache_lock
);
502 freed
= rpcauth_prune_expired(&free
, sc
->nr_to_scan
);
503 spin_unlock(&rpc_credcache_lock
);
504 rpcauth_destroy_credlist(&free
);
510 rpcauth_cache_shrink_count(struct shrinker
*shrink
, struct shrink_control
*sc
)
513 return (number_cred_unused
/ 100) * sysctl_vfs_cache_pressure
;
517 * Look up a process' credentials in the authentication cache
520 rpcauth_lookup_credcache(struct rpc_auth
*auth
, struct auth_cred
* acred
,
524 struct rpc_cred_cache
*cache
= auth
->au_credcache
;
525 struct rpc_cred
*cred
= NULL
,
529 nr
= hash_long(from_kuid(&init_user_ns
, acred
->uid
), cache
->hashbits
);
532 hlist_for_each_entry_rcu(entry
, &cache
->hashtable
[nr
], cr_hash
) {
533 if (!entry
->cr_ops
->crmatch(acred
, entry
, flags
))
535 spin_lock(&cache
->lock
);
536 if (test_bit(RPCAUTH_CRED_HASHED
, &entry
->cr_flags
) == 0) {
537 spin_unlock(&cache
->lock
);
540 cred
= get_rpccred(entry
);
541 spin_unlock(&cache
->lock
);
549 new = auth
->au_ops
->crcreate(auth
, acred
, flags
);
555 spin_lock(&cache
->lock
);
556 hlist_for_each_entry(entry
, &cache
->hashtable
[nr
], cr_hash
) {
557 if (!entry
->cr_ops
->crmatch(acred
, entry
, flags
))
559 cred
= get_rpccred(entry
);
564 set_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
);
565 hlist_add_head_rcu(&cred
->cr_hash
, &cache
->hashtable
[nr
]);
567 list_add_tail(&new->cr_lru
, &free
);
568 spin_unlock(&cache
->lock
);
570 if (test_bit(RPCAUTH_CRED_NEW
, &cred
->cr_flags
) &&
571 cred
->cr_ops
->cr_init
!= NULL
&&
572 !(flags
& RPCAUTH_LOOKUP_NEW
)) {
573 int res
= cred
->cr_ops
->cr_init(auth
, cred
);
579 rpcauth_destroy_credlist(&free
);
583 EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache
);
586 rpcauth_lookupcred(struct rpc_auth
*auth
, int flags
)
588 struct auth_cred acred
;
589 struct rpc_cred
*ret
;
590 const struct cred
*cred
= current_cred();
592 dprintk("RPC: looking up %s cred\n",
593 auth
->au_ops
->au_name
);
595 memset(&acred
, 0, sizeof(acred
));
596 acred
.uid
= cred
->fsuid
;
597 acred
.gid
= cred
->fsgid
;
598 acred
.group_info
= get_group_info(((struct cred
*)cred
)->group_info
);
600 ret
= auth
->au_ops
->lookup_cred(auth
, &acred
, flags
);
601 put_group_info(acred
.group_info
);
604 EXPORT_SYMBOL_GPL(rpcauth_lookupcred
);
607 rpcauth_init_cred(struct rpc_cred
*cred
, const struct auth_cred
*acred
,
608 struct rpc_auth
*auth
, const struct rpc_credops
*ops
)
610 INIT_HLIST_NODE(&cred
->cr_hash
);
611 INIT_LIST_HEAD(&cred
->cr_lru
);
612 atomic_set(&cred
->cr_count
, 1);
613 cred
->cr_auth
= auth
;
615 cred
->cr_expire
= jiffies
;
617 cred
->cr_magic
= RPCAUTH_CRED_MAGIC
;
619 cred
->cr_uid
= acred
->uid
;
621 EXPORT_SYMBOL_GPL(rpcauth_init_cred
);
624 rpcauth_generic_bind_cred(struct rpc_task
*task
, struct rpc_cred
*cred
, int lookupflags
)
626 dprintk("RPC: %5u holding %s cred %p\n", task
->tk_pid
,
627 cred
->cr_auth
->au_ops
->au_name
, cred
);
628 return get_rpccred(cred
);
630 EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred
);
632 static struct rpc_cred
*
633 rpcauth_bind_root_cred(struct rpc_task
*task
, int lookupflags
)
635 struct rpc_auth
*auth
= task
->tk_client
->cl_auth
;
636 struct auth_cred acred
= {
637 .uid
= GLOBAL_ROOT_UID
,
638 .gid
= GLOBAL_ROOT_GID
,
641 dprintk("RPC: %5u looking up %s cred\n",
642 task
->tk_pid
, task
->tk_client
->cl_auth
->au_ops
->au_name
);
643 return auth
->au_ops
->lookup_cred(auth
, &acred
, lookupflags
);
646 static struct rpc_cred
*
647 rpcauth_bind_new_cred(struct rpc_task
*task
, int lookupflags
)
649 struct rpc_auth
*auth
= task
->tk_client
->cl_auth
;
651 dprintk("RPC: %5u looking up %s cred\n",
652 task
->tk_pid
, auth
->au_ops
->au_name
);
653 return rpcauth_lookupcred(auth
, lookupflags
);
657 rpcauth_bindcred(struct rpc_task
*task
, struct rpc_cred
*cred
, int flags
)
659 struct rpc_rqst
*req
= task
->tk_rqstp
;
660 struct rpc_cred
*new;
663 if (flags
& RPC_TASK_ASYNC
)
664 lookupflags
|= RPCAUTH_LOOKUP_NEW
;
666 new = cred
->cr_ops
->crbind(task
, cred
, lookupflags
);
667 else if (flags
& RPC_TASK_ROOTCREDS
)
668 new = rpcauth_bind_root_cred(task
, lookupflags
);
670 new = rpcauth_bind_new_cred(task
, lookupflags
);
673 if (req
->rq_cred
!= NULL
)
674 put_rpccred(req
->rq_cred
);
680 put_rpccred(struct rpc_cred
*cred
)
682 /* Fast path for unhashed credentials */
683 if (test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
) == 0) {
684 if (atomic_dec_and_test(&cred
->cr_count
))
685 cred
->cr_ops
->crdestroy(cred
);
689 if (!atomic_dec_and_lock(&cred
->cr_count
, &rpc_credcache_lock
))
691 if (!list_empty(&cred
->cr_lru
)) {
692 number_cred_unused
--;
693 list_del_init(&cred
->cr_lru
);
695 if (test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
) != 0) {
696 if (test_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
) != 0) {
697 cred
->cr_expire
= jiffies
;
698 list_add_tail(&cred
->cr_lru
, &cred_unused
);
699 number_cred_unused
++;
702 if (!rpcauth_unhash_cred(cred
)) {
703 /* We were hashed and someone looked us up... */
707 spin_unlock(&rpc_credcache_lock
);
708 cred
->cr_ops
->crdestroy(cred
);
711 spin_unlock(&rpc_credcache_lock
);
713 EXPORT_SYMBOL_GPL(put_rpccred
);
716 rpcauth_marshcred(struct rpc_task
*task
, __be32
*p
)
718 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
720 dprintk("RPC: %5u marshaling %s cred %p\n",
721 task
->tk_pid
, cred
->cr_auth
->au_ops
->au_name
, cred
);
723 return cred
->cr_ops
->crmarshal(task
, p
);
727 rpcauth_checkverf(struct rpc_task
*task
, __be32
*p
)
729 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
731 dprintk("RPC: %5u validating %s cred %p\n",
732 task
->tk_pid
, cred
->cr_auth
->au_ops
->au_name
, cred
);
734 return cred
->cr_ops
->crvalidate(task
, p
);
737 static void rpcauth_wrap_req_encode(kxdreproc_t encode
, struct rpc_rqst
*rqstp
,
738 __be32
*data
, void *obj
)
740 struct xdr_stream xdr
;
742 xdr_init_encode(&xdr
, &rqstp
->rq_snd_buf
, data
);
743 encode(rqstp
, &xdr
, obj
);
747 rpcauth_wrap_req(struct rpc_task
*task
, kxdreproc_t encode
, void *rqstp
,
748 __be32
*data
, void *obj
)
750 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
752 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
753 task
->tk_pid
, cred
->cr_ops
->cr_name
, cred
);
754 if (cred
->cr_ops
->crwrap_req
)
755 return cred
->cr_ops
->crwrap_req(task
, encode
, rqstp
, data
, obj
);
756 /* By default, we encode the arguments normally. */
757 rpcauth_wrap_req_encode(encode
, rqstp
, data
, obj
);
762 rpcauth_unwrap_req_decode(kxdrdproc_t decode
, struct rpc_rqst
*rqstp
,
763 __be32
*data
, void *obj
)
765 struct xdr_stream xdr
;
767 xdr_init_decode(&xdr
, &rqstp
->rq_rcv_buf
, data
);
768 return decode(rqstp
, &xdr
, obj
);
772 rpcauth_unwrap_resp(struct rpc_task
*task
, kxdrdproc_t decode
, void *rqstp
,
773 __be32
*data
, void *obj
)
775 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
777 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
778 task
->tk_pid
, cred
->cr_ops
->cr_name
, cred
);
779 if (cred
->cr_ops
->crunwrap_resp
)
780 return cred
->cr_ops
->crunwrap_resp(task
, decode
, rqstp
,
782 /* By default, we decode the arguments normally. */
783 return rpcauth_unwrap_req_decode(decode
, rqstp
, data
, obj
);
787 rpcauth_refreshcred(struct rpc_task
*task
)
789 struct rpc_cred
*cred
;
792 cred
= task
->tk_rqstp
->rq_cred
;
794 err
= rpcauth_bindcred(task
, task
->tk_msg
.rpc_cred
, task
->tk_flags
);
797 cred
= task
->tk_rqstp
->rq_cred
;
799 dprintk("RPC: %5u refreshing %s cred %p\n",
800 task
->tk_pid
, cred
->cr_auth
->au_ops
->au_name
, cred
);
802 err
= cred
->cr_ops
->crrefresh(task
);
805 task
->tk_status
= err
;
810 rpcauth_invalcred(struct rpc_task
*task
)
812 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
814 dprintk("RPC: %5u invalidating %s cred %p\n",
815 task
->tk_pid
, cred
->cr_auth
->au_ops
->au_name
, cred
);
817 clear_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
);
821 rpcauth_uptodatecred(struct rpc_task
*task
)
823 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
825 return cred
== NULL
||
826 test_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
) != 0;
829 static struct shrinker rpc_cred_shrinker
= {
830 .count_objects
= rpcauth_cache_shrink_count
,
831 .scan_objects
= rpcauth_cache_shrink_scan
,
832 .seeks
= DEFAULT_SEEKS
,
835 int __init
rpcauth_init_module(void)
839 err
= rpc_init_authunix();
842 err
= rpc_init_generic_auth();
845 register_shrinker(&rpc_cred_shrinker
);
848 rpc_destroy_authunix();
853 void rpcauth_remove_module(void)
855 rpc_destroy_authunix();
856 rpc_destroy_generic_auth();
857 unregister_shrinker(&rpc_cred_shrinker
);