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, struct shrink_control *sc) 330 { 331 LIST_HEAD(free); 332 int res; 333 int nr_to_scan = sc->nr_to_scan; 334 gfp_t gfp_mask = sc->gfp_mask; 335 336 if ((gfp_mask & GFP_KERNEL) != GFP_KERNEL) 337 return (nr_to_scan == 0) ? 0 : -1; 338 if (list_empty(&cred_unused)) 339 return 0; 340 spin_lock(&rpc_credcache_lock); 341 res = rpcauth_prune_expired(&free, nr_to_scan); 342 spin_unlock(&rpc_credcache_lock); 343 rpcauth_destroy_credlist(&free); 344 return res; 345 } 346 347 /* 348 * Look up a process' credentials in the authentication cache 349 */ 350 struct rpc_cred * 351 rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred, 352 int flags) 353 { 354 LIST_HEAD(free); 355 struct rpc_cred_cache *cache = auth->au_credcache; 356 struct hlist_node *pos; 357 struct rpc_cred *cred = NULL, 358 *entry, *new; 359 unsigned int nr; 360 361 nr = hash_long(acred->uid, cache->hashbits); 362 363 rcu_read_lock(); 364 hlist_for_each_entry_rcu(entry, pos, &cache->hashtable[nr], cr_hash) { 365 if (!entry->cr_ops->crmatch(acred, entry, flags)) 366 continue; 367 spin_lock(&cache->lock); 368 if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) == 0) { 369 spin_unlock(&cache->lock); 370 continue; 371 } 372 cred = get_rpccred(entry); 373 spin_unlock(&cache->lock); 374 break; 375 } 376 rcu_read_unlock(); 377 378 if (cred != NULL) 379 goto found; 380 381 new = auth->au_ops->crcreate(auth, acred, flags); 382 if (IS_ERR(new)) { 383 cred = new; 384 goto out; 385 } 386 387 spin_lock(&cache->lock); 388 hlist_for_each_entry(entry, pos, &cache->hashtable[nr], cr_hash) { 389 if (!entry->cr_ops->crmatch(acred, entry, flags)) 390 continue; 391 cred = get_rpccred(entry); 392 break; 393 } 394 if (cred == NULL) { 395 cred = new; 396 set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags); 397 hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]); 398 } else 399 list_add_tail(&new->cr_lru, &free); 400 spin_unlock(&cache->lock); 401 found: 402 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) && 403 cred->cr_ops->cr_init != NULL && 404 !(flags & RPCAUTH_LOOKUP_NEW)) { 405 int res = cred->cr_ops->cr_init(auth, cred); 406 if (res < 0) { 407 put_rpccred(cred); 408 cred = ERR_PTR(res); 409 } 410 } 411 rpcauth_destroy_credlist(&free); 412 out: 413 return cred; 414 } 415 EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache); 416 417 struct rpc_cred * 418 rpcauth_lookupcred(struct rpc_auth *auth, int flags) 419 { 420 struct auth_cred acred; 421 struct rpc_cred *ret; 422 const struct cred *cred = current_cred(); 423 424 dprintk("RPC: looking up %s cred\n", 425 auth->au_ops->au_name); 426 427 memset(&acred, 0, sizeof(acred)); 428 acred.uid = cred->fsuid; 429 acred.gid = cred->fsgid; 430 acred.group_info = get_group_info(((struct cred *)cred)->group_info); 431 432 ret = auth->au_ops->lookup_cred(auth, &acred, flags); 433 put_group_info(acred.group_info); 434 return ret; 435 } 436 437 void 438 rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred, 439 struct rpc_auth *auth, const struct rpc_credops *ops) 440 { 441 INIT_HLIST_NODE(&cred->cr_hash); 442 INIT_LIST_HEAD(&cred->cr_lru); 443 atomic_set(&cred->cr_count, 1); 444 cred->cr_auth = auth; 445 cred->cr_ops = ops; 446 cred->cr_expire = jiffies; 447 #ifdef RPC_DEBUG 448 cred->cr_magic = RPCAUTH_CRED_MAGIC; 449 #endif 450 cred->cr_uid = acred->uid; 451 } 452 EXPORT_SYMBOL_GPL(rpcauth_init_cred); 453 454 struct rpc_cred * 455 rpcauth_generic_bind_cred(struct rpc_task *task, struct rpc_cred *cred, int lookupflags) 456 { 457 dprintk("RPC: %5u holding %s cred %p\n", task->tk_pid, 458 cred->cr_auth->au_ops->au_name, cred); 459 return get_rpccred(cred); 460 } 461 EXPORT_SYMBOL_GPL(rpcauth_generic_bind_cred); 462 463 static struct rpc_cred * 464 rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags) 465 { 466 struct rpc_auth *auth = task->tk_client->cl_auth; 467 struct auth_cred acred = { 468 .uid = 0, 469 .gid = 0, 470 }; 471 472 dprintk("RPC: %5u looking up %s cred\n", 473 task->tk_pid, task->tk_client->cl_auth->au_ops->au_name); 474 return auth->au_ops->lookup_cred(auth, &acred, lookupflags); 475 } 476 477 static struct rpc_cred * 478 rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags) 479 { 480 struct rpc_auth *auth = task->tk_client->cl_auth; 481 482 dprintk("RPC: %5u looking up %s cred\n", 483 task->tk_pid, auth->au_ops->au_name); 484 return rpcauth_lookupcred(auth, lookupflags); 485 } 486 487 static int 488 rpcauth_bindcred(struct rpc_task *task, struct rpc_cred *cred, int flags) 489 { 490 struct rpc_rqst *req = task->tk_rqstp; 491 struct rpc_cred *new; 492 int lookupflags = 0; 493 494 if (flags & RPC_TASK_ASYNC) 495 lookupflags |= RPCAUTH_LOOKUP_NEW; 496 if (cred != NULL) 497 new = cred->cr_ops->crbind(task, cred, lookupflags); 498 else if (flags & RPC_TASK_ROOTCREDS) 499 new = rpcauth_bind_root_cred(task, lookupflags); 500 else 501 new = rpcauth_bind_new_cred(task, lookupflags); 502 if (IS_ERR(new)) 503 return PTR_ERR(new); 504 if (req->rq_cred != NULL) 505 put_rpccred(req->rq_cred); 506 req->rq_cred = new; 507 return 0; 508 } 509 510 void 511 put_rpccred(struct rpc_cred *cred) 512 { 513 /* Fast path for unhashed credentials */ 514 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) == 0) { 515 if (atomic_dec_and_test(&cred->cr_count)) 516 cred->cr_ops->crdestroy(cred); 517 return; 518 } 519 520 if (!atomic_dec_and_lock(&cred->cr_count, &rpc_credcache_lock)) 521 return; 522 if (!list_empty(&cred->cr_lru)) { 523 number_cred_unused--; 524 list_del_init(&cred->cr_lru); 525 } 526 if (test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags) != 0) { 527 if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0) { 528 cred->cr_expire = jiffies; 529 list_add_tail(&cred->cr_lru, &cred_unused); 530 number_cred_unused++; 531 goto out_nodestroy; 532 } 533 if (!rpcauth_unhash_cred(cred)) { 534 /* We were hashed and someone looked us up... */ 535 goto out_nodestroy; 536 } 537 } 538 spin_unlock(&rpc_credcache_lock); 539 cred->cr_ops->crdestroy(cred); 540 return; 541 out_nodestroy: 542 spin_unlock(&rpc_credcache_lock); 543 } 544 EXPORT_SYMBOL_GPL(put_rpccred); 545 546 __be32 * 547 rpcauth_marshcred(struct rpc_task *task, __be32 *p) 548 { 549 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 550 551 dprintk("RPC: %5u marshaling %s cred %p\n", 552 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 553 554 return cred->cr_ops->crmarshal(task, p); 555 } 556 557 __be32 * 558 rpcauth_checkverf(struct rpc_task *task, __be32 *p) 559 { 560 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 561 562 dprintk("RPC: %5u validating %s cred %p\n", 563 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 564 565 return cred->cr_ops->crvalidate(task, p); 566 } 567 568 static void rpcauth_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp, 569 __be32 *data, void *obj) 570 { 571 struct xdr_stream xdr; 572 573 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, data); 574 encode(rqstp, &xdr, obj); 575 } 576 577 int 578 rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp, 579 __be32 *data, void *obj) 580 { 581 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 582 583 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n", 584 task->tk_pid, cred->cr_ops->cr_name, cred); 585 if (cred->cr_ops->crwrap_req) 586 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj); 587 /* By default, we encode the arguments normally. */ 588 rpcauth_wrap_req_encode(encode, rqstp, data, obj); 589 return 0; 590 } 591 592 static int 593 rpcauth_unwrap_req_decode(kxdrdproc_t decode, struct rpc_rqst *rqstp, 594 __be32 *data, void *obj) 595 { 596 struct xdr_stream xdr; 597 598 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, data); 599 return decode(rqstp, &xdr, obj); 600 } 601 602 int 603 rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp, 604 __be32 *data, void *obj) 605 { 606 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 607 608 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n", 609 task->tk_pid, cred->cr_ops->cr_name, cred); 610 if (cred->cr_ops->crunwrap_resp) 611 return cred->cr_ops->crunwrap_resp(task, decode, rqstp, 612 data, obj); 613 /* By default, we decode the arguments normally. */ 614 return rpcauth_unwrap_req_decode(decode, rqstp, data, obj); 615 } 616 617 int 618 rpcauth_refreshcred(struct rpc_task *task) 619 { 620 struct rpc_cred *cred; 621 int err; 622 623 cred = task->tk_rqstp->rq_cred; 624 if (cred == NULL) { 625 err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags); 626 if (err < 0) 627 goto out; 628 cred = task->tk_rqstp->rq_cred; 629 } 630 dprintk("RPC: %5u refreshing %s cred %p\n", 631 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 632 633 err = cred->cr_ops->crrefresh(task); 634 out: 635 if (err < 0) 636 task->tk_status = err; 637 return err; 638 } 639 640 void 641 rpcauth_invalcred(struct rpc_task *task) 642 { 643 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 644 645 dprintk("RPC: %5u invalidating %s cred %p\n", 646 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 647 if (cred) 648 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 649 } 650 651 int 652 rpcauth_uptodatecred(struct rpc_task *task) 653 { 654 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 655 656 return cred == NULL || 657 test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0; 658 } 659 660 static struct shrinker rpc_cred_shrinker = { 661 .shrink = rpcauth_cache_shrinker, 662 .seeks = DEFAULT_SEEKS, 663 }; 664 665 int __init rpcauth_init_module(void) 666 { 667 int err; 668 669 err = rpc_init_authunix(); 670 if (err < 0) 671 goto out1; 672 err = rpc_init_generic_auth(); 673 if (err < 0) 674 goto out2; 675 register_shrinker(&rpc_cred_shrinker); 676 return 0; 677 out2: 678 rpc_destroy_authunix(); 679 out1: 680 return err; 681 } 682 683 void rpcauth_remove_module(void) 684 { 685 rpc_destroy_authunix(); 686 rpc_destroy_generic_auth(); 687 unregister_shrinker(&rpc_cred_shrinker); 688 } 689