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