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