blob: 2928afffbb81ffdfea820fd1c2b87c3ae8b02a73 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Andy Shevchenko1b2e1222014-11-28 17:50:28 +020023#include <linux/string_helpers.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/uaccess.h>
25#include <linux/poll.h>
26#include <linux/seq_file.h>
27#include <linux/proc_fs.h>
28#include <linux/net.h>
29#include <linux/workqueue.h>
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -080030#include <linux/mutex.h>
Trond Myklebustda770052009-08-09 15:14:28 -040031#include <linux/pagemap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <asm/ioctls.h>
33#include <linux/sunrpc/types.h>
34#include <linux/sunrpc/cache.h>
35#include <linux/sunrpc/stats.h>
Trond Myklebust8854e822009-08-09 15:14:30 -040036#include <linux/sunrpc/rpc_pipe_fs.h>
Pavel Emelyanov4f42d0d2010-09-27 14:01:58 +040037#include "netns.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#define RPCDBG_FACILITY RPCDBG_CACHE
40
J. Bruce Fieldsd76d1812011-01-02 21:28:34 -050041static bool cache_defer_req(struct cache_req *req, struct cache_head *item);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042static void cache_revisit_request(struct cache_head *item);
43
Adrian Bunk74cae612006-03-27 01:15:10 -080044static void cache_init(struct cache_head *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045{
NeilBrownc5b29f82010-08-12 16:55:22 +100046 time_t now = seconds_since_boot();
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 h->next = NULL;
48 h->flags = 0;
NeilBrownbaab9352006-03-27 01:15:09 -080049 kref_init(&h->ref);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 h->expiry_time = now + CACHE_NEW_EXPIRY;
51 h->last_refresh = now;
52}
53
NeilBrown15a5f6b2006-03-27 01:15:02 -080054struct cache_head *sunrpc_cache_lookup(struct cache_detail *detail,
55 struct cache_head *key, int hash)
56{
57 struct cache_head **head, **hp;
NeilBrownd202cce2010-02-03 17:31:31 +110058 struct cache_head *new = NULL, *freeme = NULL;
NeilBrown15a5f6b2006-03-27 01:15:02 -080059
60 head = &detail->hash_table[hash];
61
62 read_lock(&detail->hash_lock);
63
64 for (hp=head; *hp != NULL ; hp = &(*hp)->next) {
65 struct cache_head *tmp = *hp;
66 if (detail->match(tmp, key)) {
NeilBrownd202cce2010-02-03 17:31:31 +110067 if (cache_is_expired(detail, tmp))
68 /* This entry is expired, we will discard it. */
69 break;
NeilBrown15a5f6b2006-03-27 01:15:02 -080070 cache_get(tmp);
71 read_unlock(&detail->hash_lock);
72 return tmp;
73 }
74 }
75 read_unlock(&detail->hash_lock);
76 /* Didn't find anything, insert an empty entry */
77
78 new = detail->alloc();
79 if (!new)
80 return NULL;
Neil Brown2f349312006-08-05 12:14:29 -070081 /* must fully initialise 'new', else
82 * we might get lose if we need to
83 * cache_put it soon.
84 */
NeilBrown15a5f6b2006-03-27 01:15:02 -080085 cache_init(new);
Neil Brown2f349312006-08-05 12:14:29 -070086 detail->init(new, key);
NeilBrown15a5f6b2006-03-27 01:15:02 -080087
88 write_lock(&detail->hash_lock);
89
90 /* check if entry appeared while we slept */
91 for (hp=head; *hp != NULL ; hp = &(*hp)->next) {
92 struct cache_head *tmp = *hp;
93 if (detail->match(tmp, key)) {
NeilBrownd202cce2010-02-03 17:31:31 +110094 if (cache_is_expired(detail, tmp)) {
95 *hp = tmp->next;
96 tmp->next = NULL;
97 detail->entries --;
98 freeme = tmp;
99 break;
100 }
NeilBrown15a5f6b2006-03-27 01:15:02 -0800101 cache_get(tmp);
102 write_unlock(&detail->hash_lock);
NeilBrownbaab9352006-03-27 01:15:09 -0800103 cache_put(new, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800104 return tmp;
105 }
106 }
NeilBrown15a5f6b2006-03-27 01:15:02 -0800107 new->next = *head;
108 *head = new;
109 detail->entries++;
110 cache_get(new);
111 write_unlock(&detail->hash_lock);
112
NeilBrownd202cce2010-02-03 17:31:31 +1100113 if (freeme)
114 cache_put(freeme, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800115 return new;
116}
Trond Myklebust24c37672008-12-23 16:30:12 -0500117EXPORT_SYMBOL_GPL(sunrpc_cache_lookup);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800118
NeilBrownebd0cb12006-03-27 01:15:08 -0800119
NeilBrownf866a812009-08-04 15:22:38 +1000120static void cache_dequeue(struct cache_detail *detail, struct cache_head *ch);
NeilBrownebd0cb12006-03-27 01:15:08 -0800121
NeilBrown908329f2009-09-09 16:32:54 +1000122static void cache_fresh_locked(struct cache_head *head, time_t expiry)
NeilBrownebd0cb12006-03-27 01:15:08 -0800123{
124 head->expiry_time = expiry;
NeilBrownc5b29f82010-08-12 16:55:22 +1000125 head->last_refresh = seconds_since_boot();
J. Bruce Fieldsfdef7aa2011-01-04 14:12:47 -0500126 smp_wmb(); /* paired with smp_rmb() in cache_is_valid() */
NeilBrown908329f2009-09-09 16:32:54 +1000127 set_bit(CACHE_VALID, &head->flags);
NeilBrownebd0cb12006-03-27 01:15:08 -0800128}
129
130static void cache_fresh_unlocked(struct cache_head *head,
NeilBrown908329f2009-09-09 16:32:54 +1000131 struct cache_detail *detail)
NeilBrownebd0cb12006-03-27 01:15:08 -0800132{
NeilBrownebd0cb12006-03-27 01:15:08 -0800133 if (test_and_clear_bit(CACHE_PENDING, &head->flags)) {
134 cache_revisit_request(head);
NeilBrownf866a812009-08-04 15:22:38 +1000135 cache_dequeue(detail, head);
NeilBrownebd0cb12006-03-27 01:15:08 -0800136 }
137}
138
NeilBrown15a5f6b2006-03-27 01:15:02 -0800139struct cache_head *sunrpc_cache_update(struct cache_detail *detail,
140 struct cache_head *new, struct cache_head *old, int hash)
141{
142 /* The 'old' entry is to be replaced by 'new'.
143 * If 'old' is not VALID, we update it directly,
144 * otherwise we need to replace it
145 */
146 struct cache_head **head;
147 struct cache_head *tmp;
148
149 if (!test_bit(CACHE_VALID, &old->flags)) {
150 write_lock(&detail->hash_lock);
151 if (!test_bit(CACHE_VALID, &old->flags)) {
152 if (test_bit(CACHE_NEGATIVE, &new->flags))
153 set_bit(CACHE_NEGATIVE, &old->flags);
154 else
155 detail->update(old, new);
NeilBrown908329f2009-09-09 16:32:54 +1000156 cache_fresh_locked(old, new->expiry_time);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800157 write_unlock(&detail->hash_lock);
NeilBrown908329f2009-09-09 16:32:54 +1000158 cache_fresh_unlocked(old, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800159 return old;
160 }
161 write_unlock(&detail->hash_lock);
162 }
163 /* We need to insert a new entry */
164 tmp = detail->alloc();
165 if (!tmp) {
NeilBrownbaab9352006-03-27 01:15:09 -0800166 cache_put(old, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800167 return NULL;
168 }
169 cache_init(tmp);
170 detail->init(tmp, old);
171 head = &detail->hash_table[hash];
172
173 write_lock(&detail->hash_lock);
174 if (test_bit(CACHE_NEGATIVE, &new->flags))
175 set_bit(CACHE_NEGATIVE, &tmp->flags);
176 else
177 detail->update(tmp, new);
178 tmp->next = *head;
179 *head = tmp;
NeilBrownf2d39582006-05-22 22:35:25 -0700180 detail->entries++;
NeilBrown15a5f6b2006-03-27 01:15:02 -0800181 cache_get(tmp);
NeilBrown908329f2009-09-09 16:32:54 +1000182 cache_fresh_locked(tmp, new->expiry_time);
NeilBrownebd0cb12006-03-27 01:15:08 -0800183 cache_fresh_locked(old, 0);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800184 write_unlock(&detail->hash_lock);
NeilBrown908329f2009-09-09 16:32:54 +1000185 cache_fresh_unlocked(tmp, detail);
186 cache_fresh_unlocked(old, detail);
NeilBrownbaab9352006-03-27 01:15:09 -0800187 cache_put(old, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800188 return tmp;
189}
Trond Myklebust24c37672008-12-23 16:30:12 -0500190EXPORT_SYMBOL_GPL(sunrpc_cache_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Trond Myklebustbc74b4f2009-08-09 15:14:29 -0400192static int cache_make_upcall(struct cache_detail *cd, struct cache_head *h)
193{
Stanislav Kinsbursky2d438332013-02-04 14:02:50 +0300194 if (cd->cache_upcall)
195 return cd->cache_upcall(cd, h);
Stanislav Kinsbursky21cd1252013-02-04 14:02:55 +0300196 return sunrpc_cache_pipe_upcall(cd, h);
Trond Myklebustbc74b4f2009-08-09 15:14:29 -0400197}
NeilBrown989a19b2009-08-04 15:22:38 +1000198
chaoting fanb6040f92013-03-28 22:19:45 +0800199static inline int cache_is_valid(struct cache_head *h)
NeilBrown989a19b2009-08-04 15:22:38 +1000200{
NeilBrownd202cce2010-02-03 17:31:31 +1100201 if (!test_bit(CACHE_VALID, &h->flags))
NeilBrown989a19b2009-08-04 15:22:38 +1000202 return -EAGAIN;
203 else {
204 /* entry is valid */
205 if (test_bit(CACHE_NEGATIVE, &h->flags))
206 return -ENOENT;
J. Bruce Fieldsfdef7aa2011-01-04 14:12:47 -0500207 else {
208 /*
209 * In combination with write barrier in
210 * sunrpc_cache_update, ensures that anyone
211 * using the cache entry after this sees the
212 * updated contents:
213 */
214 smp_rmb();
NeilBrown989a19b2009-08-04 15:22:38 +1000215 return 0;
J. Bruce Fieldsfdef7aa2011-01-04 14:12:47 -0500216 }
NeilBrown989a19b2009-08-04 15:22:38 +1000217 }
218}
J. Bruce Fieldse9dc1222009-08-21 11:27:29 -0400219
J. Bruce Fields6bab93f2011-01-03 15:10:27 -0500220static int try_to_negate_entry(struct cache_detail *detail, struct cache_head *h)
221{
222 int rv;
223
224 write_lock(&detail->hash_lock);
chaoting fanb6040f92013-03-28 22:19:45 +0800225 rv = cache_is_valid(h);
NeilBrown2a1c7f52013-06-13 12:53:42 +1000226 if (rv == -EAGAIN) {
227 set_bit(CACHE_NEGATIVE, &h->flags);
228 cache_fresh_locked(h, seconds_since_boot()+CACHE_NEW_EXPIRY);
229 rv = -ENOENT;
J. Bruce Fields6bab93f2011-01-03 15:10:27 -0500230 }
J. Bruce Fields6bab93f2011-01-03 15:10:27 -0500231 write_unlock(&detail->hash_lock);
232 cache_fresh_unlocked(h, detail);
NeilBrown2a1c7f52013-06-13 12:53:42 +1000233 return rv;
J. Bruce Fields6bab93f2011-01-03 15:10:27 -0500234}
235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236/*
237 * This is the generic cache management routine for all
238 * the authentication caches.
239 * It checks the currency of a cache item and will (later)
240 * initiate an upcall to fill it if needed.
241 *
242 *
243 * Returns 0 if the cache_head can be used, or cache_puts it and returns
NeilBrown989a19b2009-08-04 15:22:38 +1000244 * -EAGAIN if upcall is pending and request has been queued
245 * -ETIMEDOUT if upcall failed or request could not be queue or
246 * upcall completed but item is still invalid (implying that
247 * the cache item has been replaced with a newer one).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 * -ENOENT if cache entry was negative
249 */
250int cache_check(struct cache_detail *detail,
251 struct cache_head *h, struct cache_req *rqstp)
252{
253 int rv;
254 long refresh_age, age;
255
256 /* First decide return status as best we can */
chaoting fanb6040f92013-03-28 22:19:45 +0800257 rv = cache_is_valid(h);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
259 /* now see if we want to start an upcall */
260 refresh_age = (h->expiry_time - h->last_refresh);
NeilBrownc5b29f82010-08-12 16:55:22 +1000261 age = seconds_since_boot() - h->last_refresh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
263 if (rqstp == NULL) {
264 if (rv == -EAGAIN)
265 rv = -ENOENT;
NeilBrown0bebc6332013-06-13 12:53:42 +1000266 } else if (rv == -EAGAIN ||
267 (h->expiry_time != 0 && age > refresh_age/2)) {
Chuck Lever46121cf2007-01-31 12:14:08 -0500268 dprintk("RPC: Want update, refage=%ld, age=%ld\n",
269 refresh_age, age);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 if (!test_and_set_bit(CACHE_PENDING, &h->flags)) {
271 switch (cache_make_upcall(detail, h)) {
272 case -EINVAL:
J. Bruce Fields6bab93f2011-01-03 15:10:27 -0500273 rv = try_to_negate_entry(detail, h);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 case -EAGAIN:
NeilBrown2a1c7f52013-06-13 12:53:42 +1000276 cache_fresh_unlocked(h, detail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 break;
278 }
279 }
280 }
281
NeilBrown989a19b2009-08-04 15:22:38 +1000282 if (rv == -EAGAIN) {
J. Bruce Fieldsd76d1812011-01-02 21:28:34 -0500283 if (!cache_defer_req(rqstp, h)) {
284 /*
285 * Request was not deferred; handle it as best
286 * we can ourselves:
287 */
chaoting fanb6040f92013-03-28 22:19:45 +0800288 rv = cache_is_valid(h);
NeilBrown989a19b2009-08-04 15:22:38 +1000289 if (rv == -EAGAIN)
290 rv = -ETIMEDOUT;
291 }
292 }
NeilBrown4013ede2006-03-27 01:15:07 -0800293 if (rv)
NeilBrownbaab9352006-03-27 01:15:09 -0800294 cache_put(h, detail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 return rv;
296}
Trond Myklebust24c37672008-12-23 16:30:12 -0500297EXPORT_SYMBOL_GPL(cache_check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299/*
300 * caches need to be periodically cleaned.
301 * For this we maintain a list of cache_detail and
302 * a current pointer into that list and into the table
303 * for that entry.
304 *
NeilBrown013920e2013-06-13 12:53:42 +1000305 * Each time cache_clean is called it finds the next non-empty entry
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 * in the current table and walks the list in that entry
307 * looking for entries that can be removed.
308 *
309 * An entry gets removed if:
310 * - The expiry is before current time
311 * - The last_refresh time is before the flush_time for that cache
312 *
313 * later we might drop old entries with non-NEVER expiry if that table
314 * is getting 'full' for some definition of 'full'
315 *
316 * The question of "how often to scan a table" is an interesting one
317 * and is answered in part by the use of the "nextcheck" field in the
318 * cache_detail.
319 * When a scan of a table begins, the nextcheck field is set to a time
320 * that is well into the future.
321 * While scanning, if an expiry time is found that is earlier than the
322 * current nextcheck time, nextcheck is set to that expiry time.
323 * If the flush_time is ever set to a time earlier than the nextcheck
324 * time, the nextcheck time is then set to that flush_time.
325 *
326 * A table is then only scanned if the current time is at least
327 * the nextcheck time.
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800328 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 */
330
331static LIST_HEAD(cache_list);
332static DEFINE_SPINLOCK(cache_list_lock);
333static struct cache_detail *current_detail;
334static int current_index;
335
David Howells65f27f32006-11-22 14:55:48 +0000336static void do_cache_clean(struct work_struct *work);
Artem Bityutskiy8eab9452010-07-01 18:05:56 +0300337static struct delayed_work cache_cleaner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Stanislav Kinsbursky820f9442011-11-25 17:12:40 +0300339void sunrpc_init_cache_detail(struct cache_detail *cd)
J. Bruce Fieldsffe93862007-11-12 17:04:29 -0500340{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 rwlock_init(&cd->hash_lock);
342 INIT_LIST_HEAD(&cd->queue);
343 spin_lock(&cache_list_lock);
344 cd->nextcheck = 0;
345 cd->entries = 0;
346 atomic_set(&cd->readers, 0);
347 cd->last_close = 0;
348 cd->last_warn = -1;
349 list_add(&cd->others, &cache_list);
350 spin_unlock(&cache_list_lock);
351
352 /* start the cleaning process */
David Howells52bad642006-11-22 14:54:01 +0000353 schedule_delayed_work(&cache_cleaner, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354}
Stanislav Kinsbursky820f9442011-11-25 17:12:40 +0300355EXPORT_SYMBOL_GPL(sunrpc_init_cache_detail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Stanislav Kinsbursky820f9442011-11-25 17:12:40 +0300357void sunrpc_destroy_cache_detail(struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
359 cache_purge(cd);
360 spin_lock(&cache_list_lock);
361 write_lock(&cd->hash_lock);
362 if (cd->entries || atomic_read(&cd->inuse)) {
363 write_unlock(&cd->hash_lock);
364 spin_unlock(&cache_list_lock);
J. Bruce Fieldsdf95a9d2007-11-08 16:09:59 -0500365 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 }
367 if (current_detail == cd)
368 current_detail = NULL;
369 list_del_init(&cd->others);
370 write_unlock(&cd->hash_lock);
371 spin_unlock(&cache_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 if (list_empty(&cache_list)) {
373 /* module must be being unloaded so its safe to kill the worker */
Trond Myklebust4011cd92007-08-07 15:33:01 -0400374 cancel_delayed_work_sync(&cache_cleaner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 }
J. Bruce Fieldsdf95a9d2007-11-08 16:09:59 -0500376 return;
377out:
Kinglong Meeecca0632014-04-15 17:13:56 +0800378 printk(KERN_ERR "RPC: failed to unregister %s cache\n", cd->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379}
Stanislav Kinsbursky820f9442011-11-25 17:12:40 +0300380EXPORT_SYMBOL_GPL(sunrpc_destroy_cache_detail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382/* clean cache tries to find something to clean
383 * and cleans it.
384 * It returns 1 if it cleaned something,
385 * 0 if it didn't find anything this time
386 * -1 if it fell off the end of the list.
387 */
388static int cache_clean(void)
389{
390 int rv = 0;
391 struct list_head *next;
392
393 spin_lock(&cache_list_lock);
394
395 /* find a suitable table if we don't already have one */
396 while (current_detail == NULL ||
397 current_index >= current_detail->hash_size) {
398 if (current_detail)
399 next = current_detail->others.next;
400 else
401 next = cache_list.next;
402 if (next == &cache_list) {
403 current_detail = NULL;
404 spin_unlock(&cache_list_lock);
405 return -1;
406 }
407 current_detail = list_entry(next, struct cache_detail, others);
NeilBrownc5b29f82010-08-12 16:55:22 +1000408 if (current_detail->nextcheck > seconds_since_boot())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 current_index = current_detail->hash_size;
410 else {
411 current_index = 0;
NeilBrownc5b29f82010-08-12 16:55:22 +1000412 current_detail->nextcheck = seconds_since_boot()+30*60;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 }
414 }
415
416 /* find a non-empty bucket in the table */
417 while (current_detail &&
418 current_index < current_detail->hash_size &&
419 current_detail->hash_table[current_index] == NULL)
420 current_index++;
421
422 /* find a cleanable entry in the bucket and clean it, or set to next bucket */
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 if (current_detail && current_index < current_detail->hash_size) {
425 struct cache_head *ch, **cp;
426 struct cache_detail *d;
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800427
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 write_lock(&current_detail->hash_lock);
429
430 /* Ok, now to clean this strand */
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 cp = & current_detail->hash_table[current_index];
NeilBrown3af49742010-02-03 17:31:31 +1100433 for (ch = *cp ; ch ; cp = & ch->next, ch = *cp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (current_detail->nextcheck > ch->expiry_time)
435 current_detail->nextcheck = ch->expiry_time+1;
NeilBrown2f50d8b2010-02-03 17:31:31 +1100436 if (!cache_is_expired(current_detail, ch))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 *cp = ch->next;
440 ch->next = NULL;
441 current_detail->entries--;
442 rv = 1;
NeilBrown3af49742010-02-03 17:31:31 +1100443 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
NeilBrown3af49742010-02-03 17:31:31 +1100445
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 write_unlock(&current_detail->hash_lock);
447 d = current_detail;
448 if (!ch)
449 current_index ++;
450 spin_unlock(&cache_list_lock);
NeilBrown5c4d2632009-08-04 15:22:38 +1000451 if (ch) {
NeilBrown013920e2013-06-13 12:53:42 +1000452 set_bit(CACHE_CLEANED, &ch->flags);
NeilBrown2a1c7f52013-06-13 12:53:42 +1000453 cache_fresh_unlocked(ch, d);
NeilBrownbaab9352006-03-27 01:15:09 -0800454 cache_put(ch, d);
NeilBrown5c4d2632009-08-04 15:22:38 +1000455 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 } else
457 spin_unlock(&cache_list_lock);
458
459 return rv;
460}
461
462/*
463 * We want to regularly clean the cache, so we need to schedule some work ...
464 */
David Howells65f27f32006-11-22 14:55:48 +0000465static void do_cache_clean(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
467 int delay = 5;
468 if (cache_clean() == -1)
Anton Blanchard6aad89c2009-06-10 12:52:21 -0700469 delay = round_jiffies_relative(30*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
471 if (list_empty(&cache_list))
472 delay = 0;
473
474 if (delay)
475 schedule_delayed_work(&cache_cleaner, delay);
476}
477
478
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800479/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 * Clean all caches promptly. This just calls cache_clean
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800481 * repeatedly until we are sure that every cache has had a chance to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 * be fully cleaned
483 */
484void cache_flush(void)
485{
486 while (cache_clean() != -1)
487 cond_resched();
488 while (cache_clean() != -1)
489 cond_resched();
490}
Trond Myklebust24c37672008-12-23 16:30:12 -0500491EXPORT_SYMBOL_GPL(cache_flush);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493void cache_purge(struct cache_detail *detail)
494{
495 detail->flush_time = LONG_MAX;
NeilBrownc5b29f82010-08-12 16:55:22 +1000496 detail->nextcheck = seconds_since_boot();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 cache_flush();
498 detail->flush_time = 1;
499}
Trond Myklebust24c37672008-12-23 16:30:12 -0500500EXPORT_SYMBOL_GPL(cache_purge);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502
503/*
504 * Deferral and Revisiting of Requests.
505 *
506 * If a cache lookup finds a pending entry, we
507 * need to defer the request and revisit it later.
508 * All deferred requests are stored in a hash table,
509 * indexed by "struct cache_head *".
510 * As it may be wasteful to store a whole request
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800511 * structure, we allow the request to provide a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 * deferred form, which must contain a
513 * 'struct cache_deferred_req'
514 * This cache_deferred_req contains a method to allow
515 * it to be revisited when cache info is available
516 */
517
518#define DFR_HASHSIZE (PAGE_SIZE/sizeof(struct list_head))
519#define DFR_HASH(item) ((((long)item)>>4 ^ (((long)item)>>13)) % DFR_HASHSIZE)
520
521#define DFR_MAX 300 /* ??? */
522
523static DEFINE_SPINLOCK(cache_defer_lock);
524static LIST_HEAD(cache_defer_list);
NeilBrown11174492010-08-12 17:04:08 +1000525static struct hlist_head cache_defer_hash[DFR_HASHSIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526static int cache_defer_cnt;
527
J. Bruce Fields6610f722010-08-26 13:19:52 -0400528static void __unhash_deferred_req(struct cache_deferred_req *dreq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
NeilBrown11174492010-08-12 17:04:08 +1000530 hlist_del_init(&dreq->hash);
NeilBrowne33534d2010-10-07 15:29:46 +1100531 if (!list_empty(&dreq->recent)) {
532 list_del_init(&dreq->recent);
533 cache_defer_cnt--;
534 }
J. Bruce Fields6610f722010-08-26 13:19:52 -0400535}
536
537static void __hash_deferred_req(struct cache_deferred_req *dreq, struct cache_head *item)
538{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 int hash = DFR_HASH(item);
540
NeilBrowne33534d2010-10-07 15:29:46 +1100541 INIT_LIST_HEAD(&dreq->recent);
NeilBrown11174492010-08-12 17:04:08 +1000542 hlist_add_head(&dreq->hash, &cache_defer_hash[hash]);
J. Bruce Fields6610f722010-08-26 13:19:52 -0400543}
544
NeilBrowne33534d2010-10-07 15:29:46 +1100545static void setup_deferral(struct cache_deferred_req *dreq,
546 struct cache_head *item,
547 int count_me)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 dreq->item = item;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 spin_lock(&cache_defer_lock);
553
J. Bruce Fields6610f722010-08-26 13:19:52 -0400554 __hash_deferred_req(dreq, item);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
NeilBrowne33534d2010-10-07 15:29:46 +1100556 if (count_me) {
557 cache_defer_cnt++;
558 list_add(&dreq->recent, &cache_defer_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
NeilBrowne33534d2010-10-07 15:29:46 +1100560
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 spin_unlock(&cache_defer_lock);
562
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
J. Bruce Fields3211af12010-08-26 16:56:23 -0400565struct thread_deferred_req {
566 struct cache_deferred_req handle;
567 struct completion completion;
568};
569
570static void cache_restart_thread(struct cache_deferred_req *dreq, int too_many)
571{
572 struct thread_deferred_req *dr =
573 container_of(dreq, struct thread_deferred_req, handle);
574 complete(&dr->completion);
575}
576
NeilBrownd29068c42010-10-07 15:29:46 +1100577static void cache_wait_req(struct cache_req *req, struct cache_head *item)
J. Bruce Fields3211af12010-08-26 16:56:23 -0400578{
579 struct thread_deferred_req sleeper;
580 struct cache_deferred_req *dreq = &sleeper.handle;
J. Bruce Fields3211af12010-08-26 16:56:23 -0400581
582 sleeper.completion = COMPLETION_INITIALIZER_ONSTACK(sleeper.completion);
583 dreq->revisit = cache_restart_thread;
584
NeilBrowne33534d2010-10-07 15:29:46 +1100585 setup_deferral(dreq, item, 0);
J. Bruce Fields3211af12010-08-26 16:56:23 -0400586
NeilBrownd29068c42010-10-07 15:29:46 +1100587 if (!test_bit(CACHE_PENDING, &item->flags) ||
NeilBrown277f68d2010-09-22 12:55:06 +1000588 wait_for_completion_interruptible_timeout(
J. Bruce Fields3211af12010-08-26 16:56:23 -0400589 &sleeper.completion, req->thread_wait) <= 0) {
590 /* The completion wasn't completed, so we need
591 * to clean up
592 */
593 spin_lock(&cache_defer_lock);
NeilBrown11174492010-08-12 17:04:08 +1000594 if (!hlist_unhashed(&sleeper.handle.hash)) {
J. Bruce Fields3211af12010-08-26 16:56:23 -0400595 __unhash_deferred_req(&sleeper.handle);
596 spin_unlock(&cache_defer_lock);
597 } else {
598 /* cache_revisit_request already removed
599 * this from the hash table, but hasn't
600 * called ->revisit yet. It will very soon
601 * and we need to wait for it.
602 */
603 spin_unlock(&cache_defer_lock);
604 wait_for_completion(&sleeper.completion);
605 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 }
J. Bruce Fields3211af12010-08-26 16:56:23 -0400607}
608
NeilBrowne33534d2010-10-07 15:29:46 +1100609static void cache_limit_defers(void)
610{
611 /* Make sure we haven't exceed the limit of allowed deferred
612 * requests.
613 */
614 struct cache_deferred_req *discard = NULL;
615
616 if (cache_defer_cnt <= DFR_MAX)
617 return;
618
619 spin_lock(&cache_defer_lock);
620
621 /* Consider removing either the first or the last */
622 if (cache_defer_cnt > DFR_MAX) {
Aruna-Hewapathirane63862b52014-01-11 07:15:59 -0500623 if (prandom_u32() & 1)
NeilBrowne33534d2010-10-07 15:29:46 +1100624 discard = list_entry(cache_defer_list.next,
625 struct cache_deferred_req, recent);
626 else
627 discard = list_entry(cache_defer_list.prev,
628 struct cache_deferred_req, recent);
629 __unhash_deferred_req(discard);
630 }
631 spin_unlock(&cache_defer_lock);
632 if (discard)
633 discard->revisit(discard, 1);
634}
635
J. Bruce Fieldsd76d1812011-01-02 21:28:34 -0500636/* Return true if and only if a deferred request is queued. */
637static bool cache_defer_req(struct cache_req *req, struct cache_head *item)
J. Bruce Fields3211af12010-08-26 16:56:23 -0400638{
639 struct cache_deferred_req *dreq;
J. Bruce Fields3211af12010-08-26 16:56:23 -0400640
J. Bruce Fields3211af12010-08-26 16:56:23 -0400641 if (req->thread_wait) {
NeilBrownd29068c42010-10-07 15:29:46 +1100642 cache_wait_req(req, item);
643 if (!test_bit(CACHE_PENDING, &item->flags))
J. Bruce Fieldsd76d1812011-01-02 21:28:34 -0500644 return false;
J. Bruce Fields3211af12010-08-26 16:56:23 -0400645 }
646 dreq = req->defer(req);
647 if (dreq == NULL)
J. Bruce Fieldsd76d1812011-01-02 21:28:34 -0500648 return false;
NeilBrowne33534d2010-10-07 15:29:46 +1100649 setup_deferral(dreq, item, 1);
NeilBrownd29068c42010-10-07 15:29:46 +1100650 if (!test_bit(CACHE_PENDING, &item->flags))
651 /* Bit could have been cleared before we managed to
652 * set up the deferral, so need to revisit just in case
653 */
654 cache_revisit_request(item);
NeilBrowne33534d2010-10-07 15:29:46 +1100655
656 cache_limit_defers();
J. Bruce Fieldsd76d1812011-01-02 21:28:34 -0500657 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658}
659
660static void cache_revisit_request(struct cache_head *item)
661{
662 struct cache_deferred_req *dreq;
663 struct list_head pending;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800664 struct hlist_node *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 int hash = DFR_HASH(item);
666
667 INIT_LIST_HEAD(&pending);
668 spin_lock(&cache_defer_lock);
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800669
Sasha Levinb67bfe02013-02-27 17:06:00 -0800670 hlist_for_each_entry_safe(dreq, tmp, &cache_defer_hash[hash], hash)
NeilBrown11174492010-08-12 17:04:08 +1000671 if (dreq->item == item) {
672 __unhash_deferred_req(dreq);
673 list_add(&dreq->recent, &pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 }
NeilBrown11174492010-08-12 17:04:08 +1000675
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 spin_unlock(&cache_defer_lock);
677
678 while (!list_empty(&pending)) {
679 dreq = list_entry(pending.next, struct cache_deferred_req, recent);
680 list_del_init(&dreq->recent);
681 dreq->revisit(dreq, 0);
682 }
683}
684
685void cache_clean_deferred(void *owner)
686{
687 struct cache_deferred_req *dreq, *tmp;
688 struct list_head pending;
689
690
691 INIT_LIST_HEAD(&pending);
692 spin_lock(&cache_defer_lock);
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 list_for_each_entry_safe(dreq, tmp, &cache_defer_list, recent) {
695 if (dreq->owner == owner) {
J. Bruce Fields6610f722010-08-26 13:19:52 -0400696 __unhash_deferred_req(dreq);
NeilBrowne95dffa2010-09-22 12:55:06 +1000697 list_add(&dreq->recent, &pending);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 }
699 }
700 spin_unlock(&cache_defer_lock);
701
702 while (!list_empty(&pending)) {
703 dreq = list_entry(pending.next, struct cache_deferred_req, recent);
704 list_del_init(&dreq->recent);
705 dreq->revisit(dreq, 1);
706 }
707}
708
709/*
710 * communicate with user-space
711 *
J. Bruce Fieldsa490c682007-11-06 14:15:19 -0500712 * We have a magic /proc file - /proc/sunrpc/<cachename>/channel.
713 * On read, you get a full request, or block.
714 * On write, an update request is processed.
715 * Poll works if anything to read, and always allows write.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800717 * Implemented by linked list of requests. Each open file has
J. Bruce Fieldsa490c682007-11-06 14:15:19 -0500718 * a ->private that also exists in this list. New requests are added
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 * to the end and may wakeup and preceding readers.
720 * New readers are added to the head. If, on read, an item is found with
721 * CACHE_UPCALLING clear, we free it from the list.
722 *
723 */
724
725static DEFINE_SPINLOCK(queue_lock);
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -0800726static DEFINE_MUTEX(queue_io_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
728struct cache_queue {
729 struct list_head list;
730 int reader; /* if 0, then request */
731};
732struct cache_request {
733 struct cache_queue q;
734 struct cache_head *item;
735 char * buf;
736 int len;
737 int readers;
738};
739struct cache_reader {
740 struct cache_queue q;
741 int offset; /* if non-0, we have a refcnt on next request */
742};
743
Stanislav Kinsburskyd94af6d2013-02-04 14:03:03 +0300744static int cache_request(struct cache_detail *detail,
745 struct cache_request *crq)
746{
747 char *bp = crq->buf;
748 int len = PAGE_SIZE;
749
750 detail->cache_request(detail, crq->item, &bp, &len);
751 if (len < 0)
752 return -EAGAIN;
753 return PAGE_SIZE - len;
754}
755
Trond Myklebust173912a2009-08-09 15:14:29 -0400756static ssize_t cache_read(struct file *filp, char __user *buf, size_t count,
757 loff_t *ppos, struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758{
759 struct cache_reader *rp = filp->private_data;
760 struct cache_request *rq;
Al Viro496ad9a2013-01-23 17:07:38 -0500761 struct inode *inode = file_inode(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 int err;
763
764 if (count == 0)
765 return 0;
766
Trond Myklebustda770052009-08-09 15:14:28 -0400767 mutex_lock(&inode->i_mutex); /* protect against multiple concurrent
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 * readers on this file */
769 again:
770 spin_lock(&queue_lock);
771 /* need to find next request */
772 while (rp->q.list.next != &cd->queue &&
773 list_entry(rp->q.list.next, struct cache_queue, list)
774 ->reader) {
775 struct list_head *next = rp->q.list.next;
776 list_move(&rp->q.list, next);
777 }
778 if (rp->q.list.next == &cd->queue) {
779 spin_unlock(&queue_lock);
Trond Myklebustda770052009-08-09 15:14:28 -0400780 mutex_unlock(&inode->i_mutex);
Weston Andros Adamson0db74d92012-10-23 10:43:36 -0400781 WARN_ON_ONCE(rp->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 return 0;
783 }
784 rq = container_of(rp->q.list.next, struct cache_request, q.list);
Weston Andros Adamson0db74d92012-10-23 10:43:36 -0400785 WARN_ON_ONCE(rq->q.reader);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 if (rp->offset == 0)
787 rq->readers++;
788 spin_unlock(&queue_lock);
789
Stanislav Kinsburskyd94af6d2013-02-04 14:03:03 +0300790 if (rq->len == 0) {
791 err = cache_request(cd, rq);
792 if (err < 0)
793 goto out;
794 rq->len = err;
795 }
796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 if (rp->offset == 0 && !test_bit(CACHE_PENDING, &rq->item->flags)) {
798 err = -EAGAIN;
799 spin_lock(&queue_lock);
800 list_move(&rp->q.list, &rq->q.list);
801 spin_unlock(&queue_lock);
802 } else {
803 if (rp->offset + count > rq->len)
804 count = rq->len - rp->offset;
805 err = -EFAULT;
806 if (copy_to_user(buf, rq->buf + rp->offset, count))
807 goto out;
808 rp->offset += count;
809 if (rp->offset >= rq->len) {
810 rp->offset = 0;
811 spin_lock(&queue_lock);
812 list_move(&rp->q.list, &rq->q.list);
813 spin_unlock(&queue_lock);
814 }
815 err = 0;
816 }
817 out:
818 if (rp->offset == 0) {
819 /* need to release rq */
820 spin_lock(&queue_lock);
821 rq->readers--;
822 if (rq->readers == 0 &&
823 !test_bit(CACHE_PENDING, &rq->item->flags)) {
824 list_del(&rq->q.list);
825 spin_unlock(&queue_lock);
NeilBrownbaab9352006-03-27 01:15:09 -0800826 cache_put(rq->item, cd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 kfree(rq->buf);
828 kfree(rq);
829 } else
830 spin_unlock(&queue_lock);
831 }
832 if (err == -EAGAIN)
833 goto again;
Trond Myklebustda770052009-08-09 15:14:28 -0400834 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 return err ? err : count;
836}
837
Trond Myklebustda770052009-08-09 15:14:28 -0400838static ssize_t cache_do_downcall(char *kaddr, const char __user *buf,
839 size_t count, struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840{
Trond Myklebustda770052009-08-09 15:14:28 -0400841 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Dan Carpenter6d8d1742012-01-18 12:56:02 +0300843 if (count == 0)
844 return -EINVAL;
Trond Myklebustda770052009-08-09 15:14:28 -0400845 if (copy_from_user(kaddr, buf, count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 return -EFAULT;
Trond Myklebustda770052009-08-09 15:14:28 -0400847 kaddr[count] = '\0';
848 ret = cd->cache_parse(cd, kaddr, count);
849 if (!ret)
850 ret = count;
851 return ret;
852}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Trond Myklebustda770052009-08-09 15:14:28 -0400854static ssize_t cache_slow_downcall(const char __user *buf,
855 size_t count, struct cache_detail *cd)
856{
857 static char write_buf[8192]; /* protected by queue_io_mutex */
858 ssize_t ret = -EINVAL;
859
860 if (count >= sizeof(write_buf))
861 goto out;
862 mutex_lock(&queue_io_mutex);
863 ret = cache_do_downcall(write_buf, buf, count, cd);
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -0800864 mutex_unlock(&queue_io_mutex);
Trond Myklebustda770052009-08-09 15:14:28 -0400865out:
866 return ret;
867}
868
869static ssize_t cache_downcall(struct address_space *mapping,
870 const char __user *buf,
871 size_t count, struct cache_detail *cd)
872{
873 struct page *page;
874 char *kaddr;
875 ssize_t ret = -ENOMEM;
876
877 if (count >= PAGE_CACHE_SIZE)
878 goto out_slow;
879
880 page = find_or_create_page(mapping, 0, GFP_KERNEL);
881 if (!page)
882 goto out_slow;
883
884 kaddr = kmap(page);
885 ret = cache_do_downcall(kaddr, buf, count, cd);
886 kunmap(page);
887 unlock_page(page);
888 page_cache_release(page);
889 return ret;
890out_slow:
891 return cache_slow_downcall(buf, count, cd);
892}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
Trond Myklebust173912a2009-08-09 15:14:29 -0400894static ssize_t cache_write(struct file *filp, const char __user *buf,
895 size_t count, loff_t *ppos,
896 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897{
Trond Myklebustda770052009-08-09 15:14:28 -0400898 struct address_space *mapping = filp->f_mapping;
Al Viro496ad9a2013-01-23 17:07:38 -0500899 struct inode *inode = file_inode(filp);
Trond Myklebustda770052009-08-09 15:14:28 -0400900 ssize_t ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
Trond Myklebustda770052009-08-09 15:14:28 -0400902 if (!cd->cache_parse)
903 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
Trond Myklebustda770052009-08-09 15:14:28 -0400905 mutex_lock(&inode->i_mutex);
906 ret = cache_downcall(mapping, buf, count, cd);
907 mutex_unlock(&inode->i_mutex);
908out:
909 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910}
911
912static DECLARE_WAIT_QUEUE_HEAD(queue_wait);
913
Trond Myklebust173912a2009-08-09 15:14:29 -0400914static unsigned int cache_poll(struct file *filp, poll_table *wait,
915 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
917 unsigned int mask;
918 struct cache_reader *rp = filp->private_data;
919 struct cache_queue *cq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
921 poll_wait(filp, &queue_wait, wait);
922
923 /* alway allow write */
Al Viro1711fd9a2015-03-07 21:08:46 +0000924 mask = POLLOUT | POLLWRNORM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926 if (!rp)
927 return mask;
928
929 spin_lock(&queue_lock);
930
931 for (cq= &rp->q; &cq->list != &cd->queue;
932 cq = list_entry(cq->list.next, struct cache_queue, list))
933 if (!cq->reader) {
934 mask |= POLLIN | POLLRDNORM;
935 break;
936 }
937 spin_unlock(&queue_lock);
938 return mask;
939}
940
Trond Myklebust173912a2009-08-09 15:14:29 -0400941static int cache_ioctl(struct inode *ino, struct file *filp,
942 unsigned int cmd, unsigned long arg,
943 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944{
945 int len = 0;
946 struct cache_reader *rp = filp->private_data;
947 struct cache_queue *cq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948
949 if (cmd != FIONREAD || !rp)
950 return -EINVAL;
951
952 spin_lock(&queue_lock);
953
954 /* only find the length remaining in current request,
955 * or the length of the next request
956 */
957 for (cq= &rp->q; &cq->list != &cd->queue;
958 cq = list_entry(cq->list.next, struct cache_queue, list))
959 if (!cq->reader) {
960 struct cache_request *cr =
961 container_of(cq, struct cache_request, q);
962 len = cr->len - rp->offset;
963 break;
964 }
965 spin_unlock(&queue_lock);
966
967 return put_user(len, (int __user *)arg);
968}
969
Trond Myklebust173912a2009-08-09 15:14:29 -0400970static int cache_open(struct inode *inode, struct file *filp,
971 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972{
973 struct cache_reader *rp = NULL;
974
Trond Myklebustf7e86ab2009-08-19 18:13:00 -0400975 if (!cd || !try_module_get(cd->owner))
976 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 nonseekable_open(inode, filp);
978 if (filp->f_mode & FMODE_READ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 rp = kmalloc(sizeof(*rp), GFP_KERNEL);
Alexey Khoroshilova7823c72013-03-23 00:36:44 +0400980 if (!rp) {
981 module_put(cd->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 return -ENOMEM;
Alexey Khoroshilova7823c72013-03-23 00:36:44 +0400983 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 rp->offset = 0;
985 rp->q.reader = 1;
986 atomic_inc(&cd->readers);
987 spin_lock(&queue_lock);
988 list_add(&rp->q.list, &cd->queue);
989 spin_unlock(&queue_lock);
990 }
991 filp->private_data = rp;
992 return 0;
993}
994
Trond Myklebust173912a2009-08-09 15:14:29 -0400995static int cache_release(struct inode *inode, struct file *filp,
996 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997{
998 struct cache_reader *rp = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999
1000 if (rp) {
1001 spin_lock(&queue_lock);
1002 if (rp->offset) {
1003 struct cache_queue *cq;
1004 for (cq= &rp->q; &cq->list != &cd->queue;
1005 cq = list_entry(cq->list.next, struct cache_queue, list))
1006 if (!cq->reader) {
1007 container_of(cq, struct cache_request, q)
1008 ->readers--;
1009 break;
1010 }
1011 rp->offset = 0;
1012 }
1013 list_del(&rp->q.list);
1014 spin_unlock(&queue_lock);
1015
1016 filp->private_data = NULL;
1017 kfree(rp);
1018
NeilBrownc5b29f82010-08-12 16:55:22 +10001019 cd->last_close = seconds_since_boot();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 atomic_dec(&cd->readers);
1021 }
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001022 module_put(cd->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 return 0;
1024}
1025
1026
1027
NeilBrownf866a812009-08-04 15:22:38 +10001028static void cache_dequeue(struct cache_detail *detail, struct cache_head *ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029{
NeilBrownf9e1aed2013-06-13 12:53:42 +10001030 struct cache_queue *cq, *tmp;
1031 struct cache_request *cr;
1032 struct list_head dequeued;
1033
1034 INIT_LIST_HEAD(&dequeued);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 spin_lock(&queue_lock);
NeilBrownf9e1aed2013-06-13 12:53:42 +10001036 list_for_each_entry_safe(cq, tmp, &detail->queue, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 if (!cq->reader) {
NeilBrownf9e1aed2013-06-13 12:53:42 +10001038 cr = container_of(cq, struct cache_request, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 if (cr->item != ch)
1040 continue;
NeilBrownf9e1aed2013-06-13 12:53:42 +10001041 if (test_bit(CACHE_PENDING, &ch->flags))
1042 /* Lost a race and it is pending again */
1043 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 if (cr->readers != 0)
NeilBrown4013ede2006-03-27 01:15:07 -08001045 continue;
NeilBrownf9e1aed2013-06-13 12:53:42 +10001046 list_move(&cr->q.list, &dequeued);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 }
1048 spin_unlock(&queue_lock);
NeilBrownf9e1aed2013-06-13 12:53:42 +10001049 while (!list_empty(&dequeued)) {
1050 cr = list_entry(dequeued.next, struct cache_request, q.list);
1051 list_del(&cr->q.list);
1052 cache_put(cr->item, detail);
1053 kfree(cr->buf);
1054 kfree(cr);
1055 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056}
1057
1058/*
1059 * Support routines for text-based upcalls.
1060 * Fields are separated by spaces.
1061 * Fields are either mangled to quote space tab newline slosh with slosh
1062 * or a hexified with a leading \x
1063 * Record is terminated with newline.
1064 *
1065 */
1066
1067void qword_add(char **bpp, int *lp, char *str)
1068{
1069 char *bp = *bpp;
1070 int len = *lp;
Andy Shevchenko1b2e1222014-11-28 17:50:28 +02001071 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
1073 if (len < 0) return;
1074
Rasmus Villemoes41416f22015-04-15 16:17:28 -07001075 ret = string_escape_str(str, bp, len, ESCAPE_OCTAL, "\\ \n\t");
1076 if (ret >= len) {
1077 bp += len;
Andy Shevchenko1b2e1222014-11-28 17:50:28 +02001078 len = -1;
Rasmus Villemoes41416f22015-04-15 16:17:28 -07001079 } else {
1080 bp += ret;
Andy Shevchenko1b2e1222014-11-28 17:50:28 +02001081 len -= ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 *bp++ = ' ';
1083 len--;
1084 }
1085 *bpp = bp;
1086 *lp = len;
1087}
Trond Myklebust24c37672008-12-23 16:30:12 -05001088EXPORT_SYMBOL_GPL(qword_add);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
1090void qword_addhex(char **bpp, int *lp, char *buf, int blen)
1091{
1092 char *bp = *bpp;
1093 int len = *lp;
1094
1095 if (len < 0) return;
1096
1097 if (len > 2) {
1098 *bp++ = '\\';
1099 *bp++ = 'x';
1100 len -= 2;
1101 while (blen && len >= 2) {
Andy Shevchenko056785e2013-12-12 15:49:21 +02001102 bp = hex_byte_pack(bp, *buf++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 len -= 2;
1104 blen--;
1105 }
1106 }
1107 if (blen || len<1) len = -1;
1108 else {
1109 *bp++ = ' ';
1110 len--;
1111 }
1112 *bpp = bp;
1113 *lp = len;
1114}
Trond Myklebust24c37672008-12-23 16:30:12 -05001115EXPORT_SYMBOL_GPL(qword_addhex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
1117static void warn_no_listener(struct cache_detail *detail)
1118{
1119 if (detail->last_warn != detail->last_close) {
1120 detail->last_warn = detail->last_close;
1121 if (detail->warn_no_listener)
Trond Myklebust2da8ca22009-08-09 15:14:26 -04001122 detail->warn_no_listener(detail, detail->last_close != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 }
1124}
1125
J. Bruce Fields06497522010-09-19 22:55:06 -04001126static bool cache_listeners_exist(struct cache_detail *detail)
1127{
1128 if (atomic_read(&detail->readers))
1129 return true;
1130 if (detail->last_close == 0)
1131 /* This cache was never opened */
1132 return false;
1133 if (detail->last_close < seconds_since_boot() - 30)
1134 /*
1135 * We allow for the possibility that someone might
1136 * restart a userspace daemon without restarting the
1137 * server; but after 30 seconds, we give up.
1138 */
1139 return false;
1140 return true;
1141}
1142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143/*
Trond Myklebustbc74b4f2009-08-09 15:14:29 -04001144 * register an upcall request to user-space and queue it up for read() by the
1145 * upcall daemon.
1146 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 * Each request is at most one page long.
1148 */
Stanislav Kinsbursky21cd1252013-02-04 14:02:55 +03001149int sunrpc_cache_pipe_upcall(struct cache_detail *detail, struct cache_head *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150{
1151
1152 char *buf;
1153 struct cache_request *crq;
NeilBrownf9e1aed2013-06-13 12:53:42 +10001154 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
Stanislav Kinsbursky2d438332013-02-04 14:02:50 +03001156 if (!detail->cache_request)
1157 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
J. Bruce Fields06497522010-09-19 22:55:06 -04001159 if (!cache_listeners_exist(detail)) {
1160 warn_no_listener(detail);
1161 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 }
NeilBrown013920e2013-06-13 12:53:42 +10001163 if (test_bit(CACHE_CLEANED, &h->flags))
1164 /* Too late to make an upcall */
1165 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166
1167 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1168 if (!buf)
1169 return -EAGAIN;
1170
1171 crq = kmalloc(sizeof (*crq), GFP_KERNEL);
1172 if (!crq) {
1173 kfree(buf);
1174 return -EAGAIN;
1175 }
1176
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 crq->q.reader = 0;
1178 crq->item = cache_get(h);
1179 crq->buf = buf;
Stanislav Kinsburskyd94af6d2013-02-04 14:03:03 +03001180 crq->len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 crq->readers = 0;
1182 spin_lock(&queue_lock);
NeilBrownf9e1aed2013-06-13 12:53:42 +10001183 if (test_bit(CACHE_PENDING, &h->flags))
1184 list_add_tail(&crq->q.list, &detail->queue);
1185 else
1186 /* Lost a race, no longer PENDING, so don't enqueue */
1187 ret = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 spin_unlock(&queue_lock);
1189 wake_up(&queue_wait);
NeilBrownf9e1aed2013-06-13 12:53:42 +10001190 if (ret == -EAGAIN) {
1191 kfree(buf);
1192 kfree(crq);
1193 }
1194 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195}
Trond Myklebustbc74b4f2009-08-09 15:14:29 -04001196EXPORT_SYMBOL_GPL(sunrpc_cache_pipe_upcall);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
1198/*
1199 * parse a message from user-space and pass it
1200 * to an appropriate cache
1201 * Messages are, like requests, separated into fields by
1202 * spaces and dequotes as \xHEXSTRING or embedded \nnn octal
1203 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001204 * Message is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 * reply cachename expiry key ... content....
1206 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001207 * key and content are both parsed by cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 */
1209
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210int qword_get(char **bpp, char *dest, int bufsize)
1211{
1212 /* return bytes copied, or -1 on error */
1213 char *bp = *bpp;
1214 int len = 0;
1215
1216 while (*bp == ' ') bp++;
1217
1218 if (bp[0] == '\\' && bp[1] == 'x') {
1219 /* HEX STRING */
1220 bp += 2;
Andy Shevchenkoe7f483e2010-09-21 09:40:25 +03001221 while (len < bufsize) {
1222 int h, l;
1223
1224 h = hex_to_bin(bp[0]);
1225 if (h < 0)
1226 break;
1227
1228 l = hex_to_bin(bp[1]);
1229 if (l < 0)
1230 break;
1231
1232 *dest++ = (h << 4) | l;
1233 bp += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 len++;
1235 }
1236 } else {
1237 /* text with \nnn octal quoting */
1238 while (*bp != ' ' && *bp != '\n' && *bp && len < bufsize-1) {
1239 if (*bp == '\\' &&
1240 isodigit(bp[1]) && (bp[1] <= '3') &&
1241 isodigit(bp[2]) &&
1242 isodigit(bp[3])) {
1243 int byte = (*++bp -'0');
1244 bp++;
1245 byte = (byte << 3) | (*bp++ - '0');
1246 byte = (byte << 3) | (*bp++ - '0');
1247 *dest++ = byte;
1248 len++;
1249 } else {
1250 *dest++ = *bp++;
1251 len++;
1252 }
1253 }
1254 }
1255
1256 if (*bp != ' ' && *bp != '\n' && *bp != '\0')
1257 return -1;
1258 while (*bp == ' ') bp++;
1259 *bpp = bp;
1260 *dest = '\0';
1261 return len;
1262}
Trond Myklebust24c37672008-12-23 16:30:12 -05001263EXPORT_SYMBOL_GPL(qword_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
1265
1266/*
1267 * support /proc/sunrpc/cache/$CACHENAME/content
1268 * as a seqfile.
1269 * We call ->cache_show passing NULL for the item to
1270 * get a header, then pass each real item in the cache
1271 */
1272
1273struct handle {
1274 struct cache_detail *cd;
1275};
1276
1277static void *c_start(struct seq_file *m, loff_t *pos)
Eric Dumazet9a429c42008-01-01 21:58:02 -08001278 __acquires(cd->hash_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279{
1280 loff_t n = *pos;
Eric Dumazet95c96172012-04-15 05:58:06 +00001281 unsigned int hash, entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 struct cache_head *ch;
1283 struct cache_detail *cd = ((struct handle*)m->private)->cd;
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001284
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
1286 read_lock(&cd->hash_lock);
1287 if (!n--)
1288 return SEQ_START_TOKEN;
1289 hash = n >> 32;
1290 entry = n & ((1LL<<32) - 1);
1291
1292 for (ch=cd->hash_table[hash]; ch; ch=ch->next)
1293 if (!entry--)
1294 return ch;
1295 n &= ~((1LL<<32) - 1);
1296 do {
1297 hash++;
1298 n += 1LL<<32;
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001299 } while(hash < cd->hash_size &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 cd->hash_table[hash]==NULL);
1301 if (hash >= cd->hash_size)
1302 return NULL;
1303 *pos = n+1;
1304 return cd->hash_table[hash];
1305}
1306
1307static void *c_next(struct seq_file *m, void *p, loff_t *pos)
1308{
1309 struct cache_head *ch = p;
1310 int hash = (*pos >> 32);
1311 struct cache_detail *cd = ((struct handle*)m->private)->cd;
1312
1313 if (p == SEQ_START_TOKEN)
1314 hash = 0;
1315 else if (ch->next == NULL) {
1316 hash++;
1317 *pos += 1LL<<32;
1318 } else {
1319 ++*pos;
1320 return ch->next;
1321 }
1322 *pos &= ~((1LL<<32) - 1);
1323 while (hash < cd->hash_size &&
1324 cd->hash_table[hash] == NULL) {
1325 hash++;
1326 *pos += 1LL<<32;
1327 }
1328 if (hash >= cd->hash_size)
1329 return NULL;
1330 ++*pos;
1331 return cd->hash_table[hash];
1332}
1333
1334static void c_stop(struct seq_file *m, void *p)
Eric Dumazet9a429c42008-01-01 21:58:02 -08001335 __releases(cd->hash_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336{
1337 struct cache_detail *cd = ((struct handle*)m->private)->cd;
1338 read_unlock(&cd->hash_lock);
1339}
1340
1341static int c_show(struct seq_file *m, void *p)
1342{
1343 struct cache_head *cp = p;
1344 struct cache_detail *cd = ((struct handle*)m->private)->cd;
1345
1346 if (p == SEQ_START_TOKEN)
1347 return cd->cache_show(m, cd, NULL);
1348
1349 ifdebug(CACHE)
NeilBrown4013ede2006-03-27 01:15:07 -08001350 seq_printf(m, "# expiry=%ld refcnt=%d flags=%lx\n",
NeilBrownc5b29f82010-08-12 16:55:22 +10001351 convert_to_wallclock(cp->expiry_time),
1352 atomic_read(&cp->ref.refcount), cp->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 cache_get(cp);
1354 if (cache_check(cd, cp, NULL))
1355 /* cache_check does a cache_put on failure */
1356 seq_printf(m, "# ");
NeilBrown200724a2012-07-12 10:37:34 +10001357 else {
1358 if (cache_is_expired(cd, cp))
1359 seq_printf(m, "# ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 cache_put(cp, cd);
NeilBrown200724a2012-07-12 10:37:34 +10001361 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
1363 return cd->cache_show(m, cd, cp);
1364}
1365
Philippe De Muyter56b3d972007-07-10 23:07:31 -07001366static const struct seq_operations cache_content_op = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 .start = c_start,
1368 .next = c_next,
1369 .stop = c_stop,
1370 .show = c_show,
1371};
1372
Trond Myklebust173912a2009-08-09 15:14:29 -04001373static int content_open(struct inode *inode, struct file *file,
1374 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 struct handle *han;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001378 if (!cd || !try_module_get(cd->owner))
1379 return -EACCES;
Pavel Emelyanovec931032007-10-10 02:31:07 -07001380 han = __seq_open_private(file, &cache_content_op, sizeof(*han));
Li Zefana5990ea2010-03-11 14:08:10 -08001381 if (han == NULL) {
1382 module_put(cd->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 return -ENOMEM;
Li Zefana5990ea2010-03-11 14:08:10 -08001384 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385
1386 han->cd = cd;
Pavel Emelyanovec931032007-10-10 02:31:07 -07001387 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001390static int content_release(struct inode *inode, struct file *file,
1391 struct cache_detail *cd)
1392{
1393 int ret = seq_release_private(inode, file);
1394 module_put(cd->owner);
1395 return ret;
1396}
1397
1398static int open_flush(struct inode *inode, struct file *file,
1399 struct cache_detail *cd)
1400{
1401 if (!cd || !try_module_get(cd->owner))
1402 return -EACCES;
1403 return nonseekable_open(inode, file);
1404}
1405
1406static int release_flush(struct inode *inode, struct file *file,
1407 struct cache_detail *cd)
1408{
1409 module_put(cd->owner);
1410 return 0;
1411}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412
1413static ssize_t read_flush(struct file *file, char __user *buf,
Trond Myklebust173912a2009-08-09 15:14:29 -04001414 size_t count, loff_t *ppos,
1415 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416{
Sasha Levin212ba902012-07-17 00:01:26 +02001417 char tbuf[22];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 unsigned long p = *ppos;
Chuck Lever01b29692007-10-26 13:31:20 -04001419 size_t len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Sasha Levin212ba902012-07-17 00:01:26 +02001421 snprintf(tbuf, sizeof(tbuf), "%lu\n", convert_to_wallclock(cd->flush_time));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 len = strlen(tbuf);
1423 if (p >= len)
1424 return 0;
1425 len -= p;
Chuck Lever01b29692007-10-26 13:31:20 -04001426 if (len > count)
1427 len = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 if (copy_to_user(buf, (void*)(tbuf+p), len))
Chuck Lever01b29692007-10-26 13:31:20 -04001429 return -EFAULT;
1430 *ppos += len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 return len;
1432}
1433
Trond Myklebust173912a2009-08-09 15:14:29 -04001434static ssize_t write_flush(struct file *file, const char __user *buf,
1435 size_t count, loff_t *ppos,
1436 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 char tbuf[20];
NeilBrownc5b29f82010-08-12 16:55:22 +10001439 char *bp, *ep;
1440
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 if (*ppos || count > sizeof(tbuf)-1)
1442 return -EINVAL;
1443 if (copy_from_user(tbuf, buf, count))
1444 return -EFAULT;
1445 tbuf[count] = 0;
NeilBrownc5b29f82010-08-12 16:55:22 +10001446 simple_strtoul(tbuf, &ep, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 if (*ep && *ep != '\n')
1448 return -EINVAL;
1449
NeilBrownc5b29f82010-08-12 16:55:22 +10001450 bp = tbuf;
1451 cd->flush_time = get_expiry(&bp);
1452 cd->nextcheck = seconds_since_boot();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 cache_flush();
1454
1455 *ppos += count;
1456 return count;
1457}
1458
Trond Myklebust173912a2009-08-09 15:14:29 -04001459static ssize_t cache_read_procfs(struct file *filp, char __user *buf,
1460 size_t count, loff_t *ppos)
1461{
Al Virod9dda782013-03-31 18:16:14 -04001462 struct cache_detail *cd = PDE_DATA(file_inode(filp));
Trond Myklebust173912a2009-08-09 15:14:29 -04001463
1464 return cache_read(filp, buf, count, ppos, cd);
1465}
1466
1467static ssize_t cache_write_procfs(struct file *filp, const char __user *buf,
1468 size_t count, loff_t *ppos)
1469{
Al Virod9dda782013-03-31 18:16:14 -04001470 struct cache_detail *cd = PDE_DATA(file_inode(filp));
Trond Myklebust173912a2009-08-09 15:14:29 -04001471
1472 return cache_write(filp, buf, count, ppos, cd);
1473}
1474
1475static unsigned int cache_poll_procfs(struct file *filp, poll_table *wait)
1476{
Al Virod9dda782013-03-31 18:16:14 -04001477 struct cache_detail *cd = PDE_DATA(file_inode(filp));
Trond Myklebust173912a2009-08-09 15:14:29 -04001478
1479 return cache_poll(filp, wait, cd);
1480}
1481
Frederic Weisbeckerd79b6f42010-03-30 07:27:50 +02001482static long cache_ioctl_procfs(struct file *filp,
1483 unsigned int cmd, unsigned long arg)
Trond Myklebust173912a2009-08-09 15:14:29 -04001484{
Al Viro496ad9a2013-01-23 17:07:38 -05001485 struct inode *inode = file_inode(filp);
Al Virod9dda782013-03-31 18:16:14 -04001486 struct cache_detail *cd = PDE_DATA(inode);
Trond Myklebust173912a2009-08-09 15:14:29 -04001487
Arnd Bergmanna6f8dbc2010-10-04 21:18:23 +02001488 return cache_ioctl(inode, filp, cmd, arg, cd);
Trond Myklebust173912a2009-08-09 15:14:29 -04001489}
1490
1491static int cache_open_procfs(struct inode *inode, struct file *filp)
1492{
Al Virod9dda782013-03-31 18:16:14 -04001493 struct cache_detail *cd = PDE_DATA(inode);
Trond Myklebust173912a2009-08-09 15:14:29 -04001494
1495 return cache_open(inode, filp, cd);
1496}
1497
1498static int cache_release_procfs(struct inode *inode, struct file *filp)
1499{
Al Virod9dda782013-03-31 18:16:14 -04001500 struct cache_detail *cd = PDE_DATA(inode);
Trond Myklebust173912a2009-08-09 15:14:29 -04001501
1502 return cache_release(inode, filp, cd);
1503}
1504
1505static const struct file_operations cache_file_operations_procfs = {
1506 .owner = THIS_MODULE,
1507 .llseek = no_llseek,
1508 .read = cache_read_procfs,
1509 .write = cache_write_procfs,
1510 .poll = cache_poll_procfs,
Frederic Weisbeckerd79b6f42010-03-30 07:27:50 +02001511 .unlocked_ioctl = cache_ioctl_procfs, /* for FIONREAD */
Trond Myklebust173912a2009-08-09 15:14:29 -04001512 .open = cache_open_procfs,
1513 .release = cache_release_procfs,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514};
Trond Myklebust173912a2009-08-09 15:14:29 -04001515
1516static int content_open_procfs(struct inode *inode, struct file *filp)
1517{
Al Virod9dda782013-03-31 18:16:14 -04001518 struct cache_detail *cd = PDE_DATA(inode);
Trond Myklebust173912a2009-08-09 15:14:29 -04001519
1520 return content_open(inode, filp, cd);
1521}
1522
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001523static int content_release_procfs(struct inode *inode, struct file *filp)
1524{
Al Virod9dda782013-03-31 18:16:14 -04001525 struct cache_detail *cd = PDE_DATA(inode);
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001526
1527 return content_release(inode, filp, cd);
1528}
1529
Trond Myklebust173912a2009-08-09 15:14:29 -04001530static const struct file_operations content_file_operations_procfs = {
1531 .open = content_open_procfs,
1532 .read = seq_read,
1533 .llseek = seq_lseek,
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001534 .release = content_release_procfs,
Trond Myklebust173912a2009-08-09 15:14:29 -04001535};
1536
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001537static int open_flush_procfs(struct inode *inode, struct file *filp)
1538{
Al Virod9dda782013-03-31 18:16:14 -04001539 struct cache_detail *cd = PDE_DATA(inode);
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001540
1541 return open_flush(inode, filp, cd);
1542}
1543
1544static int release_flush_procfs(struct inode *inode, struct file *filp)
1545{
Al Virod9dda782013-03-31 18:16:14 -04001546 struct cache_detail *cd = PDE_DATA(inode);
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001547
1548 return release_flush(inode, filp, cd);
1549}
1550
Trond Myklebust173912a2009-08-09 15:14:29 -04001551static ssize_t read_flush_procfs(struct file *filp, char __user *buf,
1552 size_t count, loff_t *ppos)
1553{
Al Virod9dda782013-03-31 18:16:14 -04001554 struct cache_detail *cd = PDE_DATA(file_inode(filp));
Trond Myklebust173912a2009-08-09 15:14:29 -04001555
1556 return read_flush(filp, buf, count, ppos, cd);
1557}
1558
1559static ssize_t write_flush_procfs(struct file *filp,
1560 const char __user *buf,
1561 size_t count, loff_t *ppos)
1562{
Al Virod9dda782013-03-31 18:16:14 -04001563 struct cache_detail *cd = PDE_DATA(file_inode(filp));
Trond Myklebust173912a2009-08-09 15:14:29 -04001564
1565 return write_flush(filp, buf, count, ppos, cd);
1566}
1567
1568static const struct file_operations cache_flush_operations_procfs = {
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001569 .open = open_flush_procfs,
Trond Myklebust173912a2009-08-09 15:14:29 -04001570 .read = read_flush_procfs,
1571 .write = write_flush_procfs,
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001572 .release = release_flush_procfs,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001573 .llseek = no_llseek,
Trond Myklebust173912a2009-08-09 15:14:29 -04001574};
1575
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001576static void remove_cache_proc_entries(struct cache_detail *cd, struct net *net)
Trond Myklebust173912a2009-08-09 15:14:29 -04001577{
Pavel Emelyanov4f42d0d2010-09-27 14:01:58 +04001578 struct sunrpc_net *sn;
1579
Trond Myklebust173912a2009-08-09 15:14:29 -04001580 if (cd->u.procfs.proc_ent == NULL)
1581 return;
1582 if (cd->u.procfs.flush_ent)
1583 remove_proc_entry("flush", cd->u.procfs.proc_ent);
1584 if (cd->u.procfs.channel_ent)
1585 remove_proc_entry("channel", cd->u.procfs.proc_ent);
1586 if (cd->u.procfs.content_ent)
1587 remove_proc_entry("content", cd->u.procfs.proc_ent);
1588 cd->u.procfs.proc_ent = NULL;
Pavel Emelyanov4f42d0d2010-09-27 14:01:58 +04001589 sn = net_generic(net, sunrpc_net_id);
1590 remove_proc_entry(cd->name, sn->proc_net_rpc);
Trond Myklebust173912a2009-08-09 15:14:29 -04001591}
1592
1593#ifdef CONFIG_PROC_FS
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001594static int create_cache_proc_entries(struct cache_detail *cd, struct net *net)
Trond Myklebust173912a2009-08-09 15:14:29 -04001595{
1596 struct proc_dir_entry *p;
Pavel Emelyanov4f42d0d2010-09-27 14:01:58 +04001597 struct sunrpc_net *sn;
Trond Myklebust173912a2009-08-09 15:14:29 -04001598
Pavel Emelyanov4f42d0d2010-09-27 14:01:58 +04001599 sn = net_generic(net, sunrpc_net_id);
1600 cd->u.procfs.proc_ent = proc_mkdir(cd->name, sn->proc_net_rpc);
Trond Myklebust173912a2009-08-09 15:14:29 -04001601 if (cd->u.procfs.proc_ent == NULL)
1602 goto out_nomem;
1603 cd->u.procfs.channel_ent = NULL;
1604 cd->u.procfs.content_ent = NULL;
1605
1606 p = proc_create_data("flush", S_IFREG|S_IRUSR|S_IWUSR,
1607 cd->u.procfs.proc_ent,
1608 &cache_flush_operations_procfs, cd);
1609 cd->u.procfs.flush_ent = p;
1610 if (p == NULL)
1611 goto out_nomem;
1612
Stanislav Kinsbursky2d438332013-02-04 14:02:50 +03001613 if (cd->cache_request || cd->cache_parse) {
Trond Myklebust173912a2009-08-09 15:14:29 -04001614 p = proc_create_data("channel", S_IFREG|S_IRUSR|S_IWUSR,
1615 cd->u.procfs.proc_ent,
1616 &cache_file_operations_procfs, cd);
1617 cd->u.procfs.channel_ent = p;
1618 if (p == NULL)
1619 goto out_nomem;
1620 }
1621 if (cd->cache_show) {
Yanchuan Nianec168672013-01-04 19:45:35 +08001622 p = proc_create_data("content", S_IFREG|S_IRUSR,
Trond Myklebust173912a2009-08-09 15:14:29 -04001623 cd->u.procfs.proc_ent,
1624 &content_file_operations_procfs, cd);
1625 cd->u.procfs.content_ent = p;
1626 if (p == NULL)
1627 goto out_nomem;
1628 }
1629 return 0;
1630out_nomem:
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001631 remove_cache_proc_entries(cd, net);
Trond Myklebust173912a2009-08-09 15:14:29 -04001632 return -ENOMEM;
1633}
1634#else /* CONFIG_PROC_FS */
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001635static int create_cache_proc_entries(struct cache_detail *cd, struct net *net)
Trond Myklebust173912a2009-08-09 15:14:29 -04001636{
1637 return 0;
1638}
1639#endif
1640
Artem Bityutskiy8eab9452010-07-01 18:05:56 +03001641void __init cache_initialize(void)
1642{
Tejun Heo203b42f2012-08-21 13:18:23 -07001643 INIT_DEFERRABLE_WORK(&cache_cleaner, do_cache_clean);
Artem Bityutskiy8eab9452010-07-01 18:05:56 +03001644}
1645
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001646int cache_register_net(struct cache_detail *cd, struct net *net)
Trond Myklebust173912a2009-08-09 15:14:29 -04001647{
1648 int ret;
1649
1650 sunrpc_init_cache_detail(cd);
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001651 ret = create_cache_proc_entries(cd, net);
Trond Myklebust173912a2009-08-09 15:14:29 -04001652 if (ret)
1653 sunrpc_destroy_cache_detail(cd);
1654 return ret;
1655}
Stanislav Kinsburskyf5c8593b2011-12-07 12:57:56 +03001656EXPORT_SYMBOL_GPL(cache_register_net);
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001657
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001658void cache_unregister_net(struct cache_detail *cd, struct net *net)
1659{
1660 remove_cache_proc_entries(cd, net);
1661 sunrpc_destroy_cache_detail(cd);
1662}
Stanislav Kinsburskyf5c8593b2011-12-07 12:57:56 +03001663EXPORT_SYMBOL_GPL(cache_unregister_net);
Pavel Emelyanov593ce162010-09-27 14:00:15 +04001664
Stanislav Kinsbursky0a402d52012-01-19 21:42:21 +04001665struct cache_detail *cache_create_net(struct cache_detail *tmpl, struct net *net)
Trond Myklebust173912a2009-08-09 15:14:29 -04001666{
Stanislav Kinsbursky0a402d52012-01-19 21:42:21 +04001667 struct cache_detail *cd;
1668
1669 cd = kmemdup(tmpl, sizeof(struct cache_detail), GFP_KERNEL);
1670 if (cd == NULL)
1671 return ERR_PTR(-ENOMEM);
1672
1673 cd->hash_table = kzalloc(cd->hash_size * sizeof(struct cache_head *),
1674 GFP_KERNEL);
1675 if (cd->hash_table == NULL) {
1676 kfree(cd);
1677 return ERR_PTR(-ENOMEM);
1678 }
1679 cd->net = net;
1680 return cd;
Trond Myklebust173912a2009-08-09 15:14:29 -04001681}
Stanislav Kinsbursky0a402d52012-01-19 21:42:21 +04001682EXPORT_SYMBOL_GPL(cache_create_net);
1683
1684void cache_destroy_net(struct cache_detail *cd, struct net *net)
1685{
1686 kfree(cd->hash_table);
1687 kfree(cd);
1688}
1689EXPORT_SYMBOL_GPL(cache_destroy_net);
Trond Myklebust8854e822009-08-09 15:14:30 -04001690
1691static ssize_t cache_read_pipefs(struct file *filp, char __user *buf,
1692 size_t count, loff_t *ppos)
1693{
Al Viro496ad9a2013-01-23 17:07:38 -05001694 struct cache_detail *cd = RPC_I(file_inode(filp))->private;
Trond Myklebust8854e822009-08-09 15:14:30 -04001695
1696 return cache_read(filp, buf, count, ppos, cd);
1697}
1698
1699static ssize_t cache_write_pipefs(struct file *filp, const char __user *buf,
1700 size_t count, loff_t *ppos)
1701{
Al Viro496ad9a2013-01-23 17:07:38 -05001702 struct cache_detail *cd = RPC_I(file_inode(filp))->private;
Trond Myklebust8854e822009-08-09 15:14:30 -04001703
1704 return cache_write(filp, buf, count, ppos, cd);
1705}
1706
1707static unsigned int cache_poll_pipefs(struct file *filp, poll_table *wait)
1708{
Al Viro496ad9a2013-01-23 17:07:38 -05001709 struct cache_detail *cd = RPC_I(file_inode(filp))->private;
Trond Myklebust8854e822009-08-09 15:14:30 -04001710
1711 return cache_poll(filp, wait, cd);
1712}
1713
Frederic Weisbecker9918ff22010-05-19 15:08:17 +02001714static long cache_ioctl_pipefs(struct file *filp,
Trond Myklebust8854e822009-08-09 15:14:30 -04001715 unsigned int cmd, unsigned long arg)
1716{
Al Viro496ad9a2013-01-23 17:07:38 -05001717 struct inode *inode = file_inode(filp);
Trond Myklebust8854e822009-08-09 15:14:30 -04001718 struct cache_detail *cd = RPC_I(inode)->private;
1719
Arnd Bergmanna6f8dbc2010-10-04 21:18:23 +02001720 return cache_ioctl(inode, filp, cmd, arg, cd);
Trond Myklebust8854e822009-08-09 15:14:30 -04001721}
1722
1723static int cache_open_pipefs(struct inode *inode, struct file *filp)
1724{
1725 struct cache_detail *cd = RPC_I(inode)->private;
1726
1727 return cache_open(inode, filp, cd);
1728}
1729
1730static int cache_release_pipefs(struct inode *inode, struct file *filp)
1731{
1732 struct cache_detail *cd = RPC_I(inode)->private;
1733
1734 return cache_release(inode, filp, cd);
1735}
1736
1737const struct file_operations cache_file_operations_pipefs = {
1738 .owner = THIS_MODULE,
1739 .llseek = no_llseek,
1740 .read = cache_read_pipefs,
1741 .write = cache_write_pipefs,
1742 .poll = cache_poll_pipefs,
Frederic Weisbecker9918ff22010-05-19 15:08:17 +02001743 .unlocked_ioctl = cache_ioctl_pipefs, /* for FIONREAD */
Trond Myklebust8854e822009-08-09 15:14:30 -04001744 .open = cache_open_pipefs,
1745 .release = cache_release_pipefs,
1746};
1747
1748static int content_open_pipefs(struct inode *inode, struct file *filp)
1749{
1750 struct cache_detail *cd = RPC_I(inode)->private;
1751
1752 return content_open(inode, filp, cd);
1753}
1754
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001755static int content_release_pipefs(struct inode *inode, struct file *filp)
1756{
1757 struct cache_detail *cd = RPC_I(inode)->private;
1758
1759 return content_release(inode, filp, cd);
1760}
1761
Trond Myklebust8854e822009-08-09 15:14:30 -04001762const struct file_operations content_file_operations_pipefs = {
1763 .open = content_open_pipefs,
1764 .read = seq_read,
1765 .llseek = seq_lseek,
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001766 .release = content_release_pipefs,
Trond Myklebust8854e822009-08-09 15:14:30 -04001767};
1768
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001769static int open_flush_pipefs(struct inode *inode, struct file *filp)
1770{
1771 struct cache_detail *cd = RPC_I(inode)->private;
1772
1773 return open_flush(inode, filp, cd);
1774}
1775
1776static int release_flush_pipefs(struct inode *inode, struct file *filp)
1777{
1778 struct cache_detail *cd = RPC_I(inode)->private;
1779
1780 return release_flush(inode, filp, cd);
1781}
1782
Trond Myklebust8854e822009-08-09 15:14:30 -04001783static ssize_t read_flush_pipefs(struct file *filp, char __user *buf,
1784 size_t count, loff_t *ppos)
1785{
Al Viro496ad9a2013-01-23 17:07:38 -05001786 struct cache_detail *cd = RPC_I(file_inode(filp))->private;
Trond Myklebust8854e822009-08-09 15:14:30 -04001787
1788 return read_flush(filp, buf, count, ppos, cd);
1789}
1790
1791static ssize_t write_flush_pipefs(struct file *filp,
1792 const char __user *buf,
1793 size_t count, loff_t *ppos)
1794{
Al Viro496ad9a2013-01-23 17:07:38 -05001795 struct cache_detail *cd = RPC_I(file_inode(filp))->private;
Trond Myklebust8854e822009-08-09 15:14:30 -04001796
1797 return write_flush(filp, buf, count, ppos, cd);
1798}
1799
1800const struct file_operations cache_flush_operations_pipefs = {
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001801 .open = open_flush_pipefs,
Trond Myklebust8854e822009-08-09 15:14:30 -04001802 .read = read_flush_pipefs,
1803 .write = write_flush_pipefs,
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001804 .release = release_flush_pipefs,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001805 .llseek = no_llseek,
Trond Myklebust8854e822009-08-09 15:14:30 -04001806};
1807
1808int sunrpc_cache_register_pipefs(struct dentry *parent,
Al Viro64f14262011-07-25 00:35:13 -04001809 const char *name, umode_t umode,
Trond Myklebust8854e822009-08-09 15:14:30 -04001810 struct cache_detail *cd)
1811{
Al Viroa95e6912013-07-14 16:43:54 +04001812 struct dentry *dir = rpc_create_cache_dir(parent, name, umode, cd);
1813 if (IS_ERR(dir))
1814 return PTR_ERR(dir);
1815 cd->u.pipefs.dir = dir;
1816 return 0;
Trond Myklebust8854e822009-08-09 15:14:30 -04001817}
1818EXPORT_SYMBOL_GPL(sunrpc_cache_register_pipefs);
1819
1820void sunrpc_cache_unregister_pipefs(struct cache_detail *cd)
1821{
1822 rpc_remove_cache_dir(cd->u.pipefs.dir);
1823 cd->u.pipefs.dir = NULL;
Trond Myklebust8854e822009-08-09 15:14:30 -04001824}
1825EXPORT_SYMBOL_GPL(sunrpc_cache_unregister_pipefs);
1826