blob: 9826c5ceb9950158e961fd608f129b6adf554d0e [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>
23#include <asm/uaccess.h>
24#include <linux/poll.h>
25#include <linux/seq_file.h>
26#include <linux/proc_fs.h>
27#include <linux/net.h>
28#include <linux/workqueue.h>
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -080029#include <linux/mutex.h>
Trond Myklebustda770052009-08-09 15:14:28 -040030#include <linux/pagemap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <asm/ioctls.h>
32#include <linux/sunrpc/types.h>
33#include <linux/sunrpc/cache.h>
34#include <linux/sunrpc/stats.h>
Trond Myklebust8854e822009-08-09 15:14:30 -040035#include <linux/sunrpc/rpc_pipe_fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37#define RPCDBG_FACILITY RPCDBG_CACHE
38
J.Bruce Fieldse0bb89e2006-12-13 00:35:25 -080039static int cache_defer_req(struct cache_req *req, struct cache_head *item);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040static void cache_revisit_request(struct cache_head *item);
41
Adrian Bunk74cae612006-03-27 01:15:10 -080042static void cache_init(struct cache_head *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -070043{
44 time_t now = get_seconds();
45 h->next = NULL;
46 h->flags = 0;
NeilBrownbaab9352006-03-27 01:15:09 -080047 kref_init(&h->ref);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 h->expiry_time = now + CACHE_NEW_EXPIRY;
49 h->last_refresh = now;
50}
51
NeilBrown2f50d8b2010-02-03 17:31:31 +110052static inline int cache_is_expired(struct cache_detail *detail, struct cache_head *h)
53{
54 return (h->expiry_time < get_seconds()) ||
55 (detail->flush_time > h->last_refresh);
56}
57
NeilBrown15a5f6b2006-03-27 01:15:02 -080058struct cache_head *sunrpc_cache_lookup(struct cache_detail *detail,
59 struct cache_head *key, int hash)
60{
61 struct cache_head **head, **hp;
62 struct cache_head *new = NULL;
63
64 head = &detail->hash_table[hash];
65
66 read_lock(&detail->hash_lock);
67
68 for (hp=head; *hp != NULL ; hp = &(*hp)->next) {
69 struct cache_head *tmp = *hp;
70 if (detail->match(tmp, key)) {
71 cache_get(tmp);
72 read_unlock(&detail->hash_lock);
73 return tmp;
74 }
75 }
76 read_unlock(&detail->hash_lock);
77 /* Didn't find anything, insert an empty entry */
78
79 new = detail->alloc();
80 if (!new)
81 return NULL;
Neil Brown2f349312006-08-05 12:14:29 -070082 /* must fully initialise 'new', else
83 * we might get lose if we need to
84 * cache_put it soon.
85 */
NeilBrown15a5f6b2006-03-27 01:15:02 -080086 cache_init(new);
Neil Brown2f349312006-08-05 12:14:29 -070087 detail->init(new, key);
NeilBrown15a5f6b2006-03-27 01:15:02 -080088
89 write_lock(&detail->hash_lock);
90
91 /* check if entry appeared while we slept */
92 for (hp=head; *hp != NULL ; hp = &(*hp)->next) {
93 struct cache_head *tmp = *hp;
94 if (detail->match(tmp, key)) {
95 cache_get(tmp);
96 write_unlock(&detail->hash_lock);
NeilBrownbaab9352006-03-27 01:15:09 -080097 cache_put(new, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -080098 return tmp;
99 }
100 }
NeilBrown15a5f6b2006-03-27 01:15:02 -0800101 new->next = *head;
102 *head = new;
103 detail->entries++;
104 cache_get(new);
105 write_unlock(&detail->hash_lock);
106
107 return new;
108}
Trond Myklebust24c37672008-12-23 16:30:12 -0500109EXPORT_SYMBOL_GPL(sunrpc_cache_lookup);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800110
NeilBrownebd0cb12006-03-27 01:15:08 -0800111
NeilBrownf866a812009-08-04 15:22:38 +1000112static void cache_dequeue(struct cache_detail *detail, struct cache_head *ch);
NeilBrownebd0cb12006-03-27 01:15:08 -0800113
NeilBrown908329f2009-09-09 16:32:54 +1000114static void cache_fresh_locked(struct cache_head *head, time_t expiry)
NeilBrownebd0cb12006-03-27 01:15:08 -0800115{
116 head->expiry_time = expiry;
117 head->last_refresh = get_seconds();
NeilBrown908329f2009-09-09 16:32:54 +1000118 set_bit(CACHE_VALID, &head->flags);
NeilBrownebd0cb12006-03-27 01:15:08 -0800119}
120
121static void cache_fresh_unlocked(struct cache_head *head,
NeilBrown908329f2009-09-09 16:32:54 +1000122 struct cache_detail *detail)
NeilBrownebd0cb12006-03-27 01:15:08 -0800123{
NeilBrownebd0cb12006-03-27 01:15:08 -0800124 if (test_and_clear_bit(CACHE_PENDING, &head->flags)) {
125 cache_revisit_request(head);
NeilBrownf866a812009-08-04 15:22:38 +1000126 cache_dequeue(detail, head);
NeilBrownebd0cb12006-03-27 01:15:08 -0800127 }
128}
129
NeilBrown15a5f6b2006-03-27 01:15:02 -0800130struct cache_head *sunrpc_cache_update(struct cache_detail *detail,
131 struct cache_head *new, struct cache_head *old, int hash)
132{
133 /* The 'old' entry is to be replaced by 'new'.
134 * If 'old' is not VALID, we update it directly,
135 * otherwise we need to replace it
136 */
137 struct cache_head **head;
138 struct cache_head *tmp;
139
140 if (!test_bit(CACHE_VALID, &old->flags)) {
141 write_lock(&detail->hash_lock);
142 if (!test_bit(CACHE_VALID, &old->flags)) {
143 if (test_bit(CACHE_NEGATIVE, &new->flags))
144 set_bit(CACHE_NEGATIVE, &old->flags);
145 else
146 detail->update(old, new);
NeilBrown908329f2009-09-09 16:32:54 +1000147 cache_fresh_locked(old, new->expiry_time);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800148 write_unlock(&detail->hash_lock);
NeilBrown908329f2009-09-09 16:32:54 +1000149 cache_fresh_unlocked(old, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800150 return old;
151 }
152 write_unlock(&detail->hash_lock);
153 }
154 /* We need to insert a new entry */
155 tmp = detail->alloc();
156 if (!tmp) {
NeilBrownbaab9352006-03-27 01:15:09 -0800157 cache_put(old, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800158 return NULL;
159 }
160 cache_init(tmp);
161 detail->init(tmp, old);
162 head = &detail->hash_table[hash];
163
164 write_lock(&detail->hash_lock);
165 if (test_bit(CACHE_NEGATIVE, &new->flags))
166 set_bit(CACHE_NEGATIVE, &tmp->flags);
167 else
168 detail->update(tmp, new);
169 tmp->next = *head;
170 *head = tmp;
NeilBrownf2d39582006-05-22 22:35:25 -0700171 detail->entries++;
NeilBrown15a5f6b2006-03-27 01:15:02 -0800172 cache_get(tmp);
NeilBrown908329f2009-09-09 16:32:54 +1000173 cache_fresh_locked(tmp, new->expiry_time);
NeilBrownebd0cb12006-03-27 01:15:08 -0800174 cache_fresh_locked(old, 0);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800175 write_unlock(&detail->hash_lock);
NeilBrown908329f2009-09-09 16:32:54 +1000176 cache_fresh_unlocked(tmp, detail);
177 cache_fresh_unlocked(old, detail);
NeilBrownbaab9352006-03-27 01:15:09 -0800178 cache_put(old, detail);
NeilBrown15a5f6b2006-03-27 01:15:02 -0800179 return tmp;
180}
Trond Myklebust24c37672008-12-23 16:30:12 -0500181EXPORT_SYMBOL_GPL(sunrpc_cache_update);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
Trond Myklebustbc74b4f2009-08-09 15:14:29 -0400183static int cache_make_upcall(struct cache_detail *cd, struct cache_head *h)
184{
185 if (!cd->cache_upcall)
186 return -EINVAL;
187 return cd->cache_upcall(cd, h);
188}
NeilBrown989a19b2009-08-04 15:22:38 +1000189
190static inline int cache_is_valid(struct cache_detail *detail, struct cache_head *h)
191{
192 if (!test_bit(CACHE_VALID, &h->flags) ||
NeilBrown2f50d8b2010-02-03 17:31:31 +1100193 cache_is_expired(detail, h))
NeilBrown989a19b2009-08-04 15:22:38 +1000194 return -EAGAIN;
195 else {
196 /* entry is valid */
197 if (test_bit(CACHE_NEGATIVE, &h->flags))
198 return -ENOENT;
199 else
200 return 0;
201 }
202}
J. Bruce Fieldse9dc1222009-08-21 11:27:29 -0400203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204/*
205 * This is the generic cache management routine for all
206 * the authentication caches.
207 * It checks the currency of a cache item and will (later)
208 * initiate an upcall to fill it if needed.
209 *
210 *
211 * Returns 0 if the cache_head can be used, or cache_puts it and returns
NeilBrown989a19b2009-08-04 15:22:38 +1000212 * -EAGAIN if upcall is pending and request has been queued
213 * -ETIMEDOUT if upcall failed or request could not be queue or
214 * upcall completed but item is still invalid (implying that
215 * the cache item has been replaced with a newer one).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 * -ENOENT if cache entry was negative
217 */
218int cache_check(struct cache_detail *detail,
219 struct cache_head *h, struct cache_req *rqstp)
220{
221 int rv;
222 long refresh_age, age;
223
224 /* First decide return status as best we can */
NeilBrown989a19b2009-08-04 15:22:38 +1000225 rv = cache_is_valid(detail, h);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
227 /* now see if we want to start an upcall */
228 refresh_age = (h->expiry_time - h->last_refresh);
229 age = get_seconds() - h->last_refresh;
230
231 if (rqstp == NULL) {
232 if (rv == -EAGAIN)
233 rv = -ENOENT;
234 } else if (rv == -EAGAIN || age > refresh_age/2) {
Chuck Lever46121cf2007-01-31 12:14:08 -0500235 dprintk("RPC: Want update, refage=%ld, age=%ld\n",
236 refresh_age, age);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 if (!test_and_set_bit(CACHE_PENDING, &h->flags)) {
238 switch (cache_make_upcall(detail, h)) {
239 case -EINVAL:
240 clear_bit(CACHE_PENDING, &h->flags);
NeilBrown5c4d2632009-08-04 15:22:38 +1000241 cache_revisit_request(h);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 if (rv == -EAGAIN) {
243 set_bit(CACHE_NEGATIVE, &h->flags);
NeilBrown908329f2009-09-09 16:32:54 +1000244 cache_fresh_locked(h, get_seconds()+CACHE_NEW_EXPIRY);
245 cache_fresh_unlocked(h, detail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 rv = -ENOENT;
247 }
248 break;
249
250 case -EAGAIN:
251 clear_bit(CACHE_PENDING, &h->flags);
252 cache_revisit_request(h);
253 break;
254 }
255 }
256 }
257
NeilBrown989a19b2009-08-04 15:22:38 +1000258 if (rv == -EAGAIN) {
NeilBrown9e4c6372009-09-09 16:32:54 +1000259 if (cache_defer_req(rqstp, h) < 0) {
NeilBrown989a19b2009-08-04 15:22:38 +1000260 /* Request is not deferred */
261 rv = cache_is_valid(detail, h);
262 if (rv == -EAGAIN)
263 rv = -ETIMEDOUT;
264 }
265 }
NeilBrown4013ede2006-03-27 01:15:07 -0800266 if (rv)
NeilBrownbaab9352006-03-27 01:15:09 -0800267 cache_put(h, detail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 return rv;
269}
Trond Myklebust24c37672008-12-23 16:30:12 -0500270EXPORT_SYMBOL_GPL(cache_check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272/*
273 * caches need to be periodically cleaned.
274 * For this we maintain a list of cache_detail and
275 * a current pointer into that list and into the table
276 * for that entry.
277 *
278 * Each time clean_cache is called it finds the next non-empty entry
279 * in the current table and walks the list in that entry
280 * looking for entries that can be removed.
281 *
282 * An entry gets removed if:
283 * - The expiry is before current time
284 * - The last_refresh time is before the flush_time for that cache
285 *
286 * later we might drop old entries with non-NEVER expiry if that table
287 * is getting 'full' for some definition of 'full'
288 *
289 * The question of "how often to scan a table" is an interesting one
290 * and is answered in part by the use of the "nextcheck" field in the
291 * cache_detail.
292 * When a scan of a table begins, the nextcheck field is set to a time
293 * that is well into the future.
294 * While scanning, if an expiry time is found that is earlier than the
295 * current nextcheck time, nextcheck is set to that expiry time.
296 * If the flush_time is ever set to a time earlier than the nextcheck
297 * time, the nextcheck time is then set to that flush_time.
298 *
299 * A table is then only scanned if the current time is at least
300 * the nextcheck time.
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800301 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 */
303
304static LIST_HEAD(cache_list);
305static DEFINE_SPINLOCK(cache_list_lock);
306static struct cache_detail *current_detail;
307static int current_index;
308
David Howells65f27f32006-11-22 14:55:48 +0000309static void do_cache_clean(struct work_struct *work);
310static DECLARE_DELAYED_WORK(cache_cleaner, do_cache_clean);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
Trond Myklebust5b7a1b92009-08-09 15:14:27 -0400312static void sunrpc_init_cache_detail(struct cache_detail *cd)
J. Bruce Fieldsffe93862007-11-12 17:04:29 -0500313{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 rwlock_init(&cd->hash_lock);
315 INIT_LIST_HEAD(&cd->queue);
316 spin_lock(&cache_list_lock);
317 cd->nextcheck = 0;
318 cd->entries = 0;
319 atomic_set(&cd->readers, 0);
320 cd->last_close = 0;
321 cd->last_warn = -1;
322 list_add(&cd->others, &cache_list);
323 spin_unlock(&cache_list_lock);
324
325 /* start the cleaning process */
David Howells52bad642006-11-22 14:54:01 +0000326 schedule_delayed_work(&cache_cleaner, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327}
328
Trond Myklebust5b7a1b92009-08-09 15:14:27 -0400329static void sunrpc_destroy_cache_detail(struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
331 cache_purge(cd);
332 spin_lock(&cache_list_lock);
333 write_lock(&cd->hash_lock);
334 if (cd->entries || atomic_read(&cd->inuse)) {
335 write_unlock(&cd->hash_lock);
336 spin_unlock(&cache_list_lock);
J. Bruce Fieldsdf95a9d2007-11-08 16:09:59 -0500337 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
339 if (current_detail == cd)
340 current_detail = NULL;
341 list_del_init(&cd->others);
342 write_unlock(&cd->hash_lock);
343 spin_unlock(&cache_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 if (list_empty(&cache_list)) {
345 /* module must be being unloaded so its safe to kill the worker */
Trond Myklebust4011cd92007-08-07 15:33:01 -0400346 cancel_delayed_work_sync(&cache_cleaner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 }
J. Bruce Fieldsdf95a9d2007-11-08 16:09:59 -0500348 return;
349out:
350 printk(KERN_ERR "nfsd: failed to unregister %s cache\n", cd->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
353/* clean cache tries to find something to clean
354 * and cleans it.
355 * It returns 1 if it cleaned something,
356 * 0 if it didn't find anything this time
357 * -1 if it fell off the end of the list.
358 */
359static int cache_clean(void)
360{
361 int rv = 0;
362 struct list_head *next;
363
364 spin_lock(&cache_list_lock);
365
366 /* find a suitable table if we don't already have one */
367 while (current_detail == NULL ||
368 current_index >= current_detail->hash_size) {
369 if (current_detail)
370 next = current_detail->others.next;
371 else
372 next = cache_list.next;
373 if (next == &cache_list) {
374 current_detail = NULL;
375 spin_unlock(&cache_list_lock);
376 return -1;
377 }
378 current_detail = list_entry(next, struct cache_detail, others);
379 if (current_detail->nextcheck > get_seconds())
380 current_index = current_detail->hash_size;
381 else {
382 current_index = 0;
383 current_detail->nextcheck = get_seconds()+30*60;
384 }
385 }
386
387 /* find a non-empty bucket in the table */
388 while (current_detail &&
389 current_index < current_detail->hash_size &&
390 current_detail->hash_table[current_index] == NULL)
391 current_index++;
392
393 /* find a cleanable entry in the bucket and clean it, or set to next bucket */
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 if (current_detail && current_index < current_detail->hash_size) {
396 struct cache_head *ch, **cp;
397 struct cache_detail *d;
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 write_lock(&current_detail->hash_lock);
400
401 /* Ok, now to clean this strand */
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 cp = & current_detail->hash_table[current_index];
NeilBrown3af49742010-02-03 17:31:31 +1100404 for (ch = *cp ; ch ; cp = & ch->next, ch = *cp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 if (current_detail->nextcheck > ch->expiry_time)
406 current_detail->nextcheck = ch->expiry_time+1;
NeilBrown2f50d8b2010-02-03 17:31:31 +1100407 if (!cache_is_expired(current_detail, ch))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 *cp = ch->next;
411 ch->next = NULL;
412 current_detail->entries--;
413 rv = 1;
NeilBrown3af49742010-02-03 17:31:31 +1100414 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 }
NeilBrown3af49742010-02-03 17:31:31 +1100416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 write_unlock(&current_detail->hash_lock);
418 d = current_detail;
419 if (!ch)
420 current_index ++;
421 spin_unlock(&cache_list_lock);
NeilBrown5c4d2632009-08-04 15:22:38 +1000422 if (ch) {
NeilBrown3af49742010-02-03 17:31:31 +1100423 if (test_and_clear_bit(CACHE_PENDING, &ch->flags))
424 cache_dequeue(current_detail, ch);
NeilBrown5c4d2632009-08-04 15:22:38 +1000425 cache_revisit_request(ch);
NeilBrownbaab9352006-03-27 01:15:09 -0800426 cache_put(ch, d);
NeilBrown5c4d2632009-08-04 15:22:38 +1000427 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 } else
429 spin_unlock(&cache_list_lock);
430
431 return rv;
432}
433
434/*
435 * We want to regularly clean the cache, so we need to schedule some work ...
436 */
David Howells65f27f32006-11-22 14:55:48 +0000437static void do_cache_clean(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 int delay = 5;
440 if (cache_clean() == -1)
Anton Blanchard6aad89c2009-06-10 12:52:21 -0700441 delay = round_jiffies_relative(30*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
443 if (list_empty(&cache_list))
444 delay = 0;
445
446 if (delay)
447 schedule_delayed_work(&cache_cleaner, delay);
448}
449
450
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800451/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 * Clean all caches promptly. This just calls cache_clean
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800453 * repeatedly until we are sure that every cache has had a chance to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 * be fully cleaned
455 */
456void cache_flush(void)
457{
458 while (cache_clean() != -1)
459 cond_resched();
460 while (cache_clean() != -1)
461 cond_resched();
462}
Trond Myklebust24c37672008-12-23 16:30:12 -0500463EXPORT_SYMBOL_GPL(cache_flush);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465void cache_purge(struct cache_detail *detail)
466{
467 detail->flush_time = LONG_MAX;
468 detail->nextcheck = get_seconds();
469 cache_flush();
470 detail->flush_time = 1;
471}
Trond Myklebust24c37672008-12-23 16:30:12 -0500472EXPORT_SYMBOL_GPL(cache_purge);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
474
475/*
476 * Deferral and Revisiting of Requests.
477 *
478 * If a cache lookup finds a pending entry, we
479 * need to defer the request and revisit it later.
480 * All deferred requests are stored in a hash table,
481 * indexed by "struct cache_head *".
482 * As it may be wasteful to store a whole request
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800483 * structure, we allow the request to provide a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 * deferred form, which must contain a
485 * 'struct cache_deferred_req'
486 * This cache_deferred_req contains a method to allow
487 * it to be revisited when cache info is available
488 */
489
490#define DFR_HASHSIZE (PAGE_SIZE/sizeof(struct list_head))
491#define DFR_HASH(item) ((((long)item)>>4 ^ (((long)item)>>13)) % DFR_HASHSIZE)
492
493#define DFR_MAX 300 /* ??? */
494
495static DEFINE_SPINLOCK(cache_defer_lock);
496static LIST_HEAD(cache_defer_list);
497static struct list_head cache_defer_hash[DFR_HASHSIZE];
498static int cache_defer_cnt;
499
J.Bruce Fieldse0bb89e2006-12-13 00:35:25 -0800500static int cache_defer_req(struct cache_req *req, struct cache_head *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
NeilBrowncd68c372009-09-09 16:32:54 +1000502 struct cache_deferred_req *dreq, *discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 int hash = DFR_HASH(item);
504
J.Bruce Fields01f3bd12006-12-13 00:35:26 -0800505 if (cache_defer_cnt >= DFR_MAX) {
506 /* too much in the cache, randomly drop this one,
507 * or continue and drop the oldest below
508 */
509 if (net_random()&1)
NeilBrown9e4c6372009-09-09 16:32:54 +1000510 return -ENOMEM;
J.Bruce Fields01f3bd12006-12-13 00:35:26 -0800511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 dreq = req->defer(req);
513 if (dreq == NULL)
NeilBrown9e4c6372009-09-09 16:32:54 +1000514 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
516 dreq->item = item;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
518 spin_lock(&cache_defer_lock);
519
520 list_add(&dreq->recent, &cache_defer_list);
521
522 if (cache_defer_hash[hash].next == NULL)
523 INIT_LIST_HEAD(&cache_defer_hash[hash]);
524 list_add(&dreq->hash, &cache_defer_hash[hash]);
525
526 /* it is in, now maybe clean up */
NeilBrowncd68c372009-09-09 16:32:54 +1000527 discard = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 if (++cache_defer_cnt > DFR_MAX) {
NeilBrowncd68c372009-09-09 16:32:54 +1000529 discard = list_entry(cache_defer_list.prev,
530 struct cache_deferred_req, recent);
531 list_del_init(&discard->recent);
532 list_del_init(&discard->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 cache_defer_cnt--;
534 }
535 spin_unlock(&cache_defer_lock);
536
NeilBrowncd68c372009-09-09 16:32:54 +1000537 if (discard)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 /* there was one too many */
NeilBrowncd68c372009-09-09 16:32:54 +1000539 discard->revisit(discard, 1);
540
NeilBrown4013ede2006-03-27 01:15:07 -0800541 if (!test_bit(CACHE_PENDING, &item->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 /* must have just been validated... */
543 cache_revisit_request(item);
NeilBrown9e4c6372009-09-09 16:32:54 +1000544 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 }
NeilBrown9e4c6372009-09-09 16:32:54 +1000546 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547}
548
549static void cache_revisit_request(struct cache_head *item)
550{
551 struct cache_deferred_req *dreq;
552 struct list_head pending;
553
554 struct list_head *lp;
555 int hash = DFR_HASH(item);
556
557 INIT_LIST_HEAD(&pending);
558 spin_lock(&cache_defer_lock);
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 lp = cache_defer_hash[hash].next;
561 if (lp) {
562 while (lp != &cache_defer_hash[hash]) {
563 dreq = list_entry(lp, struct cache_deferred_req, hash);
564 lp = lp->next;
565 if (dreq->item == item) {
NeilBrown67e73282009-09-09 16:32:54 +1000566 list_del_init(&dreq->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 list_move(&dreq->recent, &pending);
568 cache_defer_cnt--;
569 }
570 }
571 }
572 spin_unlock(&cache_defer_lock);
573
574 while (!list_empty(&pending)) {
575 dreq = list_entry(pending.next, struct cache_deferred_req, recent);
576 list_del_init(&dreq->recent);
577 dreq->revisit(dreq, 0);
578 }
579}
580
581void cache_clean_deferred(void *owner)
582{
583 struct cache_deferred_req *dreq, *tmp;
584 struct list_head pending;
585
586
587 INIT_LIST_HEAD(&pending);
588 spin_lock(&cache_defer_lock);
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 list_for_each_entry_safe(dreq, tmp, &cache_defer_list, recent) {
591 if (dreq->owner == owner) {
NeilBrown67e73282009-09-09 16:32:54 +1000592 list_del_init(&dreq->hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 list_move(&dreq->recent, &pending);
594 cache_defer_cnt--;
595 }
596 }
597 spin_unlock(&cache_defer_lock);
598
599 while (!list_empty(&pending)) {
600 dreq = list_entry(pending.next, struct cache_deferred_req, recent);
601 list_del_init(&dreq->recent);
602 dreq->revisit(dreq, 1);
603 }
604}
605
606/*
607 * communicate with user-space
608 *
J. Bruce Fieldsa490c682007-11-06 14:15:19 -0500609 * We have a magic /proc file - /proc/sunrpc/<cachename>/channel.
610 * On read, you get a full request, or block.
611 * On write, an update request is processed.
612 * Poll works if anything to read, and always allows write.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800614 * Implemented by linked list of requests. Each open file has
J. Bruce Fieldsa490c682007-11-06 14:15:19 -0500615 * a ->private that also exists in this list. New requests are added
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 * to the end and may wakeup and preceding readers.
617 * New readers are added to the head. If, on read, an item is found with
618 * CACHE_UPCALLING clear, we free it from the list.
619 *
620 */
621
622static DEFINE_SPINLOCK(queue_lock);
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -0800623static DEFINE_MUTEX(queue_io_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625struct cache_queue {
626 struct list_head list;
627 int reader; /* if 0, then request */
628};
629struct cache_request {
630 struct cache_queue q;
631 struct cache_head *item;
632 char * buf;
633 int len;
634 int readers;
635};
636struct cache_reader {
637 struct cache_queue q;
638 int offset; /* if non-0, we have a refcnt on next request */
639};
640
Trond Myklebust173912a2009-08-09 15:14:29 -0400641static ssize_t cache_read(struct file *filp, char __user *buf, size_t count,
642 loff_t *ppos, struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643{
644 struct cache_reader *rp = filp->private_data;
645 struct cache_request *rq;
Trond Myklebustda770052009-08-09 15:14:28 -0400646 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 int err;
648
649 if (count == 0)
650 return 0;
651
Trond Myklebustda770052009-08-09 15:14:28 -0400652 mutex_lock(&inode->i_mutex); /* protect against multiple concurrent
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 * readers on this file */
654 again:
655 spin_lock(&queue_lock);
656 /* need to find next request */
657 while (rp->q.list.next != &cd->queue &&
658 list_entry(rp->q.list.next, struct cache_queue, list)
659 ->reader) {
660 struct list_head *next = rp->q.list.next;
661 list_move(&rp->q.list, next);
662 }
663 if (rp->q.list.next == &cd->queue) {
664 spin_unlock(&queue_lock);
Trond Myklebustda770052009-08-09 15:14:28 -0400665 mutex_unlock(&inode->i_mutex);
Kris Katterjohn09a62662006-01-08 22:24:28 -0800666 BUG_ON(rp->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 return 0;
668 }
669 rq = container_of(rp->q.list.next, struct cache_request, q.list);
Kris Katterjohn09a62662006-01-08 22:24:28 -0800670 BUG_ON(rq->q.reader);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 if (rp->offset == 0)
672 rq->readers++;
673 spin_unlock(&queue_lock);
674
675 if (rp->offset == 0 && !test_bit(CACHE_PENDING, &rq->item->flags)) {
676 err = -EAGAIN;
677 spin_lock(&queue_lock);
678 list_move(&rp->q.list, &rq->q.list);
679 spin_unlock(&queue_lock);
680 } else {
681 if (rp->offset + count > rq->len)
682 count = rq->len - rp->offset;
683 err = -EFAULT;
684 if (copy_to_user(buf, rq->buf + rp->offset, count))
685 goto out;
686 rp->offset += count;
687 if (rp->offset >= rq->len) {
688 rp->offset = 0;
689 spin_lock(&queue_lock);
690 list_move(&rp->q.list, &rq->q.list);
691 spin_unlock(&queue_lock);
692 }
693 err = 0;
694 }
695 out:
696 if (rp->offset == 0) {
697 /* need to release rq */
698 spin_lock(&queue_lock);
699 rq->readers--;
700 if (rq->readers == 0 &&
701 !test_bit(CACHE_PENDING, &rq->item->flags)) {
702 list_del(&rq->q.list);
703 spin_unlock(&queue_lock);
NeilBrownbaab9352006-03-27 01:15:09 -0800704 cache_put(rq->item, cd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 kfree(rq->buf);
706 kfree(rq);
707 } else
708 spin_unlock(&queue_lock);
709 }
710 if (err == -EAGAIN)
711 goto again;
Trond Myklebustda770052009-08-09 15:14:28 -0400712 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 return err ? err : count;
714}
715
Trond Myklebustda770052009-08-09 15:14:28 -0400716static ssize_t cache_do_downcall(char *kaddr, const char __user *buf,
717 size_t count, struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718{
Trond Myklebustda770052009-08-09 15:14:28 -0400719 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
Trond Myklebustda770052009-08-09 15:14:28 -0400721 if (copy_from_user(kaddr, buf, count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 return -EFAULT;
Trond Myklebustda770052009-08-09 15:14:28 -0400723 kaddr[count] = '\0';
724 ret = cd->cache_parse(cd, kaddr, count);
725 if (!ret)
726 ret = count;
727 return ret;
728}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
Trond Myklebustda770052009-08-09 15:14:28 -0400730static ssize_t cache_slow_downcall(const char __user *buf,
731 size_t count, struct cache_detail *cd)
732{
733 static char write_buf[8192]; /* protected by queue_io_mutex */
734 ssize_t ret = -EINVAL;
735
736 if (count >= sizeof(write_buf))
737 goto out;
738 mutex_lock(&queue_io_mutex);
739 ret = cache_do_downcall(write_buf, buf, count, cd);
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -0800740 mutex_unlock(&queue_io_mutex);
Trond Myklebustda770052009-08-09 15:14:28 -0400741out:
742 return ret;
743}
744
745static ssize_t cache_downcall(struct address_space *mapping,
746 const char __user *buf,
747 size_t count, struct cache_detail *cd)
748{
749 struct page *page;
750 char *kaddr;
751 ssize_t ret = -ENOMEM;
752
753 if (count >= PAGE_CACHE_SIZE)
754 goto out_slow;
755
756 page = find_or_create_page(mapping, 0, GFP_KERNEL);
757 if (!page)
758 goto out_slow;
759
760 kaddr = kmap(page);
761 ret = cache_do_downcall(kaddr, buf, count, cd);
762 kunmap(page);
763 unlock_page(page);
764 page_cache_release(page);
765 return ret;
766out_slow:
767 return cache_slow_downcall(buf, count, cd);
768}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
Trond Myklebust173912a2009-08-09 15:14:29 -0400770static ssize_t cache_write(struct file *filp, const char __user *buf,
771 size_t count, loff_t *ppos,
772 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
Trond Myklebustda770052009-08-09 15:14:28 -0400774 struct address_space *mapping = filp->f_mapping;
775 struct inode *inode = filp->f_path.dentry->d_inode;
Trond Myklebustda770052009-08-09 15:14:28 -0400776 ssize_t ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Trond Myklebustda770052009-08-09 15:14:28 -0400778 if (!cd->cache_parse)
779 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Trond Myklebustda770052009-08-09 15:14:28 -0400781 mutex_lock(&inode->i_mutex);
782 ret = cache_downcall(mapping, buf, count, cd);
783 mutex_unlock(&inode->i_mutex);
784out:
785 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786}
787
788static DECLARE_WAIT_QUEUE_HEAD(queue_wait);
789
Trond Myklebust173912a2009-08-09 15:14:29 -0400790static unsigned int cache_poll(struct file *filp, poll_table *wait,
791 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792{
793 unsigned int mask;
794 struct cache_reader *rp = filp->private_data;
795 struct cache_queue *cq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
797 poll_wait(filp, &queue_wait, wait);
798
799 /* alway allow write */
800 mask = POLL_OUT | POLLWRNORM;
801
802 if (!rp)
803 return mask;
804
805 spin_lock(&queue_lock);
806
807 for (cq= &rp->q; &cq->list != &cd->queue;
808 cq = list_entry(cq->list.next, struct cache_queue, list))
809 if (!cq->reader) {
810 mask |= POLLIN | POLLRDNORM;
811 break;
812 }
813 spin_unlock(&queue_lock);
814 return mask;
815}
816
Trond Myklebust173912a2009-08-09 15:14:29 -0400817static int cache_ioctl(struct inode *ino, struct file *filp,
818 unsigned int cmd, unsigned long arg,
819 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820{
821 int len = 0;
822 struct cache_reader *rp = filp->private_data;
823 struct cache_queue *cq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 if (cmd != FIONREAD || !rp)
826 return -EINVAL;
827
828 spin_lock(&queue_lock);
829
830 /* only find the length remaining in current request,
831 * or the length of the next request
832 */
833 for (cq= &rp->q; &cq->list != &cd->queue;
834 cq = list_entry(cq->list.next, struct cache_queue, list))
835 if (!cq->reader) {
836 struct cache_request *cr =
837 container_of(cq, struct cache_request, q);
838 len = cr->len - rp->offset;
839 break;
840 }
841 spin_unlock(&queue_lock);
842
843 return put_user(len, (int __user *)arg);
844}
845
Trond Myklebust173912a2009-08-09 15:14:29 -0400846static int cache_open(struct inode *inode, struct file *filp,
847 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
849 struct cache_reader *rp = NULL;
850
Trond Myklebustf7e86ab2009-08-19 18:13:00 -0400851 if (!cd || !try_module_get(cd->owner))
852 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 nonseekable_open(inode, filp);
854 if (filp->f_mode & FMODE_READ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 rp = kmalloc(sizeof(*rp), GFP_KERNEL);
856 if (!rp)
857 return -ENOMEM;
858 rp->offset = 0;
859 rp->q.reader = 1;
860 atomic_inc(&cd->readers);
861 spin_lock(&queue_lock);
862 list_add(&rp->q.list, &cd->queue);
863 spin_unlock(&queue_lock);
864 }
865 filp->private_data = rp;
866 return 0;
867}
868
Trond Myklebust173912a2009-08-09 15:14:29 -0400869static int cache_release(struct inode *inode, struct file *filp,
870 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871{
872 struct cache_reader *rp = filp->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
874 if (rp) {
875 spin_lock(&queue_lock);
876 if (rp->offset) {
877 struct cache_queue *cq;
878 for (cq= &rp->q; &cq->list != &cd->queue;
879 cq = list_entry(cq->list.next, struct cache_queue, list))
880 if (!cq->reader) {
881 container_of(cq, struct cache_request, q)
882 ->readers--;
883 break;
884 }
885 rp->offset = 0;
886 }
887 list_del(&rp->q.list);
888 spin_unlock(&queue_lock);
889
890 filp->private_data = NULL;
891 kfree(rp);
892
893 cd->last_close = get_seconds();
894 atomic_dec(&cd->readers);
895 }
Trond Myklebustf7e86ab2009-08-19 18:13:00 -0400896 module_put(cd->owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 return 0;
898}
899
900
901
NeilBrownf866a812009-08-04 15:22:38 +1000902static void cache_dequeue(struct cache_detail *detail, struct cache_head *ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903{
904 struct cache_queue *cq;
905 spin_lock(&queue_lock);
906 list_for_each_entry(cq, &detail->queue, list)
907 if (!cq->reader) {
908 struct cache_request *cr = container_of(cq, struct cache_request, q);
909 if (cr->item != ch)
910 continue;
911 if (cr->readers != 0)
NeilBrown4013ede2006-03-27 01:15:07 -0800912 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 list_del(&cr->q.list);
914 spin_unlock(&queue_lock);
NeilBrownbaab9352006-03-27 01:15:09 -0800915 cache_put(cr->item, detail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 kfree(cr->buf);
917 kfree(cr);
918 return;
919 }
920 spin_unlock(&queue_lock);
921}
922
923/*
924 * Support routines for text-based upcalls.
925 * Fields are separated by spaces.
926 * Fields are either mangled to quote space tab newline slosh with slosh
927 * or a hexified with a leading \x
928 * Record is terminated with newline.
929 *
930 */
931
932void qword_add(char **bpp, int *lp, char *str)
933{
934 char *bp = *bpp;
935 int len = *lp;
936 char c;
937
938 if (len < 0) return;
939
940 while ((c=*str++) && len)
941 switch(c) {
942 case ' ':
943 case '\t':
944 case '\n':
945 case '\\':
946 if (len >= 4) {
947 *bp++ = '\\';
948 *bp++ = '0' + ((c & 0300)>>6);
949 *bp++ = '0' + ((c & 0070)>>3);
950 *bp++ = '0' + ((c & 0007)>>0);
951 }
952 len -= 4;
953 break;
954 default:
955 *bp++ = c;
956 len--;
957 }
958 if (c || len <1) len = -1;
959 else {
960 *bp++ = ' ';
961 len--;
962 }
963 *bpp = bp;
964 *lp = len;
965}
Trond Myklebust24c37672008-12-23 16:30:12 -0500966EXPORT_SYMBOL_GPL(qword_add);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
968void qword_addhex(char **bpp, int *lp, char *buf, int blen)
969{
970 char *bp = *bpp;
971 int len = *lp;
972
973 if (len < 0) return;
974
975 if (len > 2) {
976 *bp++ = '\\';
977 *bp++ = 'x';
978 len -= 2;
979 while (blen && len >= 2) {
980 unsigned char c = *buf++;
981 *bp++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
982 *bp++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
983 len -= 2;
984 blen--;
985 }
986 }
987 if (blen || len<1) len = -1;
988 else {
989 *bp++ = ' ';
990 len--;
991 }
992 *bpp = bp;
993 *lp = len;
994}
Trond Myklebust24c37672008-12-23 16:30:12 -0500995EXPORT_SYMBOL_GPL(qword_addhex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996
997static void warn_no_listener(struct cache_detail *detail)
998{
999 if (detail->last_warn != detail->last_close) {
1000 detail->last_warn = detail->last_close;
1001 if (detail->warn_no_listener)
Trond Myklebust2da8ca22009-08-09 15:14:26 -04001002 detail->warn_no_listener(detail, detail->last_close != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 }
1004}
1005
1006/*
Trond Myklebustbc74b4f2009-08-09 15:14:29 -04001007 * register an upcall request to user-space and queue it up for read() by the
1008 * upcall daemon.
1009 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 * Each request is at most one page long.
1011 */
Trond Myklebustbc74b4f2009-08-09 15:14:29 -04001012int sunrpc_cache_pipe_upcall(struct cache_detail *detail, struct cache_head *h,
1013 void (*cache_request)(struct cache_detail *,
1014 struct cache_head *,
1015 char **,
1016 int *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017{
1018
1019 char *buf;
1020 struct cache_request *crq;
1021 char *bp;
1022 int len;
1023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 if (atomic_read(&detail->readers) == 0 &&
1025 detail->last_close < get_seconds() - 30) {
1026 warn_no_listener(detail);
1027 return -EINVAL;
1028 }
1029
1030 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1031 if (!buf)
1032 return -EAGAIN;
1033
1034 crq = kmalloc(sizeof (*crq), GFP_KERNEL);
1035 if (!crq) {
1036 kfree(buf);
1037 return -EAGAIN;
1038 }
1039
1040 bp = buf; len = PAGE_SIZE;
1041
Trond Myklebustbc74b4f2009-08-09 15:14:29 -04001042 cache_request(detail, h, &bp, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
1044 if (len < 0) {
1045 kfree(buf);
1046 kfree(crq);
1047 return -EAGAIN;
1048 }
1049 crq->q.reader = 0;
1050 crq->item = cache_get(h);
1051 crq->buf = buf;
1052 crq->len = PAGE_SIZE - len;
1053 crq->readers = 0;
1054 spin_lock(&queue_lock);
1055 list_add_tail(&crq->q.list, &detail->queue);
1056 spin_unlock(&queue_lock);
1057 wake_up(&queue_wait);
1058 return 0;
1059}
Trond Myklebustbc74b4f2009-08-09 15:14:29 -04001060EXPORT_SYMBOL_GPL(sunrpc_cache_pipe_upcall);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
1062/*
1063 * parse a message from user-space and pass it
1064 * to an appropriate cache
1065 * Messages are, like requests, separated into fields by
1066 * spaces and dequotes as \xHEXSTRING or embedded \nnn octal
1067 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001068 * Message is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 * reply cachename expiry key ... content....
1070 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001071 * key and content are both parsed by cache
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 */
1073
1074#define isodigit(c) (isdigit(c) && c <= '7')
1075int qword_get(char **bpp, char *dest, int bufsize)
1076{
1077 /* return bytes copied, or -1 on error */
1078 char *bp = *bpp;
1079 int len = 0;
1080
1081 while (*bp == ' ') bp++;
1082
1083 if (bp[0] == '\\' && bp[1] == 'x') {
1084 /* HEX STRING */
1085 bp += 2;
1086 while (isxdigit(bp[0]) && isxdigit(bp[1]) && len < bufsize) {
1087 int byte = isdigit(*bp) ? *bp-'0' : toupper(*bp)-'A'+10;
1088 bp++;
1089 byte <<= 4;
1090 byte |= isdigit(*bp) ? *bp-'0' : toupper(*bp)-'A'+10;
1091 *dest++ = byte;
1092 bp++;
1093 len++;
1094 }
1095 } else {
1096 /* text with \nnn octal quoting */
1097 while (*bp != ' ' && *bp != '\n' && *bp && len < bufsize-1) {
1098 if (*bp == '\\' &&
1099 isodigit(bp[1]) && (bp[1] <= '3') &&
1100 isodigit(bp[2]) &&
1101 isodigit(bp[3])) {
1102 int byte = (*++bp -'0');
1103 bp++;
1104 byte = (byte << 3) | (*bp++ - '0');
1105 byte = (byte << 3) | (*bp++ - '0');
1106 *dest++ = byte;
1107 len++;
1108 } else {
1109 *dest++ = *bp++;
1110 len++;
1111 }
1112 }
1113 }
1114
1115 if (*bp != ' ' && *bp != '\n' && *bp != '\0')
1116 return -1;
1117 while (*bp == ' ') bp++;
1118 *bpp = bp;
1119 *dest = '\0';
1120 return len;
1121}
Trond Myklebust24c37672008-12-23 16:30:12 -05001122EXPORT_SYMBOL_GPL(qword_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
1124
1125/*
1126 * support /proc/sunrpc/cache/$CACHENAME/content
1127 * as a seqfile.
1128 * We call ->cache_show passing NULL for the item to
1129 * get a header, then pass each real item in the cache
1130 */
1131
1132struct handle {
1133 struct cache_detail *cd;
1134};
1135
1136static void *c_start(struct seq_file *m, loff_t *pos)
Eric Dumazet9a429c42008-01-01 21:58:02 -08001137 __acquires(cd->hash_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138{
1139 loff_t n = *pos;
1140 unsigned hash, entry;
1141 struct cache_head *ch;
1142 struct cache_detail *cd = ((struct handle*)m->private)->cd;
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
1145 read_lock(&cd->hash_lock);
1146 if (!n--)
1147 return SEQ_START_TOKEN;
1148 hash = n >> 32;
1149 entry = n & ((1LL<<32) - 1);
1150
1151 for (ch=cd->hash_table[hash]; ch; ch=ch->next)
1152 if (!entry--)
1153 return ch;
1154 n &= ~((1LL<<32) - 1);
1155 do {
1156 hash++;
1157 n += 1LL<<32;
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001158 } while(hash < cd->hash_size &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 cd->hash_table[hash]==NULL);
1160 if (hash >= cd->hash_size)
1161 return NULL;
1162 *pos = n+1;
1163 return cd->hash_table[hash];
1164}
1165
1166static void *c_next(struct seq_file *m, void *p, loff_t *pos)
1167{
1168 struct cache_head *ch = p;
1169 int hash = (*pos >> 32);
1170 struct cache_detail *cd = ((struct handle*)m->private)->cd;
1171
1172 if (p == SEQ_START_TOKEN)
1173 hash = 0;
1174 else if (ch->next == NULL) {
1175 hash++;
1176 *pos += 1LL<<32;
1177 } else {
1178 ++*pos;
1179 return ch->next;
1180 }
1181 *pos &= ~((1LL<<32) - 1);
1182 while (hash < cd->hash_size &&
1183 cd->hash_table[hash] == NULL) {
1184 hash++;
1185 *pos += 1LL<<32;
1186 }
1187 if (hash >= cd->hash_size)
1188 return NULL;
1189 ++*pos;
1190 return cd->hash_table[hash];
1191}
1192
1193static void c_stop(struct seq_file *m, void *p)
Eric Dumazet9a429c42008-01-01 21:58:02 -08001194 __releases(cd->hash_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195{
1196 struct cache_detail *cd = ((struct handle*)m->private)->cd;
1197 read_unlock(&cd->hash_lock);
1198}
1199
1200static int c_show(struct seq_file *m, void *p)
1201{
1202 struct cache_head *cp = p;
1203 struct cache_detail *cd = ((struct handle*)m->private)->cd;
1204
1205 if (p == SEQ_START_TOKEN)
1206 return cd->cache_show(m, cd, NULL);
1207
1208 ifdebug(CACHE)
NeilBrown4013ede2006-03-27 01:15:07 -08001209 seq_printf(m, "# expiry=%ld refcnt=%d flags=%lx\n",
NeilBrownbaab9352006-03-27 01:15:09 -08001210 cp->expiry_time, atomic_read(&cp->ref.refcount), cp->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 cache_get(cp);
1212 if (cache_check(cd, cp, NULL))
1213 /* cache_check does a cache_put on failure */
1214 seq_printf(m, "# ");
1215 else
1216 cache_put(cp, cd);
1217
1218 return cd->cache_show(m, cd, cp);
1219}
1220
Philippe De Muyter56b3d972007-07-10 23:07:31 -07001221static const struct seq_operations cache_content_op = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 .start = c_start,
1223 .next = c_next,
1224 .stop = c_stop,
1225 .show = c_show,
1226};
1227
Trond Myklebust173912a2009-08-09 15:14:29 -04001228static int content_open(struct inode *inode, struct file *file,
1229 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 struct handle *han;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001233 if (!cd || !try_module_get(cd->owner))
1234 return -EACCES;
Pavel Emelyanovec931032007-10-10 02:31:07 -07001235 han = __seq_open_private(file, &cache_content_op, sizeof(*han));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 if (han == NULL)
1237 return -ENOMEM;
1238
1239 han->cd = cd;
Pavel Emelyanovec931032007-10-10 02:31:07 -07001240 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001243static int content_release(struct inode *inode, struct file *file,
1244 struct cache_detail *cd)
1245{
1246 int ret = seq_release_private(inode, file);
1247 module_put(cd->owner);
1248 return ret;
1249}
1250
1251static int open_flush(struct inode *inode, struct file *file,
1252 struct cache_detail *cd)
1253{
1254 if (!cd || !try_module_get(cd->owner))
1255 return -EACCES;
1256 return nonseekable_open(inode, file);
1257}
1258
1259static int release_flush(struct inode *inode, struct file *file,
1260 struct cache_detail *cd)
1261{
1262 module_put(cd->owner);
1263 return 0;
1264}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
1266static ssize_t read_flush(struct file *file, char __user *buf,
Trond Myklebust173912a2009-08-09 15:14:29 -04001267 size_t count, loff_t *ppos,
1268 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 char tbuf[20];
1271 unsigned long p = *ppos;
Chuck Lever01b29692007-10-26 13:31:20 -04001272 size_t len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
1274 sprintf(tbuf, "%lu\n", cd->flush_time);
1275 len = strlen(tbuf);
1276 if (p >= len)
1277 return 0;
1278 len -= p;
Chuck Lever01b29692007-10-26 13:31:20 -04001279 if (len > count)
1280 len = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 if (copy_to_user(buf, (void*)(tbuf+p), len))
Chuck Lever01b29692007-10-26 13:31:20 -04001282 return -EFAULT;
1283 *ppos += len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 return len;
1285}
1286
Trond Myklebust173912a2009-08-09 15:14:29 -04001287static ssize_t write_flush(struct file *file, const char __user *buf,
1288 size_t count, loff_t *ppos,
1289 struct cache_detail *cd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 char tbuf[20];
1292 char *ep;
1293 long flushtime;
1294 if (*ppos || count > sizeof(tbuf)-1)
1295 return -EINVAL;
1296 if (copy_from_user(tbuf, buf, count))
1297 return -EFAULT;
1298 tbuf[count] = 0;
1299 flushtime = simple_strtoul(tbuf, &ep, 0);
1300 if (*ep && *ep != '\n')
1301 return -EINVAL;
1302
1303 cd->flush_time = flushtime;
1304 cd->nextcheck = get_seconds();
1305 cache_flush();
1306
1307 *ppos += count;
1308 return count;
1309}
1310
Trond Myklebust173912a2009-08-09 15:14:29 -04001311static ssize_t cache_read_procfs(struct file *filp, char __user *buf,
1312 size_t count, loff_t *ppos)
1313{
1314 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data;
1315
1316 return cache_read(filp, buf, count, ppos, cd);
1317}
1318
1319static ssize_t cache_write_procfs(struct file *filp, const char __user *buf,
1320 size_t count, loff_t *ppos)
1321{
1322 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data;
1323
1324 return cache_write(filp, buf, count, ppos, cd);
1325}
1326
1327static unsigned int cache_poll_procfs(struct file *filp, poll_table *wait)
1328{
1329 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data;
1330
1331 return cache_poll(filp, wait, cd);
1332}
1333
1334static int cache_ioctl_procfs(struct inode *inode, struct file *filp,
1335 unsigned int cmd, unsigned long arg)
1336{
1337 struct cache_detail *cd = PDE(inode)->data;
1338
1339 return cache_ioctl(inode, filp, cmd, arg, cd);
1340}
1341
1342static int cache_open_procfs(struct inode *inode, struct file *filp)
1343{
1344 struct cache_detail *cd = PDE(inode)->data;
1345
1346 return cache_open(inode, filp, cd);
1347}
1348
1349static int cache_release_procfs(struct inode *inode, struct file *filp)
1350{
1351 struct cache_detail *cd = PDE(inode)->data;
1352
1353 return cache_release(inode, filp, cd);
1354}
1355
1356static const struct file_operations cache_file_operations_procfs = {
1357 .owner = THIS_MODULE,
1358 .llseek = no_llseek,
1359 .read = cache_read_procfs,
1360 .write = cache_write_procfs,
1361 .poll = cache_poll_procfs,
1362 .ioctl = cache_ioctl_procfs, /* for FIONREAD */
1363 .open = cache_open_procfs,
1364 .release = cache_release_procfs,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365};
Trond Myklebust173912a2009-08-09 15:14:29 -04001366
1367static int content_open_procfs(struct inode *inode, struct file *filp)
1368{
1369 struct cache_detail *cd = PDE(inode)->data;
1370
1371 return content_open(inode, filp, cd);
1372}
1373
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001374static int content_release_procfs(struct inode *inode, struct file *filp)
1375{
1376 struct cache_detail *cd = PDE(inode)->data;
1377
1378 return content_release(inode, filp, cd);
1379}
1380
Trond Myklebust173912a2009-08-09 15:14:29 -04001381static const struct file_operations content_file_operations_procfs = {
1382 .open = content_open_procfs,
1383 .read = seq_read,
1384 .llseek = seq_lseek,
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001385 .release = content_release_procfs,
Trond Myklebust173912a2009-08-09 15:14:29 -04001386};
1387
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001388static int open_flush_procfs(struct inode *inode, struct file *filp)
1389{
1390 struct cache_detail *cd = PDE(inode)->data;
1391
1392 return open_flush(inode, filp, cd);
1393}
1394
1395static int release_flush_procfs(struct inode *inode, struct file *filp)
1396{
1397 struct cache_detail *cd = PDE(inode)->data;
1398
1399 return release_flush(inode, filp, cd);
1400}
1401
Trond Myklebust173912a2009-08-09 15:14:29 -04001402static ssize_t read_flush_procfs(struct file *filp, char __user *buf,
1403 size_t count, loff_t *ppos)
1404{
1405 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data;
1406
1407 return read_flush(filp, buf, count, ppos, cd);
1408}
1409
1410static ssize_t write_flush_procfs(struct file *filp,
1411 const char __user *buf,
1412 size_t count, loff_t *ppos)
1413{
1414 struct cache_detail *cd = PDE(filp->f_path.dentry->d_inode)->data;
1415
1416 return write_flush(filp, buf, count, ppos, cd);
1417}
1418
1419static const struct file_operations cache_flush_operations_procfs = {
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001420 .open = open_flush_procfs,
Trond Myklebust173912a2009-08-09 15:14:29 -04001421 .read = read_flush_procfs,
1422 .write = write_flush_procfs,
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001423 .release = release_flush_procfs,
Trond Myklebust173912a2009-08-09 15:14:29 -04001424};
1425
1426static void remove_cache_proc_entries(struct cache_detail *cd)
1427{
1428 if (cd->u.procfs.proc_ent == NULL)
1429 return;
1430 if (cd->u.procfs.flush_ent)
1431 remove_proc_entry("flush", cd->u.procfs.proc_ent);
1432 if (cd->u.procfs.channel_ent)
1433 remove_proc_entry("channel", cd->u.procfs.proc_ent);
1434 if (cd->u.procfs.content_ent)
1435 remove_proc_entry("content", cd->u.procfs.proc_ent);
1436 cd->u.procfs.proc_ent = NULL;
1437 remove_proc_entry(cd->name, proc_net_rpc);
1438}
1439
1440#ifdef CONFIG_PROC_FS
1441static int create_cache_proc_entries(struct cache_detail *cd)
1442{
1443 struct proc_dir_entry *p;
1444
1445 cd->u.procfs.proc_ent = proc_mkdir(cd->name, proc_net_rpc);
1446 if (cd->u.procfs.proc_ent == NULL)
1447 goto out_nomem;
1448 cd->u.procfs.channel_ent = NULL;
1449 cd->u.procfs.content_ent = NULL;
1450
1451 p = proc_create_data("flush", S_IFREG|S_IRUSR|S_IWUSR,
1452 cd->u.procfs.proc_ent,
1453 &cache_flush_operations_procfs, cd);
1454 cd->u.procfs.flush_ent = p;
1455 if (p == NULL)
1456 goto out_nomem;
1457
1458 if (cd->cache_upcall || cd->cache_parse) {
1459 p = proc_create_data("channel", S_IFREG|S_IRUSR|S_IWUSR,
1460 cd->u.procfs.proc_ent,
1461 &cache_file_operations_procfs, cd);
1462 cd->u.procfs.channel_ent = p;
1463 if (p == NULL)
1464 goto out_nomem;
1465 }
1466 if (cd->cache_show) {
1467 p = proc_create_data("content", S_IFREG|S_IRUSR|S_IWUSR,
1468 cd->u.procfs.proc_ent,
1469 &content_file_operations_procfs, cd);
1470 cd->u.procfs.content_ent = p;
1471 if (p == NULL)
1472 goto out_nomem;
1473 }
1474 return 0;
1475out_nomem:
1476 remove_cache_proc_entries(cd);
1477 return -ENOMEM;
1478}
1479#else /* CONFIG_PROC_FS */
1480static int create_cache_proc_entries(struct cache_detail *cd)
1481{
1482 return 0;
1483}
1484#endif
1485
1486int cache_register(struct cache_detail *cd)
1487{
1488 int ret;
1489
1490 sunrpc_init_cache_detail(cd);
1491 ret = create_cache_proc_entries(cd);
1492 if (ret)
1493 sunrpc_destroy_cache_detail(cd);
1494 return ret;
1495}
1496EXPORT_SYMBOL_GPL(cache_register);
1497
1498void cache_unregister(struct cache_detail *cd)
1499{
1500 remove_cache_proc_entries(cd);
1501 sunrpc_destroy_cache_detail(cd);
1502}
1503EXPORT_SYMBOL_GPL(cache_unregister);
Trond Myklebust8854e822009-08-09 15:14:30 -04001504
1505static ssize_t cache_read_pipefs(struct file *filp, char __user *buf,
1506 size_t count, loff_t *ppos)
1507{
1508 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private;
1509
1510 return cache_read(filp, buf, count, ppos, cd);
1511}
1512
1513static ssize_t cache_write_pipefs(struct file *filp, const char __user *buf,
1514 size_t count, loff_t *ppos)
1515{
1516 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private;
1517
1518 return cache_write(filp, buf, count, ppos, cd);
1519}
1520
1521static unsigned int cache_poll_pipefs(struct file *filp, poll_table *wait)
1522{
1523 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private;
1524
1525 return cache_poll(filp, wait, cd);
1526}
1527
1528static int cache_ioctl_pipefs(struct inode *inode, struct file *filp,
1529 unsigned int cmd, unsigned long arg)
1530{
1531 struct cache_detail *cd = RPC_I(inode)->private;
1532
1533 return cache_ioctl(inode, filp, cmd, arg, cd);
1534}
1535
1536static int cache_open_pipefs(struct inode *inode, struct file *filp)
1537{
1538 struct cache_detail *cd = RPC_I(inode)->private;
1539
1540 return cache_open(inode, filp, cd);
1541}
1542
1543static int cache_release_pipefs(struct inode *inode, struct file *filp)
1544{
1545 struct cache_detail *cd = RPC_I(inode)->private;
1546
1547 return cache_release(inode, filp, cd);
1548}
1549
1550const struct file_operations cache_file_operations_pipefs = {
1551 .owner = THIS_MODULE,
1552 .llseek = no_llseek,
1553 .read = cache_read_pipefs,
1554 .write = cache_write_pipefs,
1555 .poll = cache_poll_pipefs,
1556 .ioctl = cache_ioctl_pipefs, /* for FIONREAD */
1557 .open = cache_open_pipefs,
1558 .release = cache_release_pipefs,
1559};
1560
1561static int content_open_pipefs(struct inode *inode, struct file *filp)
1562{
1563 struct cache_detail *cd = RPC_I(inode)->private;
1564
1565 return content_open(inode, filp, cd);
1566}
1567
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001568static int content_release_pipefs(struct inode *inode, struct file *filp)
1569{
1570 struct cache_detail *cd = RPC_I(inode)->private;
1571
1572 return content_release(inode, filp, cd);
1573}
1574
Trond Myklebust8854e822009-08-09 15:14:30 -04001575const struct file_operations content_file_operations_pipefs = {
1576 .open = content_open_pipefs,
1577 .read = seq_read,
1578 .llseek = seq_lseek,
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001579 .release = content_release_pipefs,
Trond Myklebust8854e822009-08-09 15:14:30 -04001580};
1581
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001582static int open_flush_pipefs(struct inode *inode, struct file *filp)
1583{
1584 struct cache_detail *cd = RPC_I(inode)->private;
1585
1586 return open_flush(inode, filp, cd);
1587}
1588
1589static int release_flush_pipefs(struct inode *inode, struct file *filp)
1590{
1591 struct cache_detail *cd = RPC_I(inode)->private;
1592
1593 return release_flush(inode, filp, cd);
1594}
1595
Trond Myklebust8854e822009-08-09 15:14:30 -04001596static ssize_t read_flush_pipefs(struct file *filp, char __user *buf,
1597 size_t count, loff_t *ppos)
1598{
1599 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private;
1600
1601 return read_flush(filp, buf, count, ppos, cd);
1602}
1603
1604static ssize_t write_flush_pipefs(struct file *filp,
1605 const char __user *buf,
1606 size_t count, loff_t *ppos)
1607{
1608 struct cache_detail *cd = RPC_I(filp->f_path.dentry->d_inode)->private;
1609
1610 return write_flush(filp, buf, count, ppos, cd);
1611}
1612
1613const struct file_operations cache_flush_operations_pipefs = {
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001614 .open = open_flush_pipefs,
Trond Myklebust8854e822009-08-09 15:14:30 -04001615 .read = read_flush_pipefs,
1616 .write = write_flush_pipefs,
Trond Myklebustf7e86ab2009-08-19 18:13:00 -04001617 .release = release_flush_pipefs,
Trond Myklebust8854e822009-08-09 15:14:30 -04001618};
1619
1620int sunrpc_cache_register_pipefs(struct dentry *parent,
1621 const char *name, mode_t umode,
1622 struct cache_detail *cd)
1623{
1624 struct qstr q;
1625 struct dentry *dir;
1626 int ret = 0;
1627
1628 sunrpc_init_cache_detail(cd);
1629 q.name = name;
1630 q.len = strlen(name);
1631 q.hash = full_name_hash(q.name, q.len);
1632 dir = rpc_create_cache_dir(parent, &q, umode, cd);
1633 if (!IS_ERR(dir))
1634 cd->u.pipefs.dir = dir;
1635 else {
1636 sunrpc_destroy_cache_detail(cd);
1637 ret = PTR_ERR(dir);
1638 }
1639 return ret;
1640}
1641EXPORT_SYMBOL_GPL(sunrpc_cache_register_pipefs);
1642
1643void sunrpc_cache_unregister_pipefs(struct cache_detail *cd)
1644{
1645 rpc_remove_cache_dir(cd->u.pipefs.dir);
1646 cd->u.pipefs.dir = NULL;
1647 sunrpc_destroy_cache_detail(cd);
1648}
1649EXPORT_SYMBOL_GPL(sunrpc_cache_unregister_pipefs);
1650