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_list_flavors - discover registered flavors and pseudoflavors
128 * @array: array to fill in
129 * @size: size of "array"
131 * Returns the number of array items filled in, or a negative errno.
133 * The returned array is not sorted by any policy. Callers should not
134 * rely on the order of the items in the returned array.
137 rpcauth_list_flavors(rpc_authflavor_t
*array
, int size
)
139 rpc_authflavor_t flavor
;
142 spin_lock(&rpc_authflavor_lock
);
143 for (flavor
= 0; flavor
< RPC_AUTH_MAXFLAVOR
; flavor
++) {
144 const struct rpc_authops
*ops
= auth_flavors
[flavor
];
145 rpc_authflavor_t pseudos
[4];
148 if (result
>= size
) {
155 if (ops
->list_pseudoflavors
== NULL
) {
156 array
[result
++] = ops
->au_flavor
;
159 len
= ops
->list_pseudoflavors(pseudos
, ARRAY_SIZE(pseudos
));
164 for (i
= 0; i
< len
; i
++) {
165 if (result
>= size
) {
169 array
[result
++] = pseudos
[i
];
172 spin_unlock(&rpc_authflavor_lock
);
174 dprintk("RPC: %s returns %d\n", __func__
, result
);
177 EXPORT_SYMBOL_GPL(rpcauth_list_flavors
);
180 rpcauth_create(rpc_authflavor_t pseudoflavor
, struct rpc_clnt
*clnt
)
182 struct rpc_auth
*auth
;
183 const struct rpc_authops
*ops
;
184 u32 flavor
= pseudoflavor_to_flavor(pseudoflavor
);
186 auth
= ERR_PTR(-EINVAL
);
187 if (flavor
>= RPC_AUTH_MAXFLAVOR
)
190 if ((ops
= auth_flavors
[flavor
]) == NULL
)
191 request_module("rpc-auth-%u", flavor
);
192 spin_lock(&rpc_authflavor_lock
);
193 ops
= auth_flavors
[flavor
];
194 if (ops
== NULL
|| !try_module_get(ops
->owner
)) {
195 spin_unlock(&rpc_authflavor_lock
);
198 spin_unlock(&rpc_authflavor_lock
);
199 auth
= ops
->create(clnt
, pseudoflavor
);
200 module_put(ops
->owner
);
204 rpcauth_release(clnt
->cl_auth
);
205 clnt
->cl_auth
= auth
;
210 EXPORT_SYMBOL_GPL(rpcauth_create
);
213 rpcauth_release(struct rpc_auth
*auth
)
215 if (!atomic_dec_and_test(&auth
->au_count
))
217 auth
->au_ops
->destroy(auth
);
220 static DEFINE_SPINLOCK(rpc_credcache_lock
);
223 rpcauth_unhash_cred_locked(struct rpc_cred
*cred
)
225 hlist_del_rcu(&cred
->cr_hash
);
226 smp_mb__before_clear_bit();
227 clear_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
);
231 rpcauth_unhash_cred(struct rpc_cred
*cred
)
233 spinlock_t
*cache_lock
;
236 cache_lock
= &cred
->cr_auth
->au_credcache
->lock
;
237 spin_lock(cache_lock
);
238 ret
= atomic_read(&cred
->cr_count
) == 0;
240 rpcauth_unhash_cred_locked(cred
);
241 spin_unlock(cache_lock
);
246 * Initialize RPC credential cache
249 rpcauth_init_credcache(struct rpc_auth
*auth
)
251 struct rpc_cred_cache
*new;
252 unsigned int hashsize
;
254 new = kmalloc(sizeof(*new), GFP_KERNEL
);
257 new->hashbits
= auth_hashbits
;
258 hashsize
= 1U << new->hashbits
;
259 new->hashtable
= kcalloc(hashsize
, sizeof(new->hashtable
[0]), GFP_KERNEL
);
262 spin_lock_init(&new->lock
);
263 auth
->au_credcache
= new;
270 EXPORT_SYMBOL_GPL(rpcauth_init_credcache
);
273 * Destroy a list of credentials
276 void rpcauth_destroy_credlist(struct list_head
*head
)
278 struct rpc_cred
*cred
;
280 while (!list_empty(head
)) {
281 cred
= list_entry(head
->next
, struct rpc_cred
, cr_lru
);
282 list_del_init(&cred
->cr_lru
);
288 * Clear the RPC credential cache, and delete those credentials
289 * that are not referenced.
292 rpcauth_clear_credcache(struct rpc_cred_cache
*cache
)
295 struct hlist_head
*head
;
296 struct rpc_cred
*cred
;
297 unsigned int hashsize
= 1U << cache
->hashbits
;
300 spin_lock(&rpc_credcache_lock
);
301 spin_lock(&cache
->lock
);
302 for (i
= 0; i
< hashsize
; i
++) {
303 head
= &cache
->hashtable
[i
];
304 while (!hlist_empty(head
)) {
305 cred
= hlist_entry(head
->first
, struct rpc_cred
, cr_hash
);
307 if (!list_empty(&cred
->cr_lru
)) {
308 list_del(&cred
->cr_lru
);
309 number_cred_unused
--;
311 list_add_tail(&cred
->cr_lru
, &free
);
312 rpcauth_unhash_cred_locked(cred
);
315 spin_unlock(&cache
->lock
);
316 spin_unlock(&rpc_credcache_lock
);
317 rpcauth_destroy_credlist(&free
);
321 * Destroy the RPC credential cache
324 rpcauth_destroy_credcache(struct rpc_auth
*auth
)
326 struct rpc_cred_cache
*cache
= auth
->au_credcache
;
329 auth
->au_credcache
= NULL
;
330 rpcauth_clear_credcache(cache
);
331 kfree(cache
->hashtable
);
335 EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache
);
338 #define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ)
341 * Remove stale credentials. Avoid sleeping inside the loop.
344 rpcauth_prune_expired(struct list_head
*free
, int nr_to_scan
)
346 spinlock_t
*cache_lock
;
347 struct rpc_cred
*cred
, *next
;
348 unsigned long expired
= jiffies
- RPC_AUTH_EXPIRY_MORATORIUM
;
350 list_for_each_entry_safe(cred
, next
, &cred_unused
, cr_lru
) {
352 if (nr_to_scan
-- == 0)
355 * Enforce a 60 second garbage collection moratorium
356 * Note that the cred_unused list must be time-ordered.
358 if (time_in_range(cred
->cr_expire
, expired
, jiffies
) &&
359 test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
) != 0)
362 list_del_init(&cred
->cr_lru
);
363 number_cred_unused
--;
364 if (atomic_read(&cred
->cr_count
) != 0)
367 cache_lock
= &cred
->cr_auth
->au_credcache
->lock
;
368 spin_lock(cache_lock
);
369 if (atomic_read(&cred
->cr_count
) == 0) {
371 list_add_tail(&cred
->cr_lru
, free
);
372 rpcauth_unhash_cred_locked(cred
);
374 spin_unlock(cache_lock
);
376 return (number_cred_unused
/ 100) * sysctl_vfs_cache_pressure
;
380 * Run memory cache shrinker.
383 rpcauth_cache_shrinker(struct shrinker
*shrink
, struct shrink_control
*sc
)
387 int nr_to_scan
= sc
->nr_to_scan
;
388 gfp_t gfp_mask
= sc
->gfp_mask
;
390 if ((gfp_mask
& GFP_KERNEL
) != GFP_KERNEL
)
391 return (nr_to_scan
== 0) ? 0 : -1;
392 if (list_empty(&cred_unused
))
394 spin_lock(&rpc_credcache_lock
);
395 res
= rpcauth_prune_expired(&free
, nr_to_scan
);
396 spin_unlock(&rpc_credcache_lock
);
397 rpcauth_destroy_credlist(&free
);
402 * Look up a process' credentials in the authentication cache
405 rpcauth_lookup_credcache(struct rpc_auth
*auth
, struct auth_cred
* acred
,
409 struct rpc_cred_cache
*cache
= auth
->au_credcache
;
410 struct hlist_node
*pos
;
411 struct rpc_cred
*cred
= NULL
,
415 nr
= hash_long(acred
->uid
, cache
->hashbits
);
418 hlist_for_each_entry_rcu(entry
, pos
, &cache
->hashtable
[nr
], cr_hash
) {
419 if (!entry
->cr_ops
->crmatch(acred
, entry
, flags
))
421 spin_lock(&cache
->lock
);
422 if (test_bit(RPCAUTH_CRED_HASHED
, &entry
->cr_flags
) == 0) {
423 spin_unlock(&cache
->lock
);
426 cred
= get_rpccred(entry
);
427 spin_unlock(&cache
->lock
);
435 new = auth
->au_ops
->crcreate(auth
, acred
, flags
);
441 spin_lock(&cache
->lock
);
442 hlist_for_each_entry(entry
, pos
, &cache
->hashtable
[nr
], cr_hash
) {
443 if (!entry
->cr_ops
->crmatch(acred
, entry
, flags
))
445 cred
= get_rpccred(entry
);
450 set_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
);
451 hlist_add_head_rcu(&cred
->cr_hash
, &cache
->hashtable
[nr
]);
453 list_add_tail(&new->cr_lru
, &free
);
454 spin_unlock(&cache
->lock
);
456 if (test_bit(RPCAUTH_CRED_NEW
, &cred
->cr_flags
) &&
457 cred
->cr_ops
->cr_init
!= NULL
&&
458 !(flags
& RPCAUTH_LOOKUP_NEW
)) {
459 int res
= cred
->cr_ops
->cr_init(auth
, cred
);
465 rpcauth_destroy_credlist(&free
);
469 EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache
);
472 rpcauth_lookupcred(struct rpc_auth
*auth
, int flags
)
474 struct auth_cred acred
;
475 struct rpc_cred
*ret
;
476 const struct cred
*cred
= current_cred();
478 dprintk("RPC: looking up %s cred\n",
479 auth
->au_ops
->au_name
);
481 memset(&acred
, 0, sizeof(acred
));
482 acred
.uid
= cred
->fsuid
;
483 acred
.gid
= cred
->fsgid
;
484 acred
.group_info
= get_group_info(((struct cred
*)cred
)->group_info
);
486 ret
= auth
->au_ops
->lookup_cred(auth
, &acred
, flags
);
487 put_group_info(acred
.group_info
);
492 rpcauth_init_cred(struct rpc_cred
*cred
, const struct auth_cred
*acred
,
493 struct rpc_auth
*auth
, const struct rpc_credops
*ops
)
495 INIT_HLIST_NODE(&cred
->cr_hash
);
496 INIT_LIST_HEAD(&cred
->cr_lru
);
497 atomic_set(&cred
->cr_count
, 1);
498 cred
->cr_auth
= auth
;
500 cred
->cr_expire
= jiffies
;
502 cred
->cr_magic
= RPCAUTH_CRED_MAGIC
;
504 cred
->cr_uid
= acred
->uid
;
506 EXPORT_SYMBOL_GPL(rpcauth_init_cred
);
509 rpcauth_generic_bind_cred(struct rpc_task
*task
, struct rpc_cred
*cred
, int lookupflags
)
511 dprintk("RPC: %5u holding %s cred %p\n", task
->tk_pid
,
512 cred
->cr_auth
->au_ops
->au_name
, cred
);
513 return get_rpccred(cred
);
515 EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred
);
517 static struct rpc_cred
*
518 rpcauth_bind_root_cred(struct rpc_task
*task
, int lookupflags
)
520 struct rpc_auth
*auth
= task
->tk_client
->cl_auth
;
521 struct auth_cred acred
= {
526 dprintk("RPC: %5u looking up %s cred\n",
527 task
->tk_pid
, task
->tk_client
->cl_auth
->au_ops
->au_name
);
528 return auth
->au_ops
->lookup_cred(auth
, &acred
, lookupflags
);
531 static struct rpc_cred
*
532 rpcauth_bind_new_cred(struct rpc_task
*task
, int lookupflags
)
534 struct rpc_auth
*auth
= task
->tk_client
->cl_auth
;
536 dprintk("RPC: %5u looking up %s cred\n",
537 task
->tk_pid
, auth
->au_ops
->au_name
);
538 return rpcauth_lookupcred(auth
, lookupflags
);
542 rpcauth_bindcred(struct rpc_task
*task
, struct rpc_cred
*cred
, int flags
)
544 struct rpc_rqst
*req
= task
->tk_rqstp
;
545 struct rpc_cred
*new;
548 if (flags
& RPC_TASK_ASYNC
)
549 lookupflags
|= RPCAUTH_LOOKUP_NEW
;
551 new = cred
->cr_ops
->crbind(task
, cred
, lookupflags
);
552 else if (flags
& RPC_TASK_ROOTCREDS
)
553 new = rpcauth_bind_root_cred(task
, lookupflags
);
555 new = rpcauth_bind_new_cred(task
, lookupflags
);
558 if (req
->rq_cred
!= NULL
)
559 put_rpccred(req
->rq_cred
);
565 put_rpccred(struct rpc_cred
*cred
)
567 /* Fast path for unhashed credentials */
568 if (test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
) == 0) {
569 if (atomic_dec_and_test(&cred
->cr_count
))
570 cred
->cr_ops
->crdestroy(cred
);
574 if (!atomic_dec_and_lock(&cred
->cr_count
, &rpc_credcache_lock
))
576 if (!list_empty(&cred
->cr_lru
)) {
577 number_cred_unused
--;
578 list_del_init(&cred
->cr_lru
);
580 if (test_bit(RPCAUTH_CRED_HASHED
, &cred
->cr_flags
) != 0) {
581 if (test_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
) != 0) {
582 cred
->cr_expire
= jiffies
;
583 list_add_tail(&cred
->cr_lru
, &cred_unused
);
584 number_cred_unused
++;
587 if (!rpcauth_unhash_cred(cred
)) {
588 /* We were hashed and someone looked us up... */
592 spin_unlock(&rpc_credcache_lock
);
593 cred
->cr_ops
->crdestroy(cred
);
596 spin_unlock(&rpc_credcache_lock
);
598 EXPORT_SYMBOL_GPL(put_rpccred
);
601 rpcauth_marshcred(struct rpc_task
*task
, __be32
*p
)
603 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
605 dprintk("RPC: %5u marshaling %s cred %p\n",
606 task
->tk_pid
, cred
->cr_auth
->au_ops
->au_name
, cred
);
608 return cred
->cr_ops
->crmarshal(task
, p
);
612 rpcauth_checkverf(struct rpc_task
*task
, __be32
*p
)
614 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
616 dprintk("RPC: %5u validating %s cred %p\n",
617 task
->tk_pid
, cred
->cr_auth
->au_ops
->au_name
, cred
);
619 return cred
->cr_ops
->crvalidate(task
, p
);
622 static void rpcauth_wrap_req_encode(kxdreproc_t encode
, struct rpc_rqst
*rqstp
,
623 __be32
*data
, void *obj
)
625 struct xdr_stream xdr
;
627 xdr_init_encode(&xdr
, &rqstp
->rq_snd_buf
, data
);
628 encode(rqstp
, &xdr
, obj
);
632 rpcauth_wrap_req(struct rpc_task
*task
, kxdreproc_t encode
, void *rqstp
,
633 __be32
*data
, void *obj
)
635 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
637 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n",
638 task
->tk_pid
, cred
->cr_ops
->cr_name
, cred
);
639 if (cred
->cr_ops
->crwrap_req
)
640 return cred
->cr_ops
->crwrap_req(task
, encode
, rqstp
, data
, obj
);
641 /* By default, we encode the arguments normally. */
642 rpcauth_wrap_req_encode(encode
, rqstp
, data
, obj
);
647 rpcauth_unwrap_req_decode(kxdrdproc_t decode
, struct rpc_rqst
*rqstp
,
648 __be32
*data
, void *obj
)
650 struct xdr_stream xdr
;
652 xdr_init_decode(&xdr
, &rqstp
->rq_rcv_buf
, data
);
653 return decode(rqstp
, &xdr
, obj
);
657 rpcauth_unwrap_resp(struct rpc_task
*task
, kxdrdproc_t decode
, void *rqstp
,
658 __be32
*data
, void *obj
)
660 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
662 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n",
663 task
->tk_pid
, cred
->cr_ops
->cr_name
, cred
);
664 if (cred
->cr_ops
->crunwrap_resp
)
665 return cred
->cr_ops
->crunwrap_resp(task
, decode
, rqstp
,
667 /* By default, we decode the arguments normally. */
668 return rpcauth_unwrap_req_decode(decode
, rqstp
, data
, obj
);
672 rpcauth_refreshcred(struct rpc_task
*task
)
674 struct rpc_cred
*cred
;
677 cred
= task
->tk_rqstp
->rq_cred
;
679 err
= rpcauth_bindcred(task
, task
->tk_msg
.rpc_cred
, task
->tk_flags
);
682 cred
= task
->tk_rqstp
->rq_cred
;
684 dprintk("RPC: %5u refreshing %s cred %p\n",
685 task
->tk_pid
, cred
->cr_auth
->au_ops
->au_name
, cred
);
687 err
= cred
->cr_ops
->crrefresh(task
);
690 task
->tk_status
= err
;
695 rpcauth_invalcred(struct rpc_task
*task
)
697 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
699 dprintk("RPC: %5u invalidating %s cred %p\n",
700 task
->tk_pid
, cred
->cr_auth
->au_ops
->au_name
, cred
);
702 clear_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
);
706 rpcauth_uptodatecred(struct rpc_task
*task
)
708 struct rpc_cred
*cred
= task
->tk_rqstp
->rq_cred
;
710 return cred
== NULL
||
711 test_bit(RPCAUTH_CRED_UPTODATE
, &cred
->cr_flags
) != 0;
714 static struct shrinker rpc_cred_shrinker
= {
715 .shrink
= rpcauth_cache_shrinker
,
716 .seeks
= DEFAULT_SEEKS
,
719 int __init
rpcauth_init_module(void)
723 err
= rpc_init_authunix();
726 err
= rpc_init_generic_auth();
729 register_shrinker(&rpc_cred_shrinker
);
732 rpc_destroy_authunix();
737 void rpcauth_remove_module(void)
739 rpc_destroy_authunix();
740 rpc_destroy_generic_auth();
741 unregister_shrinker(&rpc_cred_shrinker
);