cache.c revision d29068c431599fa96729556846562eb18429092d
1/* 2 * net/sunrpc/cache.c 3 * 4 * Generic code for various authentication-related caches 5 * used by sunrpc clients and servers. 6 * 7 * Copyright (C) 2002 Neil Brown <neilb@cse.unsw.edu.au> 8 * 9 * Released under terms in GPL version 2. See COPYING. 10 * 11 */ 12 13#include <linux/types.h> 14#include <linux/fs.h> 15#include <linux/file.h> 16#include <linux/slab.h> 17#include <linux/signal.h> 18#include <linux/sched.h> 19#include <linux/kmod.h> 20#include <linux/list.h> 21#include <linux/module.h> 22#include <linux/ctype.h> 23#include <asm/uaccess.h> 24#include <linux/poll.h> 25#include <linux/seq_file.h> 26#include <linux/proc_fs.h> 27#include <linux/net.h> 28#include <linux/workqueue.h> 29#include <linux/mutex.h> 30#include <linux/pagemap.h> 31#include <linux/smp_lock.h> 32#include <asm/ioctls.h> 33#include <linux/sunrpc/types.h> 34#include <linux/sunrpc/cache.h> 35#include <linux/sunrpc/stats.h> 36#include <linux/sunrpc/rpc_pipe_fs.h> 37#include "netns.h" 38 39#define RPCDBG_FACILITY RPCDBG_CACHE 40 41static void cache_defer_req(struct cache_req *req, struct cache_head *item); 42static void cache_revisit_request(struct cache_head *item); 43 44static void cache_init(struct cache_head *h) 45{ 46 time_t now = seconds_since_boot(); 47 h->next = NULL; 48 h->flags = 0; 49 kref_init(&h->ref); 50 h->expiry_time = now + CACHE_NEW_EXPIRY; 51 h->last_refresh = now; 52} 53 54static inline int cache_is_expired(struct cache_detail *detail, struct cache_head *h) 55{ 56 return (h->expiry_time < seconds_since_boot()) || 57 (detail->flush_time > h->last_refresh); 58} 59 60struct cache_head *sunrpc_cache_lookup(struct cache_detail *detail, 61 struct cache_head *key, int hash) 62{ 63 struct cache_head **head, **hp; 64 struct cache_head *new = NULL, *freeme = NULL; 65 66 head = &detail->hash_table[hash]; 67 68 read_lock(&detail->hash_lock); 69 70 for (hp=head; *hp != NULL ; hp = &(*hp)->next) { 71 struct cache_head *tmp = *hp; 72 if (detail->match(tmp, key)) { 73 if (cache_is_expired(detail, tmp)) 74 /* This entry is expired, we will discard it. */ 75 break; 76 cache_get(tmp); 77 read_unlock(&detail->hash_lock); 78 return tmp; 79 } 80 } 81 read_unlock(&detail->hash_lock); 82 /* Didn't find anything, insert an empty entry */ 83 84 new = detail->alloc(); 85 if (!new) 86 return NULL; 87 /* must fully initialise 'new', else 88 * we might get lose if we need to 89 * cache_put it soon. 90 */ 91 cache_init(new); 92 detail->init(new, key); 93 94 write_lock(&detail->hash_lock); 95 96 /* check if entry appeared while we slept */ 97 for (hp=head; *hp != NULL ; hp = &(*hp)->next) { 98 struct cache_head *tmp = *hp; 99 if (detail->match(tmp, key)) { 100 if (cache_is_expired(detail, tmp)) { 101 *hp = tmp->next; 102 tmp->next = NULL; 103 detail->entries --; 104 freeme = tmp; 105 break; 106 } 107 cache_get(tmp); 108 write_unlock(&detail->hash_lock); 109 cache_put(new, detail); 110 return tmp; 111 } 112 } 113 new->next = *head; 114 *head = new; 115 detail->entries++; 116 cache_get(new); 117 write_unlock(&detail->hash_lock); 118 119 if (freeme) 120 cache_put(freeme, detail); 121 return new; 122} 123EXPORT_SYMBOL_GPL(sunrpc_cache_lookup); 124 125 126static void cache_dequeue(struct cache_detail *detail, struct cache_head *ch); 127 128static void cache_fresh_locked(struct cache_head *head, time_t expiry) 129{ 130 head->expiry_time = expiry; 131 head->last_refresh = seconds_since_boot(); 132 set_bit(CACHE_VALID, &head->flags); 133} 134 135static void cache_fresh_unlocked(struct cache_head *head, 136 struct cache_detail *detail) 137{ 138 if (test_and_clear_bit(CACHE_PENDING, &head->flags)) { 139 cache_revisit_request(head); 140 cache_dequeue(detail, head); 141 } 142} 143 144struct cache_head *sunrpc_cache_update(struct cache_detail *detail, 145 struct cache_head *new, struct cache_head *old, int hash) 146{ 147 /* The 'old' entry is to be replaced by 'new'. 148 * If 'old' is not VALID, we update it directly, 149 * otherwise we need to replace it 150 */ 151 struct cache_head **head; 152 struct cache_head *tmp; 153 154 if (!test_bit(CACHE_VALID, &old->flags)) { 155 write_lock(&detail->hash_lock); 156 if (!test_bit(CACHE_VALID, &old->flags)) { 157 if (test_bit(CACHE_NEGATIVE, &new->flags)) 158 set_bit(CACHE_NEGATIVE, &old->flags); 159 else 160 detail->update(old, new); 161 cache_fresh_locked(old, new->expiry_time); 162 write_unlock(&detail->hash_lock); 163 cache_fresh_unlocked(old, detail); 164 return old; 165 } 166 write_unlock(&detail->hash_lock); 167 } 168 /* We need to insert a new entry */ 169 tmp = detail->alloc(); 170 if (!tmp) { 171 cache_put(old, detail); 172 return NULL; 173 } 174 cache_init(tmp); 175 detail->init(tmp, old); 176 head = &detail->hash_table[hash]; 177 178 write_lock(&detail->hash_lock); 179 if (test_bit(CACHE_NEGATIVE, &new->flags)) 180 set_bit(CACHE_NEGATIVE, &tmp->flags); 181 else 182 detail->update(tmp, new); 183 tmp->next = *head; 184 *head = tmp; 185 detail->entries++; 186 cache_get(tmp); 187 cache_fresh_locked(tmp, new->expiry_time); 188 cache_fresh_locked(old, 0); 189 write_unlock(&detail->hash_lock); 190 cache_fresh_unlocked(tmp, detail); 191 cache_fresh_unlocked(old, detail); 192 cache_put(old, detail); 193 return tmp; 194} 195EXPORT_SYMBOL_GPL(sunrpc_cache_update); 196 197static int cache_make_upcall(struct cache_detail *cd, struct cache_head *h) 198{ 199 if (!cd->cache_upcall) 200 return -EINVAL; 201 return cd->cache_upcall(cd, h); 202} 203 204static inline int cache_is_valid(struct cache_detail *detail, struct cache_head *h) 205{ 206 if (!test_bit(CACHE_VALID, &h->flags)) 207 return -EAGAIN; 208 else { 209 /* entry is valid */ 210 if (test_bit(CACHE_NEGATIVE, &h->flags)) 211 return -ENOENT; 212 else 213 return 0; 214 } 215} 216 217/* 218 * This is the generic cache management routine for all 219 * the authentication caches. 220 * It checks the currency of a cache item and will (later) 221 * initiate an upcall to fill it if needed. 222 * 223 * 224 * Returns 0 if the cache_head can be used, or cache_puts it and returns 225 * -EAGAIN if upcall is pending and request has been queued 226 * -ETIMEDOUT if upcall failed or request could not be queue or 227 * upcall completed but item is still invalid (implying that 228 * the cache item has been replaced with a newer one). 229 * -ENOENT if cache entry was negative 230 */ 231int cache_check(struct cache_detail *detail, 232 struct cache_head *h, struct cache_req *rqstp) 233{ 234 int rv; 235 long refresh_age, age; 236 237 /* First decide return status as best we can */ 238 rv = cache_is_valid(detail, h); 239 240 /* now see if we want to start an upcall */ 241 refresh_age = (h->expiry_time - h->last_refresh); 242 age = seconds_since_boot() - h->last_refresh; 243 244 if (rqstp == NULL) { 245 if (rv == -EAGAIN) 246 rv = -ENOENT; 247 } else if (rv == -EAGAIN || age > refresh_age/2) { 248 dprintk("RPC: Want update, refage=%ld, age=%ld\n", 249 refresh_age, age); 250 if (!test_and_set_bit(CACHE_PENDING, &h->flags)) { 251 switch (cache_make_upcall(detail, h)) { 252 case -EINVAL: 253 clear_bit(CACHE_PENDING, &h->flags); 254 cache_revisit_request(h); 255 if (rv == -EAGAIN) { 256 set_bit(CACHE_NEGATIVE, &h->flags); 257 cache_fresh_locked(h, seconds_since_boot()+CACHE_NEW_EXPIRY); 258 cache_fresh_unlocked(h, detail); 259 rv = -ENOENT; 260 } 261 break; 262 263 case -EAGAIN: 264 clear_bit(CACHE_PENDING, &h->flags); 265 cache_revisit_request(h); 266 break; 267 } 268 } 269 } 270 271 if (rv == -EAGAIN) { 272 cache_defer_req(rqstp, h); 273 if (!test_bit(CACHE_PENDING, &h->flags)) { 274 /* Request is not deferred */ 275 rv = cache_is_valid(detail, h); 276 if (rv == -EAGAIN) 277 rv = -ETIMEDOUT; 278 } 279 } 280 if (rv) 281 cache_put(h, detail); 282 return rv; 283} 284EXPORT_SYMBOL_GPL(cache_check); 285 286/* 287 * caches need to be periodically cleaned. 288 * For this we maintain a list of cache_detail and 289 * a current pointer into that list and into the table 290 * for that entry. 291 * 292 * Each time clean_cache is called it finds the next non-empty entry 293 * in the current table and walks the list in that entry 294 * looking for entries that can be removed. 295 * 296 * An entry gets removed if: 297 * - The expiry is before current time 298 * - The last_refresh time is before the flush_time for that cache 299 * 300 * later we might drop old entries with non-NEVER expiry if that table 301 * is getting 'full' for some definition of 'full' 302 * 303 * The question of "how often to scan a table" is an interesting one 304 * and is answered in part by the use of the "nextcheck" field in the 305 * cache_detail. 306 * When a scan of a table begins, the nextcheck field is set to a time 307 * that is well into the future. 308 * While scanning, if an expiry time is found that is earlier than the 309 * current nextcheck time, nextcheck is set to that expiry time. 310 * If the flush_time is ever set to a time earlier than the nextcheck 311 * time, the nextcheck time is then set to that flush_time. 312 * 313 * A table is then only scanned if the current time is at least 314 * the nextcheck time. 315 * 316 */ 317 318static LIST_HEAD(cache_list); 319static DEFINE_SPINLOCK(cache_list_lock); 320static struct cache_detail *current_detail; 321static int current_index; 322 323static void do_cache_clean(struct work_struct *work); 324static struct delayed_work cache_cleaner; 325 326static void sunrpc_init_cache_detail(struct cache_detail *cd) 327{ 328 rwlock_init(&cd->hash_lock); 329 INIT_LIST_HEAD(&cd->queue); 330 spin_lock(&cache_list_lock); 331 cd->nextcheck = 0; 332 cd->entries = 0; 333 atomic_set(&cd->readers, 0); 334 cd->last_close = 0; 335 cd->last_warn = -1; 336 list_add(&cd->others, &cache_list); 337 spin_unlock(&cache_list_lock); 338 339 /* start the cleaning process */ 340 schedule_delayed_work(&cache_cleaner, 0); 341} 342 343static void sunrpc_destroy_cache_detail(struct cache_detail *cd) 344{ 345 cache_purge(cd); 346 spin_lock(&cache_list_lock); 347 write_lock(&cd->hash_lock); 348 if (cd->entries || atomic_read(&cd->inuse)) { 349 write_unlock(&cd->hash_lock); 350 spin_unlock(&cache_list_lock); 351 goto out; 352 } 353 if (current_detail == cd) 354 current_detail = NULL; 355 list_del_init(&cd->others); 356 write_unlock(&cd->hash_lock); 357 spin_unlock(&cache_list_lock); 358 if (list_empty(&cache_list)) { 359 /* module must be being unloaded so its safe to kill the worker */ 360 cancel_delayed_work_sync(&cache_cleaner); 361 } 362 return; 363out: 364 printk(KERN_ERR "nfsd: failed to unregister %s cache\n", cd->name); 365} 366 367/* clean cache tries to find something to clean 368 * and cleans it. 369 * It returns 1 if it cleaned something, 370 * 0 if it didn't find anything this time 371 * -1 if it fell off the end of the list. 372 */ 373static int cache_clean(void) 374{ 375 int rv = 0; 376 struct list_head *next; 377 378 spin_lock(&cache_list_lock); 379 380 /* find a suitable table if we don't already have one */ 381 while (current_detail == NULL || 382 current_index >= current_detail->hash_size) { 383 if (current_detail) 384 next = current_detail->others.next; 385 else 386 next = cache_list.next; 387 if (next == &cache_list) { 388 current_detail = NULL; 389 spin_unlock(&cache_list_lock); 390 return -1; 391 } 392 current_detail = list_entry(next, struct cache_detail, others); 393 if (current_detail->nextcheck > seconds_since_boot()) 394 current_index = current_detail->hash_size; 395 else { 396 current_index = 0; 397 current_detail->nextcheck = seconds_since_boot()+30*60; 398 } 399 } 400 401 /* find a non-empty bucket in the table */ 402 while (current_detail && 403 current_index < current_detail->hash_size && 404 current_detail->hash_table[current_index] == NULL) 405 current_index++; 406 407 /* find a cleanable entry in the bucket and clean it, or set to next bucket */ 408 409 if (current_detail && current_index < current_detail->hash_size) { 410 struct cache_head *ch, **cp; 411 struct cache_detail *d; 412 413 write_lock(¤t_detail->hash_lock); 414 415 /* Ok, now to clean this strand */ 416 417 cp = & current_detail->hash_table[current_index]; 418 for (ch = *cp ; ch ; cp = & ch->next, ch = *cp) { 419 if (current_detail->nextcheck > ch->expiry_time) 420 current_detail->nextcheck = ch->expiry_time+1; 421 if (!cache_is_expired(current_detail, ch)) 422 continue; 423 424 *cp = ch->next; 425 ch->next = NULL; 426 current_detail->entries--; 427 rv = 1; 428 break; 429 } 430 431 write_unlock(¤t_detail->hash_lock); 432 d = current_detail; 433 if (!ch) 434 current_index ++; 435 spin_unlock(&cache_list_lock); 436 if (ch) { 437 if (test_and_clear_bit(CACHE_PENDING, &ch->flags)) 438 cache_dequeue(current_detail, ch); 439 cache_revisit_request(ch); 440 cache_put(ch, d); 441 } 442 } else 443 spin_unlock(&cache_list_lock); 444 445 return rv; 446} 447 448/* 449 * We want to regularly clean the cache, so we need to schedule some work ... 450 */ 451static void do_cache_clean(struct work_struct *work) 452{ 453 int delay = 5; 454 if (cache_clean() == -1) 455 delay = round_jiffies_relative(30*HZ); 456 457 if (list_empty(&cache_list)) 458 delay = 0; 459 460 if (delay) 461 schedule_delayed_work(&cache_cleaner, delay); 462} 463 464 465/* 466 * Clean all caches promptly. This just calls cache_clean 467 * repeatedly until we are sure that every cache has had a chance to 468 * be fully cleaned 469 */ 470void cache_flush(void) 471{ 472 while (cache_clean() != -1) 473 cond_resched(); 474 while (cache_clean() != -1) 475 cond_resched(); 476} 477EXPORT_SYMBOL_GPL(cache_flush); 478 479void cache_purge(struct cache_detail *detail) 480{ 481 detail->flush_time = LONG_MAX; 482 detail->nextcheck = seconds_since_boot(); 483 cache_flush(); 484 detail->flush_time = 1; 485} 486EXPORT_SYMBOL_GPL(cache_purge); 487 488 489/* 490 * Deferral and Revisiting of Requests. 491 * 492 * If a cache lookup finds a pending entry, we 493 * need to defer the request and revisit it later. 494 * All deferred requests are stored in a hash table, 495 * indexed by "struct cache_head *". 496 * As it may be wasteful to store a whole request 497 * structure, we allow the request to provide a 498 * deferred form, which must contain a 499 * 'struct cache_deferred_req' 500 * This cache_deferred_req contains a method to allow 501 * it to be revisited when cache info is available 502 */ 503 504#define DFR_HASHSIZE (PAGE_SIZE/sizeof(struct list_head)) 505#define DFR_HASH(item) ((((long)item)>>4 ^ (((long)item)>>13)) % DFR_HASHSIZE) 506 507#define DFR_MAX 300 /* ??? */ 508 509static DEFINE_SPINLOCK(cache_defer_lock); 510static LIST_HEAD(cache_defer_list); 511static struct hlist_head cache_defer_hash[DFR_HASHSIZE]; 512static int cache_defer_cnt; 513 514static void __unhash_deferred_req(struct cache_deferred_req *dreq) 515{ 516 list_del_init(&dreq->recent); 517 hlist_del_init(&dreq->hash); 518 cache_defer_cnt--; 519} 520 521static void __hash_deferred_req(struct cache_deferred_req *dreq, struct cache_head *item) 522{ 523 int hash = DFR_HASH(item); 524 525 list_add(&dreq->recent, &cache_defer_list); 526 hlist_add_head(&dreq->hash, &cache_defer_hash[hash]); 527} 528 529static void setup_deferral(struct cache_deferred_req *dreq, struct cache_head *item) 530{ 531 struct cache_deferred_req *discard; 532 533 dreq->item = item; 534 535 spin_lock(&cache_defer_lock); 536 537 __hash_deferred_req(dreq, item); 538 539 /* it is in, now maybe clean up */ 540 discard = NULL; 541 if (++cache_defer_cnt > DFR_MAX) { 542 discard = list_entry(cache_defer_list.prev, 543 struct cache_deferred_req, recent); 544 __unhash_deferred_req(discard); 545 } 546 spin_unlock(&cache_defer_lock); 547 548 if (discard) 549 /* there was one too many */ 550 discard->revisit(discard, 1); 551} 552 553struct thread_deferred_req { 554 struct cache_deferred_req handle; 555 struct completion completion; 556}; 557 558static void cache_restart_thread(struct cache_deferred_req *dreq, int too_many) 559{ 560 struct thread_deferred_req *dr = 561 container_of(dreq, struct thread_deferred_req, handle); 562 complete(&dr->completion); 563} 564 565static void cache_wait_req(struct cache_req *req, struct cache_head *item) 566{ 567 struct thread_deferred_req sleeper; 568 struct cache_deferred_req *dreq = &sleeper.handle; 569 570 sleeper.completion = COMPLETION_INITIALIZER_ONSTACK(sleeper.completion); 571 dreq->revisit = cache_restart_thread; 572 573 setup_deferral(dreq, item); 574 575 if (!test_bit(CACHE_PENDING, &item->flags) || 576 wait_for_completion_interruptible_timeout( 577 &sleeper.completion, req->thread_wait) <= 0) { 578 /* The completion wasn't completed, so we need 579 * to clean up 580 */ 581 spin_lock(&cache_defer_lock); 582 if (!hlist_unhashed(&sleeper.handle.hash)) { 583 __unhash_deferred_req(&sleeper.handle); 584 spin_unlock(&cache_defer_lock); 585 } else { 586 /* cache_revisit_request already removed 587 * this from the hash table, but hasn't 588 * called ->revisit yet. It will very soon 589 * and we need to wait for it. 590 */ 591 spin_unlock(&cache_defer_lock); 592 wait_for_completion(&sleeper.completion); 593 } 594 } 595} 596 597static void cache_defer_req(struct cache_req *req, struct cache_head *item) 598{ 599 struct cache_deferred_req *dreq; 600 601 if (cache_defer_cnt >= DFR_MAX) 602 /* too much in the cache, randomly drop this one, 603 * or continue and drop the oldest 604 */ 605 if (net_random()&1) 606 return; 607 608 609 if (req->thread_wait) { 610 cache_wait_req(req, item); 611 if (!test_bit(CACHE_PENDING, &item->flags)) 612 return; 613 } 614 dreq = req->defer(req); 615 if (dreq == NULL) 616 return; 617 setup_deferral(dreq, item); 618 if (!test_bit(CACHE_PENDING, &item->flags)) 619 /* Bit could have been cleared before we managed to 620 * set up the deferral, so need to revisit just in case 621 */ 622 cache_revisit_request(item); 623} 624 625static void cache_revisit_request(struct cache_head *item) 626{ 627 struct cache_deferred_req *dreq; 628 struct list_head pending; 629 struct hlist_node *lp, *tmp; 630 int hash = DFR_HASH(item); 631 632 INIT_LIST_HEAD(&pending); 633 spin_lock(&cache_defer_lock); 634 635 hlist_for_each_entry_safe(dreq, lp, tmp, &cache_defer_hash[hash], hash) 636 if (dreq->item == item) { 637 __unhash_deferred_req(dreq); 638 list_add(&dreq->recent, &pending); 639 } 640 641 spin_unlock(&cache_defer_lock); 642 643 while (!list_empty(&pending)) { 644 dreq = list_entry(pending.next, struct cache_deferred_req, recent); 645 list_del_init(&dreq->recent); 646 dreq->revisit(dreq, 0); 647 } 648} 649 650void cache_clean_deferred(void *owner) 651{ 652 struct cache_deferred_req *dreq, *tmp; 653 struct list_head pending; 654 655 656 INIT_LIST_HEAD(&pending); 657 spin_lock(&cache_defer_lock); 658 659 list_for_each_entry_safe(dreq, tmp, &cache_defer_list, recent) { 660 if (dreq->owner == owner) { 661 __unhash_deferred_req(dreq); 662 list_add(&dreq->recent, &pending); 663 } 664 } 665 spin_unlock(&cache_defer_lock); 666 667 while (!list_empty(&pending)) { 668 dreq = list_entry(pending.next, struct cache_deferred_req, recent); 669 list_del_init(&dreq->recent); 670 dreq->revisit(dreq, 1); 671 } 672} 673 674/* 675 * communicate with user-space 676 * 677 * We have a magic /proc file - /proc/sunrpc/<cachename>/channel. 678 * On read, you get a full request, or block. 679 * On write, an update request is processed. 680 * Poll works if anything to read, and always allows write. 681 * 682 * Implemented by linked list of requests. Each open file has 683 * a ->private that also exists in this list. New requests are added 684 * to the end and may wakeup and preceding readers. 685 * New readers are added to the head. If, on read, an item is found with 686 * CACHE_UPCALLING clear, we free it from the list. 687 * 688 */ 689 690static DEFINE_SPINLOCK(queue_lock); 691static DEFINE_MUTEX(queue_io_mutex); 692 693struct cache_queue { 694 struct list_head list; 695 int reader; /* if 0, then request */ 696}; 697struct cache_request { 698 struct cache_queue q; 699 struct cache_head *item; 700 char * buf; 701 int len; 702 int readers; 703}; 704struct cache_reader { 705 struct cache_queue q; 706 int offset; /* if non-0, we have a refcnt on next request */ 707}; 708 709static ssize_t cache_read(struct file *filp, char __user *buf, size_t count, 710 loff_t *ppos, struct cache_detail *cd) 711{ 712 struct cache_reader *rp = filp->private_data; 713 struct cache_request *rq; 714 struct inode *inode = filp->f_path.dentry->d_inode; 715 int err; 716 717 if (count == 0) 718 return 0; 719 720 mutex_lock(&inode->i_mutex); /* protect against multiple concurrent 721 * readers on this file */ 722 again: 723 spin_lock(&queue_lock); 724 /* need to find next request */ 725 while (rp->q.list.next != &cd->queue && 726 list_entry(rp->q.list.next, struct cache_queue, list) 727 ->reader) { 728 struct list_head *next = rp->q.list.next; 729 list_move(&rp->q.list, next); 730 } 731 if (rp->q.list.next == &cd->queue) { 732 spin_unlock(&queue_lock); 733 mutex_unlock(&inode->i_mutex); 734 BUG_ON(rp->offset); 735 return 0; 736 } 737 rq = container_of(rp->q.list.next, struct cache_request, q.list); 738 BUG_ON(rq->q.reader); 739 if (rp->offset == 0) 740 rq->readers++; 741 spin_unlock(&queue_lock); 742 743 if (rp->offset == 0 && !test_bit(CACHE_PENDING, &rq->item->flags)) { 744 err = -EAGAIN; 745 spin_lock(&queue_lock); 746 list_move(&rp->q.list, &rq->q.list); 747 spin_unlock(&queue_lock); 748 } else { 749 if (rp->offset + count > rq->len) 750 count = rq->len - rp->offset; 751 err = -EFAULT; 752 if (copy_to_user(buf, rq->buf + rp->offset, count)) 753 goto out; 754 rp->offset += count; 755 if (rp->offset >= rq->len) { 756 rp->offset = 0; 757 spin_lock(&queue_lock); 758 list_move(&rp->q.list, &rq->q.list); 759 spin_unlock(&queue_lock); 760 } 761 err = 0; 762 } 763 out: 764 if (rp->offset == 0) { 765 /* need to release rq */ 766 spin_lock(&queue_lock); 767 rq->readers--; 768 if (rq->readers == 0 && 769 !test_bit(CACHE_PENDING, &rq->item->flags)) { 770 list_del(&rq->q.list); 771 spin_unlock(&queue_lock); 772 cache_put(rq->item, cd); 773 kfree(rq->buf); 774 kfree(rq); 775 } else 776 spin_unlock(&queue_lock); 777 } 778 if (err == -EAGAIN) 779 goto again; 780 mutex_unlock(&inode->i_mutex); 781 return err ? err : count; 782} 783 784static ssize_t cache_do_downcall(char *kaddr, const char __user *buf, 785 size_t count, struct cache_detail *cd) 786{ 787 ssize_t ret; 788 789 if (copy_from_user(kaddr, buf, count)) 790 return -EFAULT; 791 kaddr[count] = '\0'; 792 ret = cd->cache_parse(cd, kaddr, count); 793 if (!ret) 794 ret = count; 795 return ret; 796} 797 798static ssize_t cache_slow_downcall(const char __user *buf, 799 size_t count, struct cache_detail *cd) 800{ 801 static char write_buf[8192]; /* protected by queue_io_mutex */ 802 ssize_t ret = -EINVAL; 803 804 if (count >= sizeof(write_buf)) 805 goto out; 806 mutex_lock(&queue_io_mutex); 807 ret = cache_do_downcall(write_buf, buf, count, cd); 808 mutex_unlock(&queue_io_mutex); 809out: 810 return ret; 811} 812 813static ssize_t cache_downcall(struct address_space *mapping, 814 const char __user *buf, 815 size_t count, struct cache_detail *cd) 816{ 817 struct page *page; 818 char *kaddr; 819 ssize_t ret = -ENOMEM; 820 821 if (count >= PAGE_CACHE_SIZE) 822 goto out_slow; 823 824 page = find_or_create_page(mapping, 0, GFP_KERNEL); 825 if (!page) 826 goto out_slow; 827 828 kaddr = kmap(page); 829 ret = cache_do_downcall(kaddr, buf, count, cd); 830 kunmap(page); 831 unlock_page(page); 832 page_cache_release(page); 833 return ret; 834out_slow: 835 return cache_slow_downcall(buf, count, cd); 836} 837 838static ssize_t cache_write(struct file *filp, const char __user *buf, 839 size_t count, loff_t *ppos, 840 struct cache_detail *cd) 841{ 842 struct address_space *mapping = filp->f_mapping; 843 struct inode *inode = filp->f_path.dentry->d_inode; 844 ssize_t ret = -EINVAL; 845 846 if (!cd->cache_parse) 847 goto out; 848 849 mutex_lock(&inode->i_mutex); 850 ret = cache_downcall(mapping, buf, count, cd); 851 mutex_unlock(&inode->i_mutex); 852out: 853 return ret; 854} 855 856static DECLARE_WAIT_QUEUE_HEAD(queue_wait); 857 858static unsigned int cache_poll(struct file *filp, poll_table *wait, 859 struct cache_detail *cd) 860{ 861 unsigned int mask; 862 struct cache_reader *rp = filp->private_data; 863 struct cache_queue *cq; 864 865 poll_wait(filp, &queue_wait, wait); 866 867 /* alway allow write */ 868 mask = POLL_OUT | POLLWRNORM; 869 870 if (!rp) 871 return mask; 872 873 spin_lock(&queue_lock); 874 875 for (cq= &rp->q; &cq->list != &cd->queue; 876 cq = list_entry(cq->list.next, struct cache_queue, list)) 877 if (!cq->reader) { 878 mask |= POLLIN | POLLRDNORM; 879 break; 880 } 881 spin_unlock(&queue_lock); 882 return mask; 883} 884 885static int cache_ioctl(struct inode *ino, struct file *filp, 886 unsigned int cmd, unsigned long arg, 887 struct cache_detail *cd) 888{ 889 int len = 0; 890 struct cache_reader *rp = filp->private_data; 891 struct cache_queue *cq; 892 893 if (cmd != FIONREAD || !rp) 894 return -EINVAL; 895 896 spin_lock(&queue_lock); 897 898 /* only find the length remaining in current request, 899 * or the length of the next request 900 */ 901 for (cq= &rp->q; &cq->list != &cd->queue; 902 cq = list_entry(cq->list.next, struct cache_queue, list)) 903 if (!cq->reader) { 904 struct cache_request *cr = 905 container_of(cq, struct cache_request, q); 906 len = cr->len - rp->offset; 907 break; 908 } 909 spin_unlock(&queue_lock); 910 911 return put_user(len, (int __user *)arg); 912} 913 914static int cache_open(struct inode *inode, struct file *filp, 915 struct cache_detail *cd) 916{ 917 struct cache_reader *rp = NULL; 918 919 if (!cd || !try_module_get(cd->owner)) 920 return -EACCES; 921 nonseekable_open(inode, filp); 922 if (filp->f_mode & FMODE_READ) { 923 rp = kmalloc(sizeof(*rp), GFP_KERNEL); 924 if (!rp) 925 return -ENOMEM; 926 rp->offset = 0; 927 rp->q.reader = 1; 928 atomic_inc(&cd->readers); 929 spin_lock(&queue_lock); 930 list_add(&rp->q.list, &cd->queue); 931 spin_unlock(&queue_lock); 932 } 933 filp->private_data = rp; 934 return 0; 935} 936 937static int cache_release(struct inode *inode, struct file *filp, 938 struct cache_detail *cd) 939{ 940 struct cache_reader *rp = filp->private_data; 941 942 if (rp) { 943 spin_lock(&queue_lock); 944 if (rp->offset) { 945 struct cache_queue *cq; 946 for (cq= &rp->q; &cq->list != &cd->queue; 947 cq = list_entry(cq->list.next, struct cache_queue, list)) 948 if (!cq->reader) { 949 container_of(cq, struct cache_request, q) 950 ->readers--; 951 break; 952 } 953 rp->offset = 0; 954 } 955 list_del(&rp->q.list); 956 spin_unlock(&queue_lock); 957 958 filp->private_data = NULL; 959 kfree(rp); 960 961 cd->last_close = seconds_since_boot(); 962 atomic_dec(&cd->readers); 963 } 964 module_put(cd->owner); 965 return 0; 966} 967 968 969 970static void cache_dequeue(struct cache_detail *detail, struct cache_head *ch) 971{ 972 struct cache_queue *cq; 973 spin_lock(&queue_lock); 974 list_for_each_entry(cq, &detail->queue, list) 975 if (!cq->reader) { 976 struct cache_request *cr = container_of(cq, struct cache_request, q); 977 if (cr->item != ch) 978 continue; 979 if (cr->readers != 0) 980 continue; 981 list_del(&cr->q.list); 982 spin_unlock(&queue_lock); 983 cache_put(cr->item, detail); 984 kfree(cr->buf); 985 kfree(cr); 986 return; 987 } 988 spin_unlock(&queue_lock); 989} 990 991/* 992 * Support routines for text-based upcalls. 993 * Fields are separated by spaces. 994 * Fields are either mangled to quote space tab newline slosh with slosh 995 * or a hexified with a leading \x 996 * Record is terminated with newline. 997 * 998 */ 999 1000void qword_add(char **bpp, int *lp, char *str) 1001{ 1002 char *bp = *bpp; 1003 int len = *lp; 1004 char c; 1005 1006 if (len < 0) return; 1007 1008 while ((c=*str++) && len) 1009 switch(c) { 1010 case ' ': 1011 case '\t': 1012 case '\n': 1013 case '\\': 1014 if (len >= 4) { 1015 *bp++ = '\\'; 1016 *bp++ = '0' + ((c & 0300)>>6); 1017 *bp++ = '0' + ((c & 0070)>>3); 1018 *bp++ = '0' + ((c & 0007)>>0); 1019 } 1020 len -= 4; 1021 break; 1022 default: 1023 *bp++ = c; 1024 len--; 1025 } 1026 if (c || len <1) len = -1; 1027 else { 1028 *bp++ = ' '; 1029 len--; 1030 } 1031 *bpp = bp; 1032 *lp = len; 1033} 1034EXPORT_SYMBOL_GPL(qword_add); 1035 1036void qword_addhex(char **bpp, int *lp, char *buf, int blen) 1037{ 1038 char *bp = *bpp; 1039 int len = *lp; 1040 1041 if (len < 0) return; 1042 1043 if (len > 2) { 1044 *bp++ = '\\'; 1045 *bp++ = 'x'; 1046 len -= 2; 1047 while (blen && len >= 2) { 1048 unsigned char c = *buf++; 1049 *bp++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1); 1050 *bp++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1); 1051 len -= 2; 1052 blen--; 1053 } 1054 } 1055 if (blen || len<1) len = -1; 1056 else { 1057 *bp++ = ' '; 1058 len--; 1059 } 1060 *bpp = bp; 1061 *lp = len; 1062} 1063EXPORT_SYMBOL_GPL(qword_addhex); 1064 1065static void warn_no_listener(struct cache_detail *detail) 1066{ 1067 if (detail->last_warn != detail->last_close) { 1068 detail->last_warn = detail->last_close; 1069 if (detail->warn_no_listener) 1070 detail->warn_no_listener(detail, detail->last_close != 0); 1071 } 1072} 1073 1074static bool cache_listeners_exist(struct cache_detail *detail) 1075{ 1076 if (atomic_read(&detail->readers)) 1077 return true; 1078 if (detail->last_close == 0) 1079 /* This cache was never opened */ 1080 return false; 1081 if (detail->last_close < seconds_since_boot() - 30) 1082 /* 1083 * We allow for the possibility that someone might 1084 * restart a userspace daemon without restarting the 1085 * server; but after 30 seconds, we give up. 1086 */ 1087 return false; 1088 return true; 1089} 1090 1091/* 1092 * register an upcall request to user-space and queue it up for read() by the 1093 * upcall daemon. 1094 * 1095 * Each request is at most one page long. 1096 */ 1097int sunrpc_cache_pipe_upcall(struct cache_detail *detail, struct cache_head *h, 1098 void (*cache_request)(struct cache_detail *, 1099 struct cache_head *, 1100 char **, 1101 int *)) 1102{ 1103 1104 char *buf; 1105 struct cache_request *crq; 1106 char *bp; 1107 int len; 1108 1109 if (!cache_listeners_exist(detail)) { 1110 warn_no_listener(detail); 1111 return -EINVAL; 1112 } 1113 1114 buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 1115 if (!buf) 1116 return -EAGAIN; 1117 1118 crq = kmalloc(sizeof (*crq), GFP_KERNEL); 1119 if (!crq) { 1120 kfree(buf); 1121 return -EAGAIN; 1122 } 1123 1124 bp = buf; len = PAGE_SIZE; 1125 1126 cache_request(detail, h, &bp, &len); 1127 1128 if (len < 0) { 1129 kfree(buf); 1130 kfree(crq); 1131 return -EAGAIN; 1132 } 1133 crq->q.reader = 0; 1134 crq->item = cache_get(h); 1135 crq->buf = buf; 1136 crq->len = PAGE_SIZE - len; 1137 crq->readers = 0; 1138 spin_lock(&queue_lock); 1139 list_add_tail(&crq->q.list, &detail->queue); 1140 spin_unlock(&queue_lock); 1141 wake_up(&queue_wait); 1142 return 0; 1143} 1144EXPORT_SYMBOL_GPL(sunrpc_cache_pipe_upcall); 1145 1146/* 1147 * parse a message from user-space and pass it 1148 * to an appropriate cache 1149 * Messages are, like requests, separated into fields by 1150 * spaces and dequotes as \xHEXSTRING or embedded \nnn octal 1151 * 1152 * Message is 1153 * reply cachename expiry key ... content.... 1154 * 1155 * key and content are both parsed by cache 1156 */ 1157 1158#define isodigit(c) (isdigit(c) && c <= '7') 1159int qword_get(char **bpp, char *dest, int bufsize) 1160{ 1161 /* return bytes copied, or -1 on error */ 1162 char *bp = *bpp; 1163 int len = 0; 1164 1165 while (*bp == ' ') bp++; 1166 1167 if (bp[0] == '\\' && bp[1] == 'x') { 1168 /* HEX STRING */ 1169 bp += 2; 1170 while (len < bufsize) { 1171 int h, l; 1172 1173 h = hex_to_bin(bp[0]); 1174 if (h < 0) 1175 break; 1176 1177 l = hex_to_bin(bp[1]); 1178 if (l < 0) 1179 break; 1180 1181 *dest++ = (h << 4) | l; 1182 bp += 2; 1183 len++; 1184 } 1185 } else { 1186 /* text with \nnn octal quoting */ 1187 while (*bp != ' ' && *bp != '\n' && *bp && len < bufsize-1) { 1188 if (*bp == '\\' && 1189 isodigit(bp[1]) && (bp[1] <= '3') && 1190 isodigit(bp[2]) && 1191 isodigit(bp[3])) { 1192 int byte = (*++bp -'0'); 1193 bp++; 1194 byte = (byte << 3) | (*bp++ - '0'); 1195 byte = (byte << 3) | (*bp++ - '0'); 1196 *dest++ = byte; 1197 len++; 1198 } else { 1199 *dest++ = *bp++; 1200 len++; 1201 } 1202 } 1203 } 1204 1205 if (*bp != ' ' && *bp != '\n' && *bp != '\0') 1206 return -1; 1207 while (*bp == ' ') bp++; 1208 *bpp = bp; 1209 *dest = '\0'; 1210 return len; 1211} 1212EXPORT_SYMBOL_GPL(qword_get); 1213 1214 1215/* 1216 * support /proc/sunrpc/cache/$CACHENAME/content 1217 * as a seqfile. 1218 * We call ->cache_show passing NULL for the item to 1219 * get a header, then pass each real item in the cache 1220 */ 1221 1222struct handle { 1223 struct cache_detail *cd; 1224}; 1225 1226static void *c_start(struct seq_file *m, loff_t *pos) 1227 __acquires(cd->hash_lock) 1228{ 1229 loff_t n = *pos; 1230 unsigned hash, entry; 1231 struct cache_head *ch; 1232 struct cache_detail *cd = ((struct handle*)m->private)->cd; 1233 1234 1235 read_lock(&cd->hash_lock); 1236 if (!n--) 1237 return SEQ_START_TOKEN; 1238 hash = n >> 32; 1239 entry = n & ((1LL<<32) - 1); 1240 1241 for (ch=cd->hash_table[hash]; ch; ch=ch->next) 1242 if (!entry--) 1243 return ch; 1244 n &= ~((1LL<<32) - 1); 1245 do { 1246 hash++; 1247 n += 1LL<<32; 1248 } while(hash < cd->hash_size && 1249 cd->hash_table[hash]==NULL); 1250 if (hash >= cd->hash_size) 1251 return NULL; 1252 *pos = n+1; 1253 return cd->hash_table[hash]; 1254} 1255 1256static void *c_next(struct seq_file *m, void *p, loff_t *pos) 1257{ 1258 struct cache_head *ch = p; 1259 int hash = (*pos >> 32); 1260 struct cache_detail *cd = ((struct handle*)m->private)->cd; 1261 1262 if (p == SEQ_START_TOKEN) 1263 hash = 0; 1264 else if (ch->next == NULL) { 1265 hash++; 1266 *pos += 1LL<<32; 1267 } else { 1268 ++*pos; 1269 return ch->next; 1270 } 1271 *pos &= ~((1LL<<32) - 1); 1272 while (hash < cd->hash_size && 1273 cd->hash_table[hash] == NULL) { 1274 hash++; 1275 *pos += 1LL<<32; 1276 } 1277 if (hash >= cd->hash_size) 1278 return NULL; 1279 ++*pos; 1280 return cd->hash_table[hash]; 1281} 1282 1283static void c_stop(struct seq_file *m, void *p) 1284 __releases(cd->hash_lock) 1285{ 1286 struct cache_detail *cd = ((struct handle*)m->private)->cd; 1287 read_unlock(&cd->hash_lock); 1288} 1289 1290static int c_show(struct seq_file *m, void *p) 1291{ 1292 struct cache_head *cp = p; 1293 struct cache_detail *cd = ((struct handle*)m->private)->cd; 1294 1295 if (p == SEQ_START_TOKEN) 1296 return cd->cache_show(m, cd, NULL); 1297 1298 ifdebug(CACHE) 1299 seq_printf(m, "# expiry=%ld refcnt=%d flags=%lx\n", 1300 convert_to_wallclock(cp->expiry_time), 1301 atomic_read(&cp->ref.refcount), cp->flags); 1302 cache_get(cp); 1303 if (cache_check(cd, cp, NULL)) 1304 /* cache_check does a cache_put on failure */ 1305 seq_printf(m, "# "); 1306 else 1307 cache_put(cp, cd); 1308 1309 return cd->cache_show(m, cd, cp); 1310} 1311 1312static const struct seq_operations cache_content_op = { 1313 .start = c_start, 1314 .next = c_next, 1315 .stop = c_stop, 1316 .show = c_show, 1317}; 1318 1319static int content_open(struct inode *inode, struct file *file, 1320 struct cache_detail *cd) 1321{ 1322 struct handle *han; 1323 1324 if (!cd || !try_module_get(cd->owner)) 1325 return -EACCES; 1326 han = __seq_open_private(file, &cache_content_op, sizeof(*han)); 1327 if (han == NULL) { 1328 module_put(cd->owner); 1329 return -ENOMEM; 1330 } 1331 1332 han->cd = cd; 1333 return 0; 1334} 1335 1336static int content_release(struct inode *inode, struct file *file, 1337 struct cache_detail *cd) 1338{ 1339 int ret = seq_release_private(inode, file); 1340 module_put(cd->owner); 1341 return ret; 1342} 1343 1344static int open_flush(struct inode *inode, struct file *file, 1345 struct cache_detail *cd) 1346{ 1347 if (!cd || !try_module_get(cd->owner)) 1348 return -EACCES; 1349 return nonseekable_open(inode, file); 1350} 1351 1352static int release_flush(struct inode *inode, struct file *file, 1353 struct cache_detail *cd) 1354{ 1355 module_put(cd->owner); 1356 return 0; 1357} 1358 1359static ssize_t read_flush(struct file *file, char __user *buf, 1360 size_t count, loff_t *ppos, 1361 struct cache_detail *cd) 1362{ 1363 char tbuf[20]; 1364 unsigned long p = *ppos; 1365 size_t len; 1366 1367 sprintf(tbuf, "%lu\n", convert_to_wallclock(cd->flush_time)); 1368 len = strlen(tbuf); 1369 if (p >= len) 1370 return 0; 1371 len -= p; 1372 if (len > count) 1373 len = count; 1374 if (copy_to_user(buf, (void*)(tbuf+p), len)) 1375 return -EFAULT; 1376 *ppos += len; 1377 return len; 1378} 1379 1380static ssize_t write_flush(struct file *file, const char __user *buf, 1381 size_t count, loff_t *ppos, 1382 struct cache_detail *cd) 1383{ 1384 char tbuf[20]; 1385 char *bp, *ep; 1386 1387 if (*ppos || count > sizeof(tbuf)-1) 1388 return -EINVAL; 1389 if (copy_from_user(tbuf, buf, count)) 1390 return -EFAULT; 1391 tbuf[count] = 0; 1392 simple_strtoul(tbuf, &ep, 0); 1393 if (*ep && *ep != '\n') 1394 return -EINVAL; 1395 1396 bp = tbuf; 1397 cd->flush_time = get_expiry(&bp); 1398 cd->nextcheck = seconds_since_boot(); 1399 cache_flush(); 1400 1401 *ppos += count; 1402 return count; 1403} 1404 1405static ssize_t cache_read_procfs(struct file *filp, char __user *buf, 1406 size_t count, loff_t *ppos) 1407{ 1408 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; 1409 1410 return cache_read(filp, buf, count, ppos, cd); 1411} 1412 1413static ssize_t cache_write_procfs(struct file *filp, const char __user *buf, 1414 size_t count, loff_t *ppos) 1415{ 1416 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; 1417 1418 return cache_write(filp, buf, count, ppos, cd); 1419} 1420 1421static unsigned int cache_poll_procfs(struct file *filp, poll_table *wait) 1422{ 1423 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; 1424 1425 return cache_poll(filp, wait, cd); 1426} 1427 1428static long cache_ioctl_procfs(struct file *filp, 1429 unsigned int cmd, unsigned long arg) 1430{ 1431 long ret; 1432 struct inode *inode = filp->f_path.dentry->d_inode; 1433 struct cache_detail *cd = PDE(inode)->data; 1434 1435 lock_kernel(); 1436 ret = cache_ioctl(inode, filp, cmd, arg, cd); 1437 unlock_kernel(); 1438 1439 return ret; 1440} 1441 1442static int cache_open_procfs(struct inode *inode, struct file *filp) 1443{ 1444 struct cache_detail *cd = PDE(inode)->data; 1445 1446 return cache_open(inode, filp, cd); 1447} 1448 1449static int cache_release_procfs(struct inode *inode, struct file *filp) 1450{ 1451 struct cache_detail *cd = PDE(inode)->data; 1452 1453 return cache_release(inode, filp, cd); 1454} 1455 1456static const struct file_operations cache_file_operations_procfs = { 1457 .owner = THIS_MODULE, 1458 .llseek = no_llseek, 1459 .read = cache_read_procfs, 1460 .write = cache_write_procfs, 1461 .poll = cache_poll_procfs, 1462 .unlocked_ioctl = cache_ioctl_procfs, /* for FIONREAD */ 1463 .open = cache_open_procfs, 1464 .release = cache_release_procfs, 1465}; 1466 1467static int content_open_procfs(struct inode *inode, struct file *filp) 1468{ 1469 struct cache_detail *cd = PDE(inode)->data; 1470 1471 return content_open(inode, filp, cd); 1472} 1473 1474static int content_release_procfs(struct inode *inode, struct file *filp) 1475{ 1476 struct cache_detail *cd = PDE(inode)->data; 1477 1478 return content_release(inode, filp, cd); 1479} 1480 1481static const struct file_operations content_file_operations_procfs = { 1482 .open = content_open_procfs, 1483 .read = seq_read, 1484 .llseek = seq_lseek, 1485 .release = content_release_procfs, 1486}; 1487 1488static int open_flush_procfs(struct inode *inode, struct file *filp) 1489{ 1490 struct cache_detail *cd = PDE(inode)->data; 1491 1492 return open_flush(inode, filp, cd); 1493} 1494 1495static int release_flush_procfs(struct inode *inode, struct file *filp) 1496{ 1497 struct cache_detail *cd = PDE(inode)->data; 1498 1499 return release_flush(inode, filp, cd); 1500} 1501 1502static ssize_t read_flush_procfs(struct file *filp, char __user *buf, 1503 size_t count, loff_t *ppos) 1504{ 1505 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; 1506 1507 return read_flush(filp, buf, count, ppos, cd); 1508} 1509 1510static ssize_t write_flush_procfs(struct file *filp, 1511 const char __user *buf, 1512 size_t count, loff_t *ppos) 1513{ 1514 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data; 1515 1516 return write_flush(filp, buf, count, ppos, cd); 1517} 1518 1519static const struct file_operations cache_flush_operations_procfs = { 1520 .open = open_flush_procfs, 1521 .read = read_flush_procfs, 1522 .write = write_flush_procfs, 1523 .release = release_flush_procfs, 1524}; 1525 1526static void remove_cache_proc_entries(struct cache_detail *cd, struct net *net) 1527{ 1528 struct sunrpc_net *sn; 1529 1530 if (cd->u.procfs.proc_ent == NULL) 1531 return; 1532 if (cd->u.procfs.flush_ent) 1533 remove_proc_entry("flush", cd->u.procfs.proc_ent); 1534 if (cd->u.procfs.channel_ent) 1535 remove_proc_entry("channel", cd->u.procfs.proc_ent); 1536 if (cd->u.procfs.content_ent) 1537 remove_proc_entry("content", cd->u.procfs.proc_ent); 1538 cd->u.procfs.proc_ent = NULL; 1539 sn = net_generic(net, sunrpc_net_id); 1540 remove_proc_entry(cd->name, sn->proc_net_rpc); 1541} 1542 1543#ifdef CONFIG_PROC_FS 1544static int create_cache_proc_entries(struct cache_detail *cd, struct net *net) 1545{ 1546 struct proc_dir_entry *p; 1547 struct sunrpc_net *sn; 1548 1549 sn = net_generic(net, sunrpc_net_id); 1550 cd->u.procfs.proc_ent = proc_mkdir(cd->name, sn->proc_net_rpc); 1551 if (cd->u.procfs.proc_ent == NULL) 1552 goto out_nomem; 1553 cd->u.procfs.channel_ent = NULL; 1554 cd->u.procfs.content_ent = NULL; 1555 1556 p = proc_create_data("flush", S_IFREG|S_IRUSR|S_IWUSR, 1557 cd->u.procfs.proc_ent, 1558 &cache_flush_operations_procfs, cd); 1559 cd->u.procfs.flush_ent = p; 1560 if (p == NULL) 1561 goto out_nomem; 1562 1563 if (cd->cache_upcall || cd->cache_parse) { 1564 p = proc_create_data("channel", S_IFREG|S_IRUSR|S_IWUSR, 1565 cd->u.procfs.proc_ent, 1566 &cache_file_operations_procfs, cd); 1567 cd->u.procfs.channel_ent = p; 1568 if (p == NULL) 1569 goto out_nomem; 1570 } 1571 if (cd->cache_show) { 1572 p = proc_create_data("content", S_IFREG|S_IRUSR|S_IWUSR, 1573 cd->u.procfs.proc_ent, 1574 &content_file_operations_procfs, cd); 1575 cd->u.procfs.content_ent = p; 1576 if (p == NULL) 1577 goto out_nomem; 1578 } 1579 return 0; 1580out_nomem: 1581 remove_cache_proc_entries(cd, net); 1582 return -ENOMEM; 1583} 1584#else /* CONFIG_PROC_FS */ 1585static int create_cache_proc_entries(struct cache_detail *cd, struct net *net) 1586{ 1587 return 0; 1588} 1589#endif 1590 1591void __init cache_initialize(void) 1592{ 1593 INIT_DELAYED_WORK_DEFERRABLE(&cache_cleaner, do_cache_clean); 1594} 1595 1596int cache_register_net(struct cache_detail *cd, struct net *net) 1597{ 1598 int ret; 1599 1600 sunrpc_init_cache_detail(cd); 1601 ret = create_cache_proc_entries(cd, net); 1602 if (ret) 1603 sunrpc_destroy_cache_detail(cd); 1604 return ret; 1605} 1606 1607int cache_register(struct cache_detail *cd) 1608{ 1609 return cache_register_net(cd, &init_net); 1610} 1611EXPORT_SYMBOL_GPL(cache_register); 1612 1613void cache_unregister_net(struct cache_detail *cd, struct net *net) 1614{ 1615 remove_cache_proc_entries(cd, net); 1616 sunrpc_destroy_cache_detail(cd); 1617} 1618 1619void cache_unregister(struct cache_detail *cd) 1620{ 1621 cache_unregister_net(cd, &init_net); 1622} 1623EXPORT_SYMBOL_GPL(cache_unregister); 1624 1625static ssize_t cache_read_pipefs(struct file *filp, char __user *buf, 1626 size_t count, loff_t *ppos) 1627{ 1628 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; 1629 1630 return cache_read(filp, buf, count, ppos, cd); 1631} 1632 1633static ssize_t cache_write_pipefs(struct file *filp, const char __user *buf, 1634 size_t count, loff_t *ppos) 1635{ 1636 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; 1637 1638 return cache_write(filp, buf, count, ppos, cd); 1639} 1640 1641static unsigned int cache_poll_pipefs(struct file *filp, poll_table *wait) 1642{ 1643 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; 1644 1645 return cache_poll(filp, wait, cd); 1646} 1647 1648static long cache_ioctl_pipefs(struct file *filp, 1649 unsigned int cmd, unsigned long arg) 1650{ 1651 struct inode *inode = filp->f_dentry->d_inode; 1652 struct cache_detail *cd = RPC_I(inode)->private; 1653 long ret; 1654 1655 lock_kernel(); 1656 ret = cache_ioctl(inode, filp, cmd, arg, cd); 1657 unlock_kernel(); 1658 1659 return ret; 1660} 1661 1662static int cache_open_pipefs(struct inode *inode, struct file *filp) 1663{ 1664 struct cache_detail *cd = RPC_I(inode)->private; 1665 1666 return cache_open(inode, filp, cd); 1667} 1668 1669static int cache_release_pipefs(struct inode *inode, struct file *filp) 1670{ 1671 struct cache_detail *cd = RPC_I(inode)->private; 1672 1673 return cache_release(inode, filp, cd); 1674} 1675 1676const struct file_operations cache_file_operations_pipefs = { 1677 .owner = THIS_MODULE, 1678 .llseek = no_llseek, 1679 .read = cache_read_pipefs, 1680 .write = cache_write_pipefs, 1681 .poll = cache_poll_pipefs, 1682 .unlocked_ioctl = cache_ioctl_pipefs, /* for FIONREAD */ 1683 .open = cache_open_pipefs, 1684 .release = cache_release_pipefs, 1685}; 1686 1687static int content_open_pipefs(struct inode *inode, struct file *filp) 1688{ 1689 struct cache_detail *cd = RPC_I(inode)->private; 1690 1691 return content_open(inode, filp, cd); 1692} 1693 1694static int content_release_pipefs(struct inode *inode, struct file *filp) 1695{ 1696 struct cache_detail *cd = RPC_I(inode)->private; 1697 1698 return content_release(inode, filp, cd); 1699} 1700 1701const struct file_operations content_file_operations_pipefs = { 1702 .open = content_open_pipefs, 1703 .read = seq_read, 1704 .llseek = seq_lseek, 1705 .release = content_release_pipefs, 1706}; 1707 1708static int open_flush_pipefs(struct inode *inode, struct file *filp) 1709{ 1710 struct cache_detail *cd = RPC_I(inode)->private; 1711 1712 return open_flush(inode, filp, cd); 1713} 1714 1715static int release_flush_pipefs(struct inode *inode, struct file *filp) 1716{ 1717 struct cache_detail *cd = RPC_I(inode)->private; 1718 1719 return release_flush(inode, filp, cd); 1720} 1721 1722static ssize_t read_flush_pipefs(struct file *filp, char __user *buf, 1723 size_t count, loff_t *ppos) 1724{ 1725 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; 1726 1727 return read_flush(filp, buf, count, ppos, cd); 1728} 1729 1730static ssize_t write_flush_pipefs(struct file *filp, 1731 const char __user *buf, 1732 size_t count, loff_t *ppos) 1733{ 1734 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private; 1735 1736 return write_flush(filp, buf, count, ppos, cd); 1737} 1738 1739const struct file_operations cache_flush_operations_pipefs = { 1740 .open = open_flush_pipefs, 1741 .read = read_flush_pipefs, 1742 .write = write_flush_pipefs, 1743 .release = release_flush_pipefs, 1744}; 1745 1746int sunrpc_cache_register_pipefs(struct dentry *parent, 1747 const char *name, mode_t umode, 1748 struct cache_detail *cd) 1749{ 1750 struct qstr q; 1751 struct dentry *dir; 1752 int ret = 0; 1753 1754 sunrpc_init_cache_detail(cd); 1755 q.name = name; 1756 q.len = strlen(name); 1757 q.hash = full_name_hash(q.name, q.len); 1758 dir = rpc_create_cache_dir(parent, &q, umode, cd); 1759 if (!IS_ERR(dir)) 1760 cd->u.pipefs.dir = dir; 1761 else { 1762 sunrpc_destroy_cache_detail(cd); 1763 ret = PTR_ERR(dir); 1764 } 1765 return ret; 1766} 1767EXPORT_SYMBOL_GPL(sunrpc_cache_register_pipefs); 1768 1769void sunrpc_cache_unregister_pipefs(struct cache_detail *cd) 1770{ 1771 rpc_remove_cache_dir(cd->u.pipefs.dir); 1772 cd->u.pipefs.dir = NULL; 1773 sunrpc_destroy_cache_detail(cd); 1774} 1775EXPORT_SYMBOL_GPL(sunrpc_cache_unregister_pipefs); 1776 1777