1 /* 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> 14 #include <linux/hash.h> 15 #include <linux/sunrpc/clnt.h> 16 #include <linux/spinlock.h> 17 18 #ifdef RPC_DEBUG 19 # define RPCDBG_FACILITY RPCDBG_AUTH 20 #endif 21 22 #define RPC_CREDCACHE_DEFAULT_HASHBITS (4) 23 struct rpc_cred_cache { 24 struct hlist_head *hashtable; 25 unsigned int hashbits; 26 spinlock_t lock; 27 }; 28 29 static unsigned int auth_hashbits = RPC_CREDCACHE_DEFAULT_HASHBITS; 30 31 static DEFINE_SPINLOCK(rpc_authflavor_lock); 32 static const struct rpc_authops *auth_flavors[RPC_AUTH_MAXFLAVOR] = { 33 &authnull_ops, /* AUTH_NULL */ 34 &authunix_ops, /* AUTH_UNIX */ 35 NULL, /* others can be loadable modules */ 36 }; 37 38 static LIST_HEAD(cred_unused); 39 static unsigned long number_cred_unused; 40 41 #define MAX_HASHTABLE_BITS (14) 42 static int param_set_hashtbl_sz(const char *val, const struct kernel_param *kp) 43 { 44 unsigned long num; 45 unsigned int nbits; 46 int ret; 47 48 if (!val) 49 goto out_inval; 50 ret = strict_strtoul(val, 0, &num); 51 if (ret == -EINVAL) 52 goto out_inval; 53 nbits = fls(num); 54 if (num > (1U << nbits)) 55 nbits++; 56 if (nbits > MAX_HASHTABLE_BITS || nbits < 2) 57 goto out_inval; 58 *(unsigned int *)kp->arg = nbits; 59 return 0; 60 out_inval: 61 return -EINVAL; 62 } 63 64 static int param_get_hashtbl_sz(char *buffer, const struct kernel_param *kp) 65 { 66 unsigned int nbits; 67 68 nbits = *(unsigned int *)kp->arg; 69 return sprintf(buffer, "%u", 1U << nbits); 70 } 71 72 #define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int); 73 74 static struct kernel_param_ops param_ops_hashtbl_sz = { 75 .set = param_set_hashtbl_sz, 76 .get = param_get_hashtbl_sz, 77 }; 78 79 module_param_named(auth_hashtable_size, auth_hashbits, hashtbl_sz, 0644); 80 MODULE_PARM_DESC(auth_hashtable_size, "RPC credential cache hashtable size"); 81 82 static u32 83 pseudoflavor_to_flavor(u32 flavor) { 84 if (flavor >= RPC_AUTH_MAXFLAVOR) 85 return RPC_AUTH_GSS; 86 return flavor; 87 } 88 89 int 90 rpcauth_register(const struct rpc_authops *ops) 91 { 92 rpc_authflavor_t flavor; 93 int ret = -EPERM; 94 95 if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR) 96 return -EINVAL; 97 spin_lock(&rpc_authflavor_lock); 98 if (auth_flavors[flavor] == NULL) { 99 auth_flavors[flavor] = ops; 100 ret = 0; 101 } 102 spin_unlock(&rpc_authflavor_lock); 103 return ret; 104 } 105 EXPORT_SYMBOL_GPL(rpcauth_register); 106 107 int 108 rpcauth_unregister(const struct rpc_authops *ops) 109 { 110 rpc_authflavor_t flavor; 111 int ret = -EPERM; 112 113 if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR) 114 return -EINVAL; 115 spin_lock(&rpc_authflavor_lock); 116 if (auth_flavors[flavor] == ops) { 117 auth_flavors[flavor] = NULL; 118 ret = 0; 119 } 120 spin_unlock(&rpc_authflavor_lock); 121 return ret; 122 } 123 EXPORT_SYMBOL_GPL(rpcauth_unregister); 124 125 struct rpc_auth * 126 rpcauth_create(rpc_authflavor_t pseudoflavor, struct rpc_clnt *clnt) 127 { 128 struct rpc_auth *auth; 129 const struct rpc_authops *ops; 130 u32 flavor = pseudoflavor_to_flavor(pseudoflavor); 131 132 auth = ERR_PTR(-EINVAL); 133 if (flavor >= RPC_AUTH_MAXFLAVOR) 134 goto out; 135 136 if ((ops = auth_flavors[flavor]) == NULL) 137 request_module("rpc-auth-%u", flavor); 138 spin_lock(&rpc_authflavor_lock); 139 ops = auth_flavors[flavor]; 140 if (ops == NULL || !try_module_get(ops->owner)) { 141 spin_unlock(&rpc_authflavor_lock); 142 goto out; 143 } 144 spin_unlock(&rpc_authflavor_lock); 145 auth = ops->create(clnt, pseudoflavor); 146 module_put(ops->owner); 147 if (IS_ERR(auth)) 148 return auth; 149 if (clnt->cl_auth) 150 rpcauth_release(clnt->cl_auth); 151 clnt->cl_auth = auth; 152 153 out: 154 return auth; 155 } 156 EXPORT_SYMBOL_GPL(rpcauth_create); 157 158 void 159 rpcauth_release(struct rpc_auth *auth) 160 { 161 if (!atomic_dec_and_test(&auth->au_count)) 162 return; 163 auth->au_ops->destroy(auth); 164 } 165 166 static DEFINE_SPINLOCK(rpc_credcache_lock); 167 168 static void 169 rpcauth_unhash_cred_locked(struct rpc_cred *cred) 170 { 171 hlist_del_rcu(&cred->cr_hash); 172 smp_mb__before_clear_bit(); 173 clear_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags); 174 } 175 176 static int 177 rpcauth_unhash_cred(struct rpc_cred *cred) 178 { 179 spinlock_t *cache_lock; 180 int ret; 181 182 cache_lock = &cred->cr_auth->au_credcache->lock; 183 spin_lock(cache_lock); 184 ret = atomic_read(&cred->cr_count) == 0; 185 if (ret) 186 rpcauth_unhash_cred_locked(cred); 187 spin_unlock(cache_lock); 188 return ret; 189 } 190 191 /* 192 * Initialize RPC credential cache 193 */ 194 int 195 rpcauth_init_credcache(struct rpc_auth *auth) 196 { 197 struct rpc_cred_cache *new; 198 unsigned int hashsize; 199 200 new = kmalloc(sizeof(*new), GFP_KERNEL); 201 if (!new) 202 goto out_nocache; 203 new->hashbits = auth_hashbits; 204 hashsize = 1U << new->hashbits; 205 new->hashtable = kcalloc(hashsize, sizeof(new->hashtable[0]), GFP_KERNEL); 206 if (!new->hashtable) 207 goto out_nohashtbl; 208 spin_lock_init(&new->lock); 209 auth->au_credcache = new; 210 return 0; 211 out_nohashtbl: 212 kfree(new); 213 out_nocache: 214 return -ENOMEM; 215 } 216 EXPORT_SYMBOL_GPL(rpcauth_init_credcache); 217 218 /* 219 * Destroy a list of credentials 220 */ 221 static inline 222 void rpcauth_destroy_credlist(struct list_head *head) 223 { 224 struct rpc_cred *cred; 225 226 while (!list_empty(head)) { 227 cred = list_entry(head->next, struct rpc_cred, cr_lru); 228 list_del_init(&cred->cr_lru); 229 put_rpccred(cred); 230 } 231 } 232 233 /* 234 * Clear the RPC credential cache, and delete those credentials 235 * that are not referenced. 236 */ 237 void 238 rpcauth_clear_credcache(struct rpc_cred_cache *cache) 239 { 240 LIST_HEAD(free); 241 struct hlist_head *head; 242 struct rpc_cred *cred; 243 unsigned int hashsize = 1U << cache->hashbits; 244 int i; 245 246 spin_lock(&rpc_credcache_lock); 247 spin_lock(&cache->lock); 248 for (i = 0; i < hashsize; i++) { 249 head = &cache->hashtable[i]; 250 while (!hlist_empty(head)) { 251 cred = hlist_entry(head->first, struct rpc_cred, cr_hash); 252 get_rpccred(cred); 253 if (!list_empty(&cred->cr_lru)) { 254 list_del(&cred->cr_lru); 255 number_cred_unused--; 256 } 257 list_add_tail(&cred->cr_lru, &free); 258 rpcauth_unhash_cred_locked(cred); 259 } 260 } 261 spin_unlock(&cache->lock); 262 spin_unlock(&rpc_credcache_lock); 263 rpcauth_destroy_credlist(&free); 264 } 265 266 /* 267 * Destroy the RPC credential cache 268 */ 269 void 270 rpcauth_destroy_credcache(struct rpc_auth *auth) 271 { 272 struct rpc_cred_cache *cache = auth->au_credcache; 273 274 if (cache) { 275 auth->au_credcache = NULL; 276 rpcauth_clear_credcache(cache); 277 kfree(cache->hashtable); 278 kfree(cache); 279 } 280 } 281 EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache); 282 283 284 #define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ) 285 286 /* 287 * Remove stale credentials. Avoid sleeping inside the loop. 288 */ 289 static int 290 rpcauth_prune_expired(struct list_head *free, int nr_to_scan) 291 { 292 spinlock_t *cache_lock; 293 struct rpc_cred *cred, *next; 294 unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM; 295 296 list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) { 297 298 if (nr_to_scan-- == 0) 299 break; 300 /* 301 * Enforce a 60 second garbage collection moratorium 302 * Note that the cred_unused list must be time-ordered. 303 */ 304 if (time_in_range(cred->cr_expire, expired, jiffies) && 305 test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0) 306 return 0; 307 308 list_del_init(&cred->cr_lru); 309 number_cred_unused--; 310 if (atomic_read(&cred->cr_count) != 0) 311 continue; 312 313 cache_lock = &cred->cr_auth->au_credcache->lock; 314 spin_lock(cache_lock); 315 if (atomic_read(&cred->cr_count) == 0) { 316 get_rpccred(cred); 317 list_add_tail(&cred->cr_lru, free); 318 rpcauth_unhash_cred_locked(cred); 319 } 320 spin_unlock(cache_lock); 321 } 322 return (number_cred_unused / 100) * sysctl_vfs_cache_pressure; 323 } 324 325 /* 326 * Run memory cache shrinker. 327 */ 328 static int 329 rpcauth_cache_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask) 330 { 331 LIST_HEAD(free); 332 int res; 333 334 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 335 return (nr_to_scan == 0) ? 0 : -1; 336 if (list_empty(&cred_unused)) 337 return 0; 338 spin_lock(&rpc_credcache_lock); 339 res = rpcauth_prune_expired(&free, nr_to_scan); 340 spin_unlock(&rpc_credcache_lock); 341 rpcauth_destroy_credlist(&free); 342 return res; 343 } 344 345 /* 346 * Look up a process' credentials in the authentication cache 347 */ 348 struct rpc_cred * 349 rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred, 350 int flags) 351 { 352 LIST_HEAD(free); 353 struct rpc_cred_cache *cache = auth->au_credcache; 354 struct hlist_node *pos; 355 struct rpc_cred *cred = NULL, 356 *entry, *new; 357 unsigned int nr; 358 359 nr = hash_long(acred->uid, cache->hashbits); 360 361 rcu_read_lock(); 362 hlist_for_each_entry_rcu(entry, pos, &cache->hashtable[nr], cr_hash) { 363 if (!entry->cr_ops->crmatch(acred, entry, flags)) 364 continue; 365 spin_lock(&cache->lock); 366 if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) == 0) { 367 spin_unlock(&cache->lock); 368 continue; 369 } 370 cred = get_rpccred(entry); 371 spin_unlock(&cache->lock); 372 break; 373 } 374 rcu_read_unlock(); 375 376 if (cred != NULL) 377 goto found; 378 379 new = auth->au_ops->crcreate(auth, acred, flags); 380 if (IS_ERR(new)) { 381 cred = new; 382 goto out; 383 } 384 385 spin_lock(&cache->lock); 386 hlist_for_each_entry(entry, pos, &cache->hashtable[nr], cr_hash) { 387 if (!entry->cr_ops->crmatch(acred, entry, flags)) 388 continue; 389 cred = get_rpccred(entry); 390 break; 391 } 392 if (cred == NULL) { 393 cred = new; 394 set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags); 395 hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]); 396 } else 397 list_add_tail(&new->cr_lru, &free); 398 spin_unlock(&cache->lock); 399 found: 400 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) && 401 cred->cr_ops->cr_init != NULL && 402 !(flags & RPCAUTH_LOOKUP_NEW)) { 403 int res = cred->cr_ops->cr_init(auth, cred); 404 if (res < 0) { 405 put_rpccred(cred); 406 cred = ERR_PTR(res); 407 } 408 } 409 rpcauth_destroy_credlist(&free); 410 out: 411 return cred; 412 } 413 EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache); 414 415 struct rpc_cred * 416 rpcauth_lookupcred(struct rpc_auth *auth, int flags) 417 { 418 struct auth_cred acred; 419 struct rpc_cred *ret; 420 const struct cred *cred = current_cred(); 421 422 dprintk("RPC: looking up %s cred\n", 423 auth->au_ops->au_name); 424 425 memset(&acred, 0, sizeof(acred)); 426 acred.uid = cred->fsuid; 427 acred.gid = cred->fsgid; 428 acred.group_info = get_group_info(((struct cred *)cred)->group_info); 429 430 ret = auth->au_ops->lookup_cred(auth, &acred, flags); 431 put_group_info(acred.group_info); 432 return ret; 433 } 434 435 void 436 rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred, 437 struct rpc_auth *auth, const struct rpc_credops *ops) 438 { 439 INIT_HLIST_NODE(&cred->cr_hash); 440 INIT_LIST_HEAD(&cred->cr_lru); 441 atomic_set(&cred->cr_count, 1); 442 cred->cr_auth = auth; 443 cred->cr_ops = ops; 444 cred->cr_expire = jiffies; 445 #ifdef RPC_DEBUG 446 cred->cr_magic = RPCAUTH_CRED_MAGIC; 447 #endif 448 cred->cr_uid = acred->uid; 449 } 450 EXPORT_SYMBOL_GPL(rpcauth_init_cred); 451 452 struct rpc_cred * 453 rpcauth_generic_bind_cred(struct rpc_task *task, struct rpc_cred *cred, int lookupflags) 454 { 455 dprintk("RPC: %5u holding %s cred %p\n", task->tk_pid, 456 cred->cr_auth->au_ops->au_name, cred); 457 return get_rpccred(cred); 458 } 459 EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred); 460 461 static struct rpc_cred * 462 rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags) 463 { 464 struct rpc_auth *auth = task->tk_client->cl_auth; 465 struct auth_cred acred = { 466 .uid = 0, 467 .gid = 0, 468 }; 469 470 dprintk("RPC: %5u looking up %s cred\n", 471 task->tk_pid, task->tk_client->cl_auth->au_ops->au_name); 472 return auth->au_ops->lookup_cred(auth, &acred, lookupflags); 473 } 474 475 static struct rpc_cred * 476 rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags) 477 { 478 struct rpc_auth *auth = task->tk_client->cl_auth; 479 480 dprintk("RPC: %5u looking up %s cred\n", 481 task->tk_pid, auth->au_ops->au_name); 482 return rpcauth_lookupcred(auth, lookupflags); 483 } 484 485 static int 486 rpcauth_bindcred(struct rpc_task *task, struct rpc_cred *cred, int flags) 487 { 488 struct rpc_rqst *req = task->tk_rqstp; 489 struct rpc_cred *new; 490 int lookupflags = 0; 491 492 if (flags & RPC_TASK_ASYNC) 493 lookupflags |= RPCAUTH_LOOKUP_NEW; 494 if (cred != NULL) 495 new = cred->cr_ops->crbind(task, cred, lookupflags); 496 else if (flags & RPC_TASK_ROOTCREDS) 497 new = rpcauth_bind_root_cred(task, lookupflags); 498 else 499 new = rpcauth_bind_new_cred(task, lookupflags); 500 if (IS_ERR(new)) 501 return PTR_ERR(new); 502 if (req->rq_cred != NULL) 503 put_rpccred(req->rq_cred); 504 req->rq_cred = new; 505 return 0; 506 } 507 508 void 509 put_rpccred(struct rpc_cred *cred) 510 { 511 /* Fast path for unhashed credentials */ 512 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) == 0) { 513 if (atomic_dec_and_test(&cred->cr_count)) 514 cred->cr_ops->crdestroy(cred); 515 return; 516 } 517 518 if (!atomic_dec_and_lock(&cred->cr_count, &rpc_credcache_lock)) 519 return; 520 if (!list_empty(&cred->cr_lru)) { 521 number_cred_unused--; 522 list_del_init(&cred->cr_lru); 523 } 524 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0) { 525 if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0) { 526 cred->cr_expire = jiffies; 527 list_add_tail(&cred->cr_lru, &cred_unused); 528 number_cred_unused++; 529 goto out_nodestroy; 530 } 531 if (!rpcauth_unhash_cred(cred)) { 532 /* We were hashed and someone looked us up... */ 533 goto out_nodestroy; 534 } 535 } 536 spin_unlock(&rpc_credcache_lock); 537 cred->cr_ops->crdestroy(cred); 538 return; 539 out_nodestroy: 540 spin_unlock(&rpc_credcache_lock); 541 } 542 EXPORT_SYMBOL_GPL(put_rpccred); 543 544 __be32 * 545 rpcauth_marshcred(struct rpc_task *task, __be32 *p) 546 { 547 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 548 549 dprintk("RPC: %5u marshaling %s cred %p\n", 550 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 551 552 return cred->cr_ops->crmarshal(task, p); 553 } 554 555 __be32 * 556 rpcauth_checkverf(struct rpc_task *task, __be32 *p) 557 { 558 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 559 560 dprintk("RPC: %5u validating %s cred %p\n", 561 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 562 563 return cred->cr_ops->crvalidate(task, p); 564 } 565 566 static void rpcauth_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp, 567 __be32 *data, void *obj) 568 { 569 struct xdr_stream xdr; 570 571 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, data); 572 encode(rqstp, &xdr, obj); 573 } 574 575 int 576 rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp, 577 __be32 *data, void *obj) 578 { 579 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 580 581 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n", 582 task->tk_pid, cred->cr_ops->cr_name, cred); 583 if (cred->cr_ops->crwrap_req) 584 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj); 585 /* By default, we encode the arguments normally. */ 586 rpcauth_wrap_req_encode(encode, rqstp, data, obj); 587 return 0; 588 } 589 590 static int 591 rpcauth_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp, 592 __be32 *data, void *obj) 593 { 594 struct xdr_stream xdr; 595 596 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, data); 597 return decode(rqstp, &xdr, obj); 598 } 599 600 int 601 rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp, 602 __be32 *data, void *obj) 603 { 604 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 605 606 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n", 607 task->tk_pid, cred->cr_ops->cr_name, cred); 608 if (cred->cr_ops->crunwrap_resp) 609 return cred->cr_ops->crunwrap_resp(task, decode, rqstp, 610 data, obj); 611 /* By default, we decode the arguments normally. */ 612 return rpcauth_unwrap_req_decode(decode, rqstp, data, obj); 613 } 614 615 int 616 rpcauth_refreshcred(struct rpc_task *task) 617 { 618 struct rpc_cred *cred; 619 int err; 620 621 cred = task->tk_rqstp->rq_cred; 622 if (cred == NULL) { 623 err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags); 624 if (err < 0) 625 goto out; 626 cred = task->tk_rqstp->rq_cred; 627 }; 628 dprintk("RPC: %5u refreshing %s cred %p\n", 629 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 630 631 err = cred->cr_ops->crrefresh(task); 632 out: 633 if (err < 0) 634 task->tk_status = err; 635 return err; 636 } 637 638 void 639 rpcauth_invalcred(struct rpc_task *task) 640 { 641 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 642 643 dprintk("RPC: %5u invalidating %s cred %p\n", 644 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 645 if (cred) 646 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 647 } 648 649 int 650 rpcauth_uptodatecred(struct rpc_task *task) 651 { 652 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 653 654 return cred == NULL || 655 test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0; 656 } 657 658 static struct shrinker rpc_cred_shrinker = { 659 .shrink = rpcauth_cache_shrinker, 660 .seeks = DEFAULT_SEEKS, 661 }; 662 663 int __init rpcauth_init_module(void) 664 { 665 int err; 666 667 err = rpc_init_authunix(); 668 if (err < 0) 669 goto out1; 670 err = rpc_init_generic_auth(); 671 if (err < 0) 672 goto out2; 673 register_shrinker(&rpc_cred_shrinker); 674 return 0; 675 out2: 676 rpc_destroy_authunix(); 677 out1: 678 return err; 679 } 680 681 void rpcauth_remove_module(void) 682 { 683 rpc_destroy_authunix(); 684 rpc_destroy_generic_auth(); 685 unregister_shrinker(&rpc_cred_shrinker); 686 } 687