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 int 567 rpcauth_wrap_req(struct rpc_task *task, kxdrproc_t encode, void *rqstp, 568 __be32 *data, void *obj) 569 { 570 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 571 572 dprintk("RPC: %5u using %s cred %p to wrap rpc data\n", 573 task->tk_pid, cred->cr_ops->cr_name, cred); 574 if (cred->cr_ops->crwrap_req) 575 return cred->cr_ops->crwrap_req(task, encode, rqstp, data, obj); 576 /* By default, we encode the arguments normally. */ 577 return encode(rqstp, data, obj); 578 } 579 580 int 581 rpcauth_unwrap_resp(struct rpc_task *task, kxdrproc_t decode, void *rqstp, 582 __be32 *data, void *obj) 583 { 584 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 585 586 dprintk("RPC: %5u using %s cred %p to unwrap rpc data\n", 587 task->tk_pid, cred->cr_ops->cr_name, cred); 588 if (cred->cr_ops->crunwrap_resp) 589 return cred->cr_ops->crunwrap_resp(task, decode, rqstp, 590 data, obj); 591 /* By default, we decode the arguments normally. */ 592 return decode(rqstp, data, obj); 593 } 594 595 int 596 rpcauth_refreshcred(struct rpc_task *task) 597 { 598 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 599 int err; 600 601 cred = task->tk_rqstp->rq_cred; 602 if (cred == NULL) { 603 err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags); 604 if (err < 0) 605 goto out; 606 cred = task->tk_rqstp->rq_cred; 607 }; 608 dprintk("RPC: %5u refreshing %s cred %p\n", 609 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 610 611 err = cred->cr_ops->crrefresh(task); 612 out: 613 if (err < 0) 614 task->tk_status = err; 615 return err; 616 } 617 618 void 619 rpcauth_invalcred(struct rpc_task *task) 620 { 621 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 622 623 dprintk("RPC: %5u invalidating %s cred %p\n", 624 task->tk_pid, cred->cr_auth->au_ops->au_name, cred); 625 if (cred) 626 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 627 } 628 629 int 630 rpcauth_uptodatecred(struct rpc_task *task) 631 { 632 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 633 634 return cred == NULL || 635 test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0; 636 } 637 638 static struct shrinker rpc_cred_shrinker = { 639 .shrink = rpcauth_cache_shrinker, 640 .seeks = DEFAULT_SEEKS, 641 }; 642 643 int __init rpcauth_init_module(void) 644 { 645 int err; 646 647 err = rpc_init_authunix(); 648 if (err < 0) 649 goto out1; 650 err = rpc_init_generic_auth(); 651 if (err < 0) 652 goto out2; 653 register_shrinker(&rpc_cred_shrinker); 654 return 0; 655 out2: 656 rpc_destroy_authunix(); 657 out1: 658 return err; 659 } 660 661 void __exit rpcauth_remove_module(void) 662 { 663 rpc_destroy_authunix(); 664 rpc_destroy_generic_auth(); 665 unregister_shrinker(&rpc_cred_shrinker); 666 } 667