1 // SPDX-License-Identifier: GPL-2.0-only
5 * Generic code for various authentication-related caches
6 * used by sunrpc clients and servers.
8 * Copyright (C) 2002 Neil Brown <neilb@cse.unsw.edu.au>
11 #include <linux/types.h>
13 #include <linux/file.h>
14 #include <linux/slab.h>
15 #include <linux/signal.h>
16 #include <linux/sched.h>
17 #include <linux/kmod.h>
18 #include <linux/list.h>
19 #include <linux/module.h>
20 #include <linux/ctype.h>
21 #include <linux/string_helpers.h>
22 #include <linux/uaccess.h>
23 #include <linux/poll.h>
24 #include <linux/seq_file.h>
25 #include <linux/proc_fs.h>
26 #include <linux/net.h>
27 #include <linux/workqueue.h>
28 #include <linux/mutex.h>
29 #include <linux/pagemap.h>
30 #include <asm/ioctls.h>
31 #include <linux/sunrpc/types.h>
32 #include <linux/sunrpc/cache.h>
33 #include <linux/sunrpc/stats.h>
34 #include <linux/sunrpc/rpc_pipe_fs.h>
35 #include <trace/events/sunrpc.h>
38 #define RPCDBG_FACILITY RPCDBG_CACHE
40 static bool cache_defer_req(struct cache_req
*req
, struct cache_head
*item
);
41 static void cache_revisit_request(struct cache_head
*item
);
43 static void cache_init(struct cache_head
*h
, struct cache_detail
*detail
)
45 time64_t now
= seconds_since_boot();
46 INIT_HLIST_NODE(&h
->cache_list
);
49 h
->expiry_time
= now
+ CACHE_NEW_EXPIRY
;
50 if (now
<= detail
->flush_time
)
51 /* ensure it isn't already expired */
52 now
= detail
->flush_time
+ 1;
53 h
->last_refresh
= now
;
56 static void cache_fresh_unlocked(struct cache_head
*head
,
57 struct cache_detail
*detail
);
59 static struct cache_head
*sunrpc_cache_find_rcu(struct cache_detail
*detail
,
60 struct cache_head
*key
,
63 struct hlist_head
*head
= &detail
->hash_table
[hash
];
64 struct cache_head
*tmp
;
67 hlist_for_each_entry_rcu(tmp
, head
, cache_list
) {
68 if (!detail
->match(tmp
, key
))
70 if (test_bit(CACHE_VALID
, &tmp
->flags
) &&
71 cache_is_expired(detail
, tmp
))
73 tmp
= cache_get_rcu(tmp
);
81 static void sunrpc_begin_cache_remove_entry(struct cache_head
*ch
,
82 struct cache_detail
*cd
)
84 /* Must be called under cd->hash_lock */
85 hlist_del_init_rcu(&ch
->cache_list
);
86 set_bit(CACHE_CLEANED
, &ch
->flags
);
90 static void sunrpc_end_cache_remove_entry(struct cache_head
*ch
,
91 struct cache_detail
*cd
)
93 cache_fresh_unlocked(ch
, cd
);
97 static struct cache_head
*sunrpc_cache_add_entry(struct cache_detail
*detail
,
98 struct cache_head
*key
,
101 struct cache_head
*new, *tmp
, *freeme
= NULL
;
102 struct hlist_head
*head
= &detail
->hash_table
[hash
];
104 new = detail
->alloc();
107 /* must fully initialise 'new', else
108 * we might get lose if we need to
111 cache_init(new, detail
);
112 detail
->init(new, key
);
114 spin_lock(&detail
->hash_lock
);
116 /* check if entry appeared while we slept */
117 hlist_for_each_entry_rcu(tmp
, head
, cache_list
,
118 lockdep_is_held(&detail
->hash_lock
)) {
119 if (!detail
->match(tmp
, key
))
121 if (test_bit(CACHE_VALID
, &tmp
->flags
) &&
122 cache_is_expired(detail
, tmp
)) {
123 sunrpc_begin_cache_remove_entry(tmp
, detail
);
124 trace_cache_entry_expired(detail
, tmp
);
129 spin_unlock(&detail
->hash_lock
);
130 cache_put(new, detail
);
134 hlist_add_head_rcu(&new->cache_list
, head
);
137 spin_unlock(&detail
->hash_lock
);
140 sunrpc_end_cache_remove_entry(freeme
, detail
);
144 struct cache_head
*sunrpc_cache_lookup_rcu(struct cache_detail
*detail
,
145 struct cache_head
*key
, int hash
)
147 struct cache_head
*ret
;
149 ret
= sunrpc_cache_find_rcu(detail
, key
, hash
);
152 /* Didn't find anything, insert an empty entry */
153 return sunrpc_cache_add_entry(detail
, key
, hash
);
155 EXPORT_SYMBOL_GPL(sunrpc_cache_lookup_rcu
);
157 static void cache_dequeue(struct cache_detail
*detail
, struct cache_head
*ch
);
159 static void cache_fresh_locked(struct cache_head
*head
, time64_t expiry
,
160 struct cache_detail
*detail
)
162 time64_t now
= seconds_since_boot();
163 if (now
<= detail
->flush_time
)
164 /* ensure it isn't immediately treated as expired */
165 now
= detail
->flush_time
+ 1;
166 head
->expiry_time
= expiry
;
167 head
->last_refresh
= now
;
168 smp_wmb(); /* paired with smp_rmb() in cache_is_valid() */
169 set_bit(CACHE_VALID
, &head
->flags
);
172 static void cache_fresh_unlocked(struct cache_head
*head
,
173 struct cache_detail
*detail
)
175 if (test_and_clear_bit(CACHE_PENDING
, &head
->flags
)) {
176 cache_revisit_request(head
);
177 cache_dequeue(detail
, head
);
181 static void cache_make_negative(struct cache_detail
*detail
,
182 struct cache_head
*h
)
184 set_bit(CACHE_NEGATIVE
, &h
->flags
);
185 trace_cache_entry_make_negative(detail
, h
);
188 static void cache_entry_update(struct cache_detail
*detail
,
189 struct cache_head
*h
,
190 struct cache_head
*new)
192 if (!test_bit(CACHE_NEGATIVE
, &new->flags
)) {
193 detail
->update(h
, new);
194 trace_cache_entry_update(detail
, h
);
196 cache_make_negative(detail
, h
);
200 struct cache_head
*sunrpc_cache_update(struct cache_detail
*detail
,
201 struct cache_head
*new, struct cache_head
*old
, int hash
)
203 /* The 'old' entry is to be replaced by 'new'.
204 * If 'old' is not VALID, we update it directly,
205 * otherwise we need to replace it
207 struct cache_head
*tmp
;
209 if (!test_bit(CACHE_VALID
, &old
->flags
)) {
210 spin_lock(&detail
->hash_lock
);
211 if (!test_bit(CACHE_VALID
, &old
->flags
)) {
212 cache_entry_update(detail
, old
, new);
213 cache_fresh_locked(old
, new->expiry_time
, detail
);
214 spin_unlock(&detail
->hash_lock
);
215 cache_fresh_unlocked(old
, detail
);
218 spin_unlock(&detail
->hash_lock
);
220 /* We need to insert a new entry */
221 tmp
= detail
->alloc();
223 cache_put(old
, detail
);
226 cache_init(tmp
, detail
);
227 detail
->init(tmp
, old
);
229 spin_lock(&detail
->hash_lock
);
230 cache_entry_update(detail
, tmp
, new);
231 hlist_add_head(&tmp
->cache_list
, &detail
->hash_table
[hash
]);
234 cache_fresh_locked(tmp
, new->expiry_time
, detail
);
235 cache_fresh_locked(old
, 0, detail
);
236 spin_unlock(&detail
->hash_lock
);
237 cache_fresh_unlocked(tmp
, detail
);
238 cache_fresh_unlocked(old
, detail
);
239 cache_put(old
, detail
);
242 EXPORT_SYMBOL_GPL(sunrpc_cache_update
);
244 static inline int cache_is_valid(struct cache_head
*h
)
246 if (!test_bit(CACHE_VALID
, &h
->flags
))
250 if (test_bit(CACHE_NEGATIVE
, &h
->flags
))
254 * In combination with write barrier in
255 * sunrpc_cache_update, ensures that anyone
256 * using the cache entry after this sees the
265 static int try_to_negate_entry(struct cache_detail
*detail
, struct cache_head
*h
)
269 spin_lock(&detail
->hash_lock
);
270 rv
= cache_is_valid(h
);
272 cache_make_negative(detail
, h
);
273 cache_fresh_locked(h
, seconds_since_boot()+CACHE_NEW_EXPIRY
,
277 spin_unlock(&detail
->hash_lock
);
278 cache_fresh_unlocked(h
, detail
);
283 * This is the generic cache management routine for all
284 * the authentication caches.
285 * It checks the currency of a cache item and will (later)
286 * initiate an upcall to fill it if needed.
289 * Returns 0 if the cache_head can be used, or cache_puts it and returns
290 * -EAGAIN if upcall is pending and request has been queued
291 * -ETIMEDOUT if upcall failed or request could not be queue or
292 * upcall completed but item is still invalid (implying that
293 * the cache item has been replaced with a newer one).
294 * -ENOENT if cache entry was negative
296 int cache_check(struct cache_detail
*detail
,
297 struct cache_head
*h
, struct cache_req
*rqstp
)
300 time64_t refresh_age
, age
;
302 /* First decide return status as best we can */
303 rv
= cache_is_valid(h
);
305 /* now see if we want to start an upcall */
306 refresh_age
= (h
->expiry_time
- h
->last_refresh
);
307 age
= seconds_since_boot() - h
->last_refresh
;
312 } else if (rv
== -EAGAIN
||
313 (h
->expiry_time
!= 0 && age
> refresh_age
/2)) {
314 dprintk("RPC: Want update, refage=%lld, age=%lld\n",
316 switch (detail
->cache_upcall(detail
, h
)) {
318 rv
= try_to_negate_entry(detail
, h
);
321 cache_fresh_unlocked(h
, detail
);
327 if (!cache_defer_req(rqstp
, h
)) {
329 * Request was not deferred; handle it as best
332 rv
= cache_is_valid(h
);
338 cache_put(h
, detail
);
341 EXPORT_SYMBOL_GPL(cache_check
);
344 * caches need to be periodically cleaned.
345 * For this we maintain a list of cache_detail and
346 * a current pointer into that list and into the table
349 * Each time cache_clean is called it finds the next non-empty entry
350 * in the current table and walks the list in that entry
351 * looking for entries that can be removed.
353 * An entry gets removed if:
354 * - The expiry is before current time
355 * - The last_refresh time is before the flush_time for that cache
357 * later we might drop old entries with non-NEVER expiry if that table
358 * is getting 'full' for some definition of 'full'
360 * The question of "how often to scan a table" is an interesting one
361 * and is answered in part by the use of the "nextcheck" field in the
363 * When a scan of a table begins, the nextcheck field is set to a time
364 * that is well into the future.
365 * While scanning, if an expiry time is found that is earlier than the
366 * current nextcheck time, nextcheck is set to that expiry time.
367 * If the flush_time is ever set to a time earlier than the nextcheck
368 * time, the nextcheck time is then set to that flush_time.
370 * A table is then only scanned if the current time is at least
371 * the nextcheck time.
375 static LIST_HEAD(cache_list
);
376 static DEFINE_SPINLOCK(cache_list_lock
);
377 static struct cache_detail
*current_detail
;
378 static int current_index
;
380 static void do_cache_clean(struct work_struct
*work
);
381 static struct delayed_work cache_cleaner
;
383 void sunrpc_init_cache_detail(struct cache_detail
*cd
)
385 spin_lock_init(&cd
->hash_lock
);
386 INIT_LIST_HEAD(&cd
->queue
);
387 spin_lock(&cache_list_lock
);
390 atomic_set(&cd
->writers
, 0);
393 list_add(&cd
->others
, &cache_list
);
394 spin_unlock(&cache_list_lock
);
396 /* start the cleaning process */
397 queue_delayed_work(system_power_efficient_wq
, &cache_cleaner
, 0);
399 EXPORT_SYMBOL_GPL(sunrpc_init_cache_detail
);
401 void sunrpc_destroy_cache_detail(struct cache_detail
*cd
)
404 spin_lock(&cache_list_lock
);
405 spin_lock(&cd
->hash_lock
);
406 if (current_detail
== cd
)
407 current_detail
= NULL
;
408 list_del_init(&cd
->others
);
409 spin_unlock(&cd
->hash_lock
);
410 spin_unlock(&cache_list_lock
);
411 if (list_empty(&cache_list
)) {
412 /* module must be being unloaded so its safe to kill the worker */
413 cancel_delayed_work_sync(&cache_cleaner
);
416 EXPORT_SYMBOL_GPL(sunrpc_destroy_cache_detail
);
418 /* clean cache tries to find something to clean
420 * It returns 1 if it cleaned something,
421 * 0 if it didn't find anything this time
422 * -1 if it fell off the end of the list.
424 static int cache_clean(void)
427 struct list_head
*next
;
429 spin_lock(&cache_list_lock
);
431 /* find a suitable table if we don't already have one */
432 while (current_detail
== NULL
||
433 current_index
>= current_detail
->hash_size
) {
435 next
= current_detail
->others
.next
;
437 next
= cache_list
.next
;
438 if (next
== &cache_list
) {
439 current_detail
= NULL
;
440 spin_unlock(&cache_list_lock
);
443 current_detail
= list_entry(next
, struct cache_detail
, others
);
444 if (current_detail
->nextcheck
> seconds_since_boot())
445 current_index
= current_detail
->hash_size
;
448 current_detail
->nextcheck
= seconds_since_boot()+30*60;
452 /* find a non-empty bucket in the table */
453 while (current_detail
&&
454 current_index
< current_detail
->hash_size
&&
455 hlist_empty(¤t_detail
->hash_table
[current_index
]))
458 /* find a cleanable entry in the bucket and clean it, or set to next bucket */
460 if (current_detail
&& current_index
< current_detail
->hash_size
) {
461 struct cache_head
*ch
= NULL
;
462 struct cache_detail
*d
;
463 struct hlist_head
*head
;
464 struct hlist_node
*tmp
;
466 spin_lock(¤t_detail
->hash_lock
);
468 /* Ok, now to clean this strand */
470 head
= ¤t_detail
->hash_table
[current_index
];
471 hlist_for_each_entry_safe(ch
, tmp
, head
, cache_list
) {
472 if (current_detail
->nextcheck
> ch
->expiry_time
)
473 current_detail
->nextcheck
= ch
->expiry_time
+1;
474 if (!cache_is_expired(current_detail
, ch
))
477 sunrpc_begin_cache_remove_entry(ch
, current_detail
);
478 trace_cache_entry_expired(current_detail
, ch
);
483 spin_unlock(¤t_detail
->hash_lock
);
487 spin_unlock(&cache_list_lock
);
489 sunrpc_end_cache_remove_entry(ch
, d
);
491 spin_unlock(&cache_list_lock
);
497 * We want to regularly clean the cache, so we need to schedule some work ...
499 static void do_cache_clean(struct work_struct
*work
)
503 if (list_empty(&cache_list
))
506 if (cache_clean() == -1)
507 delay
= round_jiffies_relative(30*HZ
);
511 queue_delayed_work(system_power_efficient_wq
, &cache_cleaner
, delay
);
516 * Clean all caches promptly. This just calls cache_clean
517 * repeatedly until we are sure that every cache has had a chance to
520 void cache_flush(void)
522 while (cache_clean() != -1)
524 while (cache_clean() != -1)
527 EXPORT_SYMBOL_GPL(cache_flush
);
529 void cache_purge(struct cache_detail
*detail
)
531 struct cache_head
*ch
= NULL
;
532 struct hlist_head
*head
= NULL
;
535 spin_lock(&detail
->hash_lock
);
536 if (!detail
->entries
) {
537 spin_unlock(&detail
->hash_lock
);
541 dprintk("RPC: %d entries in %s cache\n", detail
->entries
, detail
->name
);
542 for (i
= 0; i
< detail
->hash_size
; i
++) {
543 head
= &detail
->hash_table
[i
];
544 while (!hlist_empty(head
)) {
545 ch
= hlist_entry(head
->first
, struct cache_head
,
547 sunrpc_begin_cache_remove_entry(ch
, detail
);
548 spin_unlock(&detail
->hash_lock
);
549 sunrpc_end_cache_remove_entry(ch
, detail
);
550 spin_lock(&detail
->hash_lock
);
553 spin_unlock(&detail
->hash_lock
);
555 EXPORT_SYMBOL_GPL(cache_purge
);
559 * Deferral and Revisiting of Requests.
561 * If a cache lookup finds a pending entry, we
562 * need to defer the request and revisit it later.
563 * All deferred requests are stored in a hash table,
564 * indexed by "struct cache_head *".
565 * As it may be wasteful to store a whole request
566 * structure, we allow the request to provide a
567 * deferred form, which must contain a
568 * 'struct cache_deferred_req'
569 * This cache_deferred_req contains a method to allow
570 * it to be revisited when cache info is available
573 #define DFR_HASHSIZE (PAGE_SIZE/sizeof(struct list_head))
574 #define DFR_HASH(item) ((((long)item)>>4 ^ (((long)item)>>13)) % DFR_HASHSIZE)
576 #define DFR_MAX 300 /* ??? */
578 static DEFINE_SPINLOCK(cache_defer_lock
);
579 static LIST_HEAD(cache_defer_list
);
580 static struct hlist_head cache_defer_hash
[DFR_HASHSIZE
];
581 static int cache_defer_cnt
;
583 static void __unhash_deferred_req(struct cache_deferred_req
*dreq
)
585 hlist_del_init(&dreq
->hash
);
586 if (!list_empty(&dreq
->recent
)) {
587 list_del_init(&dreq
->recent
);
592 static void __hash_deferred_req(struct cache_deferred_req
*dreq
, struct cache_head
*item
)
594 int hash
= DFR_HASH(item
);
596 INIT_LIST_HEAD(&dreq
->recent
);
597 hlist_add_head(&dreq
->hash
, &cache_defer_hash
[hash
]);
600 static void setup_deferral(struct cache_deferred_req
*dreq
,
601 struct cache_head
*item
,
607 spin_lock(&cache_defer_lock
);
609 __hash_deferred_req(dreq
, item
);
613 list_add(&dreq
->recent
, &cache_defer_list
);
616 spin_unlock(&cache_defer_lock
);
620 struct thread_deferred_req
{
621 struct cache_deferred_req handle
;
622 struct completion completion
;
625 static void cache_restart_thread(struct cache_deferred_req
*dreq
, int too_many
)
627 struct thread_deferred_req
*dr
=
628 container_of(dreq
, struct thread_deferred_req
, handle
);
629 complete(&dr
->completion
);
632 static void cache_wait_req(struct cache_req
*req
, struct cache_head
*item
)
634 struct thread_deferred_req sleeper
;
635 struct cache_deferred_req
*dreq
= &sleeper
.handle
;
637 sleeper
.completion
= COMPLETION_INITIALIZER_ONSTACK(sleeper
.completion
);
638 dreq
->revisit
= cache_restart_thread
;
640 setup_deferral(dreq
, item
, 0);
642 if (!test_bit(CACHE_PENDING
, &item
->flags
) ||
643 wait_for_completion_interruptible_timeout(
644 &sleeper
.completion
, req
->thread_wait
) <= 0) {
645 /* The completion wasn't completed, so we need
648 spin_lock(&cache_defer_lock
);
649 if (!hlist_unhashed(&sleeper
.handle
.hash
)) {
650 __unhash_deferred_req(&sleeper
.handle
);
651 spin_unlock(&cache_defer_lock
);
653 /* cache_revisit_request already removed
654 * this from the hash table, but hasn't
655 * called ->revisit yet. It will very soon
656 * and we need to wait for it.
658 spin_unlock(&cache_defer_lock
);
659 wait_for_completion(&sleeper
.completion
);
664 static void cache_limit_defers(void)
666 /* Make sure we haven't exceed the limit of allowed deferred
669 struct cache_deferred_req
*discard
= NULL
;
671 if (cache_defer_cnt
<= DFR_MAX
)
674 spin_lock(&cache_defer_lock
);
676 /* Consider removing either the first or the last */
677 if (cache_defer_cnt
> DFR_MAX
) {
678 if (prandom_u32() & 1)
679 discard
= list_entry(cache_defer_list
.next
,
680 struct cache_deferred_req
, recent
);
682 discard
= list_entry(cache_defer_list
.prev
,
683 struct cache_deferred_req
, recent
);
684 __unhash_deferred_req(discard
);
686 spin_unlock(&cache_defer_lock
);
688 discard
->revisit(discard
, 1);
691 /* Return true if and only if a deferred request is queued. */
692 static bool cache_defer_req(struct cache_req
*req
, struct cache_head
*item
)
694 struct cache_deferred_req
*dreq
;
696 if (req
->thread_wait
) {
697 cache_wait_req(req
, item
);
698 if (!test_bit(CACHE_PENDING
, &item
->flags
))
701 dreq
= req
->defer(req
);
704 setup_deferral(dreq
, item
, 1);
705 if (!test_bit(CACHE_PENDING
, &item
->flags
))
706 /* Bit could have been cleared before we managed to
707 * set up the deferral, so need to revisit just in case
709 cache_revisit_request(item
);
711 cache_limit_defers();
715 static void cache_revisit_request(struct cache_head
*item
)
717 struct cache_deferred_req
*dreq
;
718 struct list_head pending
;
719 struct hlist_node
*tmp
;
720 int hash
= DFR_HASH(item
);
722 INIT_LIST_HEAD(&pending
);
723 spin_lock(&cache_defer_lock
);
725 hlist_for_each_entry_safe(dreq
, tmp
, &cache_defer_hash
[hash
], hash
)
726 if (dreq
->item
== item
) {
727 __unhash_deferred_req(dreq
);
728 list_add(&dreq
->recent
, &pending
);
731 spin_unlock(&cache_defer_lock
);
733 while (!list_empty(&pending
)) {
734 dreq
= list_entry(pending
.next
, struct cache_deferred_req
, recent
);
735 list_del_init(&dreq
->recent
);
736 dreq
->revisit(dreq
, 0);
740 void cache_clean_deferred(void *owner
)
742 struct cache_deferred_req
*dreq
, *tmp
;
743 struct list_head pending
;
746 INIT_LIST_HEAD(&pending
);
747 spin_lock(&cache_defer_lock
);
749 list_for_each_entry_safe(dreq
, tmp
, &cache_defer_list
, recent
) {
750 if (dreq
->owner
== owner
) {
751 __unhash_deferred_req(dreq
);
752 list_add(&dreq
->recent
, &pending
);
755 spin_unlock(&cache_defer_lock
);
757 while (!list_empty(&pending
)) {
758 dreq
= list_entry(pending
.next
, struct cache_deferred_req
, recent
);
759 list_del_init(&dreq
->recent
);
760 dreq
->revisit(dreq
, 1);
765 * communicate with user-space
767 * We have a magic /proc file - /proc/net/rpc/<cachename>/channel.
768 * On read, you get a full request, or block.
769 * On write, an update request is processed.
770 * Poll works if anything to read, and always allows write.
772 * Implemented by linked list of requests. Each open file has
773 * a ->private that also exists in this list. New requests are added
774 * to the end and may wakeup and preceding readers.
775 * New readers are added to the head. If, on read, an item is found with
776 * CACHE_UPCALLING clear, we free it from the list.
780 static DEFINE_SPINLOCK(queue_lock
);
783 struct list_head list
;
784 int reader
; /* if 0, then request */
786 struct cache_request
{
787 struct cache_queue q
;
788 struct cache_head
*item
;
793 struct cache_reader
{
794 struct cache_queue q
;
795 int offset
; /* if non-0, we have a refcnt on next request */
798 static int cache_request(struct cache_detail
*detail
,
799 struct cache_request
*crq
)
804 detail
->cache_request(detail
, crq
->item
, &bp
, &len
);
807 return PAGE_SIZE
- len
;
810 static ssize_t
cache_read(struct file
*filp
, char __user
*buf
, size_t count
,
811 loff_t
*ppos
, struct cache_detail
*cd
)
813 struct cache_reader
*rp
= filp
->private_data
;
814 struct cache_request
*rq
;
815 struct inode
*inode
= file_inode(filp
);
821 inode_lock(inode
); /* protect against multiple concurrent
822 * readers on this file */
824 spin_lock(&queue_lock
);
825 /* need to find next request */
826 while (rp
->q
.list
.next
!= &cd
->queue
&&
827 list_entry(rp
->q
.list
.next
, struct cache_queue
, list
)
829 struct list_head
*next
= rp
->q
.list
.next
;
830 list_move(&rp
->q
.list
, next
);
832 if (rp
->q
.list
.next
== &cd
->queue
) {
833 spin_unlock(&queue_lock
);
835 WARN_ON_ONCE(rp
->offset
);
838 rq
= container_of(rp
->q
.list
.next
, struct cache_request
, q
.list
);
839 WARN_ON_ONCE(rq
->q
.reader
);
842 spin_unlock(&queue_lock
);
845 err
= cache_request(cd
, rq
);
851 if (rp
->offset
== 0 && !test_bit(CACHE_PENDING
, &rq
->item
->flags
)) {
853 spin_lock(&queue_lock
);
854 list_move(&rp
->q
.list
, &rq
->q
.list
);
855 spin_unlock(&queue_lock
);
857 if (rp
->offset
+ count
> rq
->len
)
858 count
= rq
->len
- rp
->offset
;
860 if (copy_to_user(buf
, rq
->buf
+ rp
->offset
, count
))
863 if (rp
->offset
>= rq
->len
) {
865 spin_lock(&queue_lock
);
866 list_move(&rp
->q
.list
, &rq
->q
.list
);
867 spin_unlock(&queue_lock
);
872 if (rp
->offset
== 0) {
873 /* need to release rq */
874 spin_lock(&queue_lock
);
876 if (rq
->readers
== 0 &&
877 !test_bit(CACHE_PENDING
, &rq
->item
->flags
)) {
878 list_del(&rq
->q
.list
);
879 spin_unlock(&queue_lock
);
880 cache_put(rq
->item
, cd
);
884 spin_unlock(&queue_lock
);
889 return err
? err
: count
;
892 static ssize_t
cache_do_downcall(char *kaddr
, const char __user
*buf
,
893 size_t count
, struct cache_detail
*cd
)
899 if (copy_from_user(kaddr
, buf
, count
))
902 ret
= cd
->cache_parse(cd
, kaddr
, count
);
908 static ssize_t
cache_downcall(struct address_space
*mapping
,
909 const char __user
*buf
,
910 size_t count
, struct cache_detail
*cd
)
913 ssize_t ret
= -ENOMEM
;
915 if (count
>= 32768) { /* 32k is max userland buffer, lets check anyway */
920 write_buf
= kvmalloc(count
+ 1, GFP_KERNEL
);
924 ret
= cache_do_downcall(write_buf
, buf
, count
, cd
);
930 static ssize_t
cache_write(struct file
*filp
, const char __user
*buf
,
931 size_t count
, loff_t
*ppos
,
932 struct cache_detail
*cd
)
934 struct address_space
*mapping
= filp
->f_mapping
;
935 struct inode
*inode
= file_inode(filp
);
936 ssize_t ret
= -EINVAL
;
938 if (!cd
->cache_parse
)
942 ret
= cache_downcall(mapping
, buf
, count
, cd
);
948 static DECLARE_WAIT_QUEUE_HEAD(queue_wait
);
950 static __poll_t
cache_poll(struct file
*filp
, poll_table
*wait
,
951 struct cache_detail
*cd
)
954 struct cache_reader
*rp
= filp
->private_data
;
955 struct cache_queue
*cq
;
957 poll_wait(filp
, &queue_wait
, wait
);
959 /* alway allow write */
960 mask
= EPOLLOUT
| EPOLLWRNORM
;
965 spin_lock(&queue_lock
);
967 for (cq
= &rp
->q
; &cq
->list
!= &cd
->queue
;
968 cq
= list_entry(cq
->list
.next
, struct cache_queue
, list
))
970 mask
|= EPOLLIN
| EPOLLRDNORM
;
973 spin_unlock(&queue_lock
);
977 static int cache_ioctl(struct inode
*ino
, struct file
*filp
,
978 unsigned int cmd
, unsigned long arg
,
979 struct cache_detail
*cd
)
982 struct cache_reader
*rp
= filp
->private_data
;
983 struct cache_queue
*cq
;
985 if (cmd
!= FIONREAD
|| !rp
)
988 spin_lock(&queue_lock
);
990 /* only find the length remaining in current request,
991 * or the length of the next request
993 for (cq
= &rp
->q
; &cq
->list
!= &cd
->queue
;
994 cq
= list_entry(cq
->list
.next
, struct cache_queue
, list
))
996 struct cache_request
*cr
=
997 container_of(cq
, struct cache_request
, q
);
998 len
= cr
->len
- rp
->offset
;
1001 spin_unlock(&queue_lock
);
1003 return put_user(len
, (int __user
*)arg
);
1006 static int cache_open(struct inode
*inode
, struct file
*filp
,
1007 struct cache_detail
*cd
)
1009 struct cache_reader
*rp
= NULL
;
1011 if (!cd
|| !try_module_get(cd
->owner
))
1013 nonseekable_open(inode
, filp
);
1014 if (filp
->f_mode
& FMODE_READ
) {
1015 rp
= kmalloc(sizeof(*rp
), GFP_KERNEL
);
1017 module_put(cd
->owner
);
1023 spin_lock(&queue_lock
);
1024 list_add(&rp
->q
.list
, &cd
->queue
);
1025 spin_unlock(&queue_lock
);
1027 if (filp
->f_mode
& FMODE_WRITE
)
1028 atomic_inc(&cd
->writers
);
1029 filp
->private_data
= rp
;
1033 static int cache_release(struct inode
*inode
, struct file
*filp
,
1034 struct cache_detail
*cd
)
1036 struct cache_reader
*rp
= filp
->private_data
;
1039 spin_lock(&queue_lock
);
1041 struct cache_queue
*cq
;
1042 for (cq
= &rp
->q
; &cq
->list
!= &cd
->queue
;
1043 cq
= list_entry(cq
->list
.next
, struct cache_queue
, list
))
1045 container_of(cq
, struct cache_request
, q
)
1051 list_del(&rp
->q
.list
);
1052 spin_unlock(&queue_lock
);
1054 filp
->private_data
= NULL
;
1058 if (filp
->f_mode
& FMODE_WRITE
) {
1059 atomic_dec(&cd
->writers
);
1060 cd
->last_close
= seconds_since_boot();
1062 module_put(cd
->owner
);
1068 static void cache_dequeue(struct cache_detail
*detail
, struct cache_head
*ch
)
1070 struct cache_queue
*cq
, *tmp
;
1071 struct cache_request
*cr
;
1072 struct list_head dequeued
;
1074 INIT_LIST_HEAD(&dequeued
);
1075 spin_lock(&queue_lock
);
1076 list_for_each_entry_safe(cq
, tmp
, &detail
->queue
, list
)
1078 cr
= container_of(cq
, struct cache_request
, q
);
1081 if (test_bit(CACHE_PENDING
, &ch
->flags
))
1082 /* Lost a race and it is pending again */
1084 if (cr
->readers
!= 0)
1086 list_move(&cr
->q
.list
, &dequeued
);
1088 spin_unlock(&queue_lock
);
1089 while (!list_empty(&dequeued
)) {
1090 cr
= list_entry(dequeued
.next
, struct cache_request
, q
.list
);
1091 list_del(&cr
->q
.list
);
1092 cache_put(cr
->item
, detail
);
1099 * Support routines for text-based upcalls.
1100 * Fields are separated by spaces.
1101 * Fields are either mangled to quote space tab newline slosh with slosh
1102 * or a hexified with a leading \x
1103 * Record is terminated with newline.
1107 void qword_add(char **bpp
, int *lp
, char *str
)
1113 if (len
< 0) return;
1115 ret
= string_escape_str(str
, bp
, len
, ESCAPE_OCTAL
, "\\ \n\t");
1128 EXPORT_SYMBOL_GPL(qword_add
);
1130 void qword_addhex(char **bpp
, int *lp
, char *buf
, int blen
)
1135 if (len
< 0) return;
1141 while (blen
&& len
>= 2) {
1142 bp
= hex_byte_pack(bp
, *buf
++);
1147 if (blen
|| len
<1) len
= -1;
1155 EXPORT_SYMBOL_GPL(qword_addhex
);
1157 static void warn_no_listener(struct cache_detail
*detail
)
1159 if (detail
->last_warn
!= detail
->last_close
) {
1160 detail
->last_warn
= detail
->last_close
;
1161 if (detail
->warn_no_listener
)
1162 detail
->warn_no_listener(detail
, detail
->last_close
!= 0);
1166 static bool cache_listeners_exist(struct cache_detail
*detail
)
1168 if (atomic_read(&detail
->writers
))
1170 if (detail
->last_close
== 0)
1171 /* This cache was never opened */
1173 if (detail
->last_close
< seconds_since_boot() - 30)
1175 * We allow for the possibility that someone might
1176 * restart a userspace daemon without restarting the
1177 * server; but after 30 seconds, we give up.
1184 * register an upcall request to user-space and queue it up for read() by the
1187 * Each request is at most one page long.
1189 static int cache_pipe_upcall(struct cache_detail
*detail
, struct cache_head
*h
)
1192 struct cache_request
*crq
;
1195 if (test_bit(CACHE_CLEANED
, &h
->flags
))
1196 /* Too late to make an upcall */
1199 buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
1203 crq
= kmalloc(sizeof (*crq
), GFP_KERNEL
);
1213 spin_lock(&queue_lock
);
1214 if (test_bit(CACHE_PENDING
, &h
->flags
)) {
1215 crq
->item
= cache_get(h
);
1216 list_add_tail(&crq
->q
.list
, &detail
->queue
);
1217 trace_cache_entry_upcall(detail
, h
);
1219 /* Lost a race, no longer PENDING, so don't enqueue */
1221 spin_unlock(&queue_lock
);
1222 wake_up(&queue_wait
);
1223 if (ret
== -EAGAIN
) {
1230 int sunrpc_cache_pipe_upcall(struct cache_detail
*detail
, struct cache_head
*h
)
1232 if (test_and_set_bit(CACHE_PENDING
, &h
->flags
))
1234 return cache_pipe_upcall(detail
, h
);
1236 EXPORT_SYMBOL_GPL(sunrpc_cache_pipe_upcall
);
1238 int sunrpc_cache_pipe_upcall_timeout(struct cache_detail
*detail
,
1239 struct cache_head
*h
)
1241 if (!cache_listeners_exist(detail
)) {
1242 warn_no_listener(detail
);
1243 trace_cache_entry_no_listener(detail
, h
);
1246 return sunrpc_cache_pipe_upcall(detail
, h
);
1248 EXPORT_SYMBOL_GPL(sunrpc_cache_pipe_upcall_timeout
);
1251 * parse a message from user-space and pass it
1252 * to an appropriate cache
1253 * Messages are, like requests, separated into fields by
1254 * spaces and dequotes as \xHEXSTRING or embedded \nnn octal
1257 * reply cachename expiry key ... content....
1259 * key and content are both parsed by cache
1262 int qword_get(char **bpp
, char *dest
, int bufsize
)
1264 /* return bytes copied, or -1 on error */
1268 while (*bp
== ' ') bp
++;
1270 if (bp
[0] == '\\' && bp
[1] == 'x') {
1273 while (len
< bufsize
- 1) {
1276 h
= hex_to_bin(bp
[0]);
1280 l
= hex_to_bin(bp
[1]);
1284 *dest
++ = (h
<< 4) | l
;
1289 /* text with \nnn octal quoting */
1290 while (*bp
!= ' ' && *bp
!= '\n' && *bp
&& len
< bufsize
-1) {
1292 isodigit(bp
[1]) && (bp
[1] <= '3') &&
1295 int byte
= (*++bp
-'0');
1297 byte
= (byte
<< 3) | (*bp
++ - '0');
1298 byte
= (byte
<< 3) | (*bp
++ - '0');
1308 if (*bp
!= ' ' && *bp
!= '\n' && *bp
!= '\0')
1310 while (*bp
== ' ') bp
++;
1315 EXPORT_SYMBOL_GPL(qword_get
);
1319 * support /proc/net/rpc/$CACHENAME/content
1321 * We call ->cache_show passing NULL for the item to
1322 * get a header, then pass each real item in the cache
1325 static void *__cache_seq_start(struct seq_file
*m
, loff_t
*pos
)
1328 unsigned int hash
, entry
;
1329 struct cache_head
*ch
;
1330 struct cache_detail
*cd
= m
->private;
1333 return SEQ_START_TOKEN
;
1335 entry
= n
& ((1LL<<32) - 1);
1337 hlist_for_each_entry_rcu(ch
, &cd
->hash_table
[hash
], cache_list
)
1340 n
&= ~((1LL<<32) - 1);
1344 } while(hash
< cd
->hash_size
&&
1345 hlist_empty(&cd
->hash_table
[hash
]));
1346 if (hash
>= cd
->hash_size
)
1349 return hlist_entry_safe(rcu_dereference_raw(
1350 hlist_first_rcu(&cd
->hash_table
[hash
])),
1351 struct cache_head
, cache_list
);
1354 static void *cache_seq_next(struct seq_file
*m
, void *p
, loff_t
*pos
)
1356 struct cache_head
*ch
= p
;
1357 int hash
= (*pos
>> 32);
1358 struct cache_detail
*cd
= m
->private;
1360 if (p
== SEQ_START_TOKEN
)
1362 else if (ch
->cache_list
.next
== NULL
) {
1367 return hlist_entry_safe(rcu_dereference_raw(
1368 hlist_next_rcu(&ch
->cache_list
)),
1369 struct cache_head
, cache_list
);
1371 *pos
&= ~((1LL<<32) - 1);
1372 while (hash
< cd
->hash_size
&&
1373 hlist_empty(&cd
->hash_table
[hash
])) {
1377 if (hash
>= cd
->hash_size
)
1380 return hlist_entry_safe(rcu_dereference_raw(
1381 hlist_first_rcu(&cd
->hash_table
[hash
])),
1382 struct cache_head
, cache_list
);
1385 void *cache_seq_start_rcu(struct seq_file
*m
, loff_t
*pos
)
1389 return __cache_seq_start(m
, pos
);
1391 EXPORT_SYMBOL_GPL(cache_seq_start_rcu
);
1393 void *cache_seq_next_rcu(struct seq_file
*file
, void *p
, loff_t
*pos
)
1395 return cache_seq_next(file
, p
, pos
);
1397 EXPORT_SYMBOL_GPL(cache_seq_next_rcu
);
1399 void cache_seq_stop_rcu(struct seq_file
*m
, void *p
)
1404 EXPORT_SYMBOL_GPL(cache_seq_stop_rcu
);
1406 static int c_show(struct seq_file
*m
, void *p
)
1408 struct cache_head
*cp
= p
;
1409 struct cache_detail
*cd
= m
->private;
1411 if (p
== SEQ_START_TOKEN
)
1412 return cd
->cache_show(m
, cd
, NULL
);
1415 seq_printf(m
, "# expiry=%lld refcnt=%d flags=%lx\n",
1416 convert_to_wallclock(cp
->expiry_time
),
1417 kref_read(&cp
->ref
), cp
->flags
);
1419 if (cache_check(cd
, cp
, NULL
))
1420 /* cache_check does a cache_put on failure */
1423 if (cache_is_expired(cd
, cp
))
1428 return cd
->cache_show(m
, cd
, cp
);
1431 static const struct seq_operations cache_content_op
= {
1432 .start
= cache_seq_start_rcu
,
1433 .next
= cache_seq_next_rcu
,
1434 .stop
= cache_seq_stop_rcu
,
1438 static int content_open(struct inode
*inode
, struct file
*file
,
1439 struct cache_detail
*cd
)
1441 struct seq_file
*seq
;
1444 if (!cd
|| !try_module_get(cd
->owner
))
1447 err
= seq_open(file
, &cache_content_op
);
1449 module_put(cd
->owner
);
1453 seq
= file
->private_data
;
1458 static int content_release(struct inode
*inode
, struct file
*file
,
1459 struct cache_detail
*cd
)
1461 int ret
= seq_release(inode
, file
);
1462 module_put(cd
->owner
);
1466 static int open_flush(struct inode
*inode
, struct file
*file
,
1467 struct cache_detail
*cd
)
1469 if (!cd
|| !try_module_get(cd
->owner
))
1471 return nonseekable_open(inode
, file
);
1474 static int release_flush(struct inode
*inode
, struct file
*file
,
1475 struct cache_detail
*cd
)
1477 module_put(cd
->owner
);
1481 static ssize_t
read_flush(struct file
*file
, char __user
*buf
,
1482 size_t count
, loff_t
*ppos
,
1483 struct cache_detail
*cd
)
1488 len
= snprintf(tbuf
, sizeof(tbuf
), "%llu\n",
1489 convert_to_wallclock(cd
->flush_time
));
1490 return simple_read_from_buffer(buf
, count
, ppos
, tbuf
, len
);
1493 static ssize_t
write_flush(struct file
*file
, const char __user
*buf
,
1494 size_t count
, loff_t
*ppos
,
1495 struct cache_detail
*cd
)
1501 if (*ppos
|| count
> sizeof(tbuf
)-1)
1503 if (copy_from_user(tbuf
, buf
, count
))
1506 simple_strtoul(tbuf
, &ep
, 0);
1507 if (*ep
&& *ep
!= '\n')
1509 /* Note that while we check that 'buf' holds a valid number,
1510 * we always ignore the value and just flush everything.
1511 * Making use of the number leads to races.
1514 now
= seconds_since_boot();
1515 /* Always flush everything, so behave like cache_purge()
1516 * Do this by advancing flush_time to the current time,
1517 * or by one second if it has already reached the current time.
1518 * Newly added cache entries will always have ->last_refresh greater
1519 * that ->flush_time, so they don't get flushed prematurely.
1522 if (cd
->flush_time
>= now
)
1523 now
= cd
->flush_time
+ 1;
1525 cd
->flush_time
= now
;
1526 cd
->nextcheck
= now
;
1536 static ssize_t
cache_read_procfs(struct file
*filp
, char __user
*buf
,
1537 size_t count
, loff_t
*ppos
)
1539 struct cache_detail
*cd
= PDE_DATA(file_inode(filp
));
1541 return cache_read(filp
, buf
, count
, ppos
, cd
);
1544 static ssize_t
cache_write_procfs(struct file
*filp
, const char __user
*buf
,
1545 size_t count
, loff_t
*ppos
)
1547 struct cache_detail
*cd
= PDE_DATA(file_inode(filp
));
1549 return cache_write(filp
, buf
, count
, ppos
, cd
);
1552 static __poll_t
cache_poll_procfs(struct file
*filp
, poll_table
*wait
)
1554 struct cache_detail
*cd
= PDE_DATA(file_inode(filp
));
1556 return cache_poll(filp
, wait
, cd
);
1559 static long cache_ioctl_procfs(struct file
*filp
,
1560 unsigned int cmd
, unsigned long arg
)
1562 struct inode
*inode
= file_inode(filp
);
1563 struct cache_detail
*cd
= PDE_DATA(inode
);
1565 return cache_ioctl(inode
, filp
, cmd
, arg
, cd
);
1568 static int cache_open_procfs(struct inode
*inode
, struct file
*filp
)
1570 struct cache_detail
*cd
= PDE_DATA(inode
);
1572 return cache_open(inode
, filp
, cd
);
1575 static int cache_release_procfs(struct inode
*inode
, struct file
*filp
)
1577 struct cache_detail
*cd
= PDE_DATA(inode
);
1579 return cache_release(inode
, filp
, cd
);
1582 static const struct proc_ops cache_channel_proc_ops
= {
1583 .proc_lseek
= no_llseek
,
1584 .proc_read
= cache_read_procfs
,
1585 .proc_write
= cache_write_procfs
,
1586 .proc_poll
= cache_poll_procfs
,
1587 .proc_ioctl
= cache_ioctl_procfs
, /* for FIONREAD */
1588 .proc_open
= cache_open_procfs
,
1589 .proc_release
= cache_release_procfs
,
1592 static int content_open_procfs(struct inode
*inode
, struct file
*filp
)
1594 struct cache_detail
*cd
= PDE_DATA(inode
);
1596 return content_open(inode
, filp
, cd
);
1599 static int content_release_procfs(struct inode
*inode
, struct file
*filp
)
1601 struct cache_detail
*cd
= PDE_DATA(inode
);
1603 return content_release(inode
, filp
, cd
);
1606 static const struct proc_ops content_proc_ops
= {
1607 .proc_open
= content_open_procfs
,
1608 .proc_read
= seq_read
,
1609 .proc_lseek
= seq_lseek
,
1610 .proc_release
= content_release_procfs
,
1613 static int open_flush_procfs(struct inode
*inode
, struct file
*filp
)
1615 struct cache_detail
*cd
= PDE_DATA(inode
);
1617 return open_flush(inode
, filp
, cd
);
1620 static int release_flush_procfs(struct inode
*inode
, struct file
*filp
)
1622 struct cache_detail
*cd
= PDE_DATA(inode
);
1624 return release_flush(inode
, filp
, cd
);
1627 static ssize_t
read_flush_procfs(struct file
*filp
, char __user
*buf
,
1628 size_t count
, loff_t
*ppos
)
1630 struct cache_detail
*cd
= PDE_DATA(file_inode(filp
));
1632 return read_flush(filp
, buf
, count
, ppos
, cd
);
1635 static ssize_t
write_flush_procfs(struct file
*filp
,
1636 const char __user
*buf
,
1637 size_t count
, loff_t
*ppos
)
1639 struct cache_detail
*cd
= PDE_DATA(file_inode(filp
));
1641 return write_flush(filp
, buf
, count
, ppos
, cd
);
1644 static const struct proc_ops cache_flush_proc_ops
= {
1645 .proc_open
= open_flush_procfs
,
1646 .proc_read
= read_flush_procfs
,
1647 .proc_write
= write_flush_procfs
,
1648 .proc_release
= release_flush_procfs
,
1649 .proc_lseek
= no_llseek
,
1652 static void remove_cache_proc_entries(struct cache_detail
*cd
)
1655 proc_remove(cd
->procfs
);
1660 #ifdef CONFIG_PROC_FS
1661 static int create_cache_proc_entries(struct cache_detail
*cd
, struct net
*net
)
1663 struct proc_dir_entry
*p
;
1664 struct sunrpc_net
*sn
;
1666 sn
= net_generic(net
, sunrpc_net_id
);
1667 cd
->procfs
= proc_mkdir(cd
->name
, sn
->proc_net_rpc
);
1668 if (cd
->procfs
== NULL
)
1671 p
= proc_create_data("flush", S_IFREG
| 0600,
1672 cd
->procfs
, &cache_flush_proc_ops
, cd
);
1676 if (cd
->cache_request
|| cd
->cache_parse
) {
1677 p
= proc_create_data("channel", S_IFREG
| 0600, cd
->procfs
,
1678 &cache_channel_proc_ops
, cd
);
1682 if (cd
->cache_show
) {
1683 p
= proc_create_data("content", S_IFREG
| 0400, cd
->procfs
,
1684 &content_proc_ops
, cd
);
1690 remove_cache_proc_entries(cd
);
1693 #else /* CONFIG_PROC_FS */
1694 static int create_cache_proc_entries(struct cache_detail
*cd
, struct net
*net
)
1700 void __init
cache_initialize(void)
1702 INIT_DEFERRABLE_WORK(&cache_cleaner
, do_cache_clean
);
1705 int cache_register_net(struct cache_detail
*cd
, struct net
*net
)
1709 sunrpc_init_cache_detail(cd
);
1710 ret
= create_cache_proc_entries(cd
, net
);
1712 sunrpc_destroy_cache_detail(cd
);
1715 EXPORT_SYMBOL_GPL(cache_register_net
);
1717 void cache_unregister_net(struct cache_detail
*cd
, struct net
*net
)
1719 remove_cache_proc_entries(cd
);
1720 sunrpc_destroy_cache_detail(cd
);
1722 EXPORT_SYMBOL_GPL(cache_unregister_net
);
1724 struct cache_detail
*cache_create_net(const struct cache_detail
*tmpl
, struct net
*net
)
1726 struct cache_detail
*cd
;
1729 cd
= kmemdup(tmpl
, sizeof(struct cache_detail
), GFP_KERNEL
);
1731 return ERR_PTR(-ENOMEM
);
1733 cd
->hash_table
= kcalloc(cd
->hash_size
, sizeof(struct hlist_head
),
1735 if (cd
->hash_table
== NULL
) {
1737 return ERR_PTR(-ENOMEM
);
1740 for (i
= 0; i
< cd
->hash_size
; i
++)
1741 INIT_HLIST_HEAD(&cd
->hash_table
[i
]);
1745 EXPORT_SYMBOL_GPL(cache_create_net
);
1747 void cache_destroy_net(struct cache_detail
*cd
, struct net
*net
)
1749 kfree(cd
->hash_table
);
1752 EXPORT_SYMBOL_GPL(cache_destroy_net
);
1754 static ssize_t
cache_read_pipefs(struct file
*filp
, char __user
*buf
,
1755 size_t count
, loff_t
*ppos
)
1757 struct cache_detail
*cd
= RPC_I(file_inode(filp
))->private;
1759 return cache_read(filp
, buf
, count
, ppos
, cd
);
1762 static ssize_t
cache_write_pipefs(struct file
*filp
, const char __user
*buf
,
1763 size_t count
, loff_t
*ppos
)
1765 struct cache_detail
*cd
= RPC_I(file_inode(filp
))->private;
1767 return cache_write(filp
, buf
, count
, ppos
, cd
);
1770 static __poll_t
cache_poll_pipefs(struct file
*filp
, poll_table
*wait
)
1772 struct cache_detail
*cd
= RPC_I(file_inode(filp
))->private;
1774 return cache_poll(filp
, wait
, cd
);
1777 static long cache_ioctl_pipefs(struct file
*filp
,
1778 unsigned int cmd
, unsigned long arg
)
1780 struct inode
*inode
= file_inode(filp
);
1781 struct cache_detail
*cd
= RPC_I(inode
)->private;
1783 return cache_ioctl(inode
, filp
, cmd
, arg
, cd
);
1786 static int cache_open_pipefs(struct inode
*inode
, struct file
*filp
)
1788 struct cache_detail
*cd
= RPC_I(inode
)->private;
1790 return cache_open(inode
, filp
, cd
);
1793 static int cache_release_pipefs(struct inode
*inode
, struct file
*filp
)
1795 struct cache_detail
*cd
= RPC_I(inode
)->private;
1797 return cache_release(inode
, filp
, cd
);
1800 const struct file_operations cache_file_operations_pipefs
= {
1801 .owner
= THIS_MODULE
,
1802 .llseek
= no_llseek
,
1803 .read
= cache_read_pipefs
,
1804 .write
= cache_write_pipefs
,
1805 .poll
= cache_poll_pipefs
,
1806 .unlocked_ioctl
= cache_ioctl_pipefs
, /* for FIONREAD */
1807 .open
= cache_open_pipefs
,
1808 .release
= cache_release_pipefs
,
1811 static int content_open_pipefs(struct inode
*inode
, struct file
*filp
)
1813 struct cache_detail
*cd
= RPC_I(inode
)->private;
1815 return content_open(inode
, filp
, cd
);
1818 static int content_release_pipefs(struct inode
*inode
, struct file
*filp
)
1820 struct cache_detail
*cd
= RPC_I(inode
)->private;
1822 return content_release(inode
, filp
, cd
);
1825 const struct file_operations content_file_operations_pipefs
= {
1826 .open
= content_open_pipefs
,
1828 .llseek
= seq_lseek
,
1829 .release
= content_release_pipefs
,
1832 static int open_flush_pipefs(struct inode
*inode
, struct file
*filp
)
1834 struct cache_detail
*cd
= RPC_I(inode
)->private;
1836 return open_flush(inode
, filp
, cd
);
1839 static int release_flush_pipefs(struct inode
*inode
, struct file
*filp
)
1841 struct cache_detail
*cd
= RPC_I(inode
)->private;
1843 return release_flush(inode
, filp
, cd
);
1846 static ssize_t
read_flush_pipefs(struct file
*filp
, char __user
*buf
,
1847 size_t count
, loff_t
*ppos
)
1849 struct cache_detail
*cd
= RPC_I(file_inode(filp
))->private;
1851 return read_flush(filp
, buf
, count
, ppos
, cd
);
1854 static ssize_t
write_flush_pipefs(struct file
*filp
,
1855 const char __user
*buf
,
1856 size_t count
, loff_t
*ppos
)
1858 struct cache_detail
*cd
= RPC_I(file_inode(filp
))->private;
1860 return write_flush(filp
, buf
, count
, ppos
, cd
);
1863 const struct file_operations cache_flush_operations_pipefs
= {
1864 .open
= open_flush_pipefs
,
1865 .read
= read_flush_pipefs
,
1866 .write
= write_flush_pipefs
,
1867 .release
= release_flush_pipefs
,
1868 .llseek
= no_llseek
,
1871 int sunrpc_cache_register_pipefs(struct dentry
*parent
,
1872 const char *name
, umode_t umode
,
1873 struct cache_detail
*cd
)
1875 struct dentry
*dir
= rpc_create_cache_dir(parent
, name
, umode
, cd
);
1877 return PTR_ERR(dir
);
1881 EXPORT_SYMBOL_GPL(sunrpc_cache_register_pipefs
);
1883 void sunrpc_cache_unregister_pipefs(struct cache_detail
*cd
)
1886 rpc_remove_cache_dir(cd
->pipefs
);
1890 EXPORT_SYMBOL_GPL(sunrpc_cache_unregister_pipefs
);
1892 void sunrpc_cache_unhash(struct cache_detail
*cd
, struct cache_head
*h
)
1894 spin_lock(&cd
->hash_lock
);
1895 if (!hlist_unhashed(&h
->cache_list
)){
1896 sunrpc_begin_cache_remove_entry(h
, cd
);
1897 spin_unlock(&cd
->hash_lock
);
1898 sunrpc_end_cache_remove_entry(h
, cd
);
1900 spin_unlock(&cd
->hash_lock
);
1902 EXPORT_SYMBOL_GPL(sunrpc_cache_unhash
);