Loading...
1/* netfs cookie management
2 *
3 * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 * See Documentation/filesystems/caching/netfs-api.txt for more information on
12 * the netfs API.
13 */
14
15#define FSCACHE_DEBUG_LEVEL COOKIE
16#include <linux/module.h>
17#include <linux/slab.h>
18#include "internal.h"
19
20struct kmem_cache *fscache_cookie_jar;
21
22static atomic_t fscache_object_debug_id = ATOMIC_INIT(0);
23
24static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie);
25static int fscache_alloc_object(struct fscache_cache *cache,
26 struct fscache_cookie *cookie);
27static int fscache_attach_object(struct fscache_cookie *cookie,
28 struct fscache_object *object);
29
30/*
31 * initialise an cookie jar slab element prior to any use
32 */
33void fscache_cookie_init_once(void *_cookie)
34{
35 struct fscache_cookie *cookie = _cookie;
36
37 memset(cookie, 0, sizeof(*cookie));
38 spin_lock_init(&cookie->lock);
39 spin_lock_init(&cookie->stores_lock);
40 INIT_HLIST_HEAD(&cookie->backing_objects);
41}
42
43/*
44 * request a cookie to represent an object (index, datafile, xattr, etc)
45 * - parent specifies the parent object
46 * - the top level index cookie for each netfs is stored in the fscache_netfs
47 * struct upon registration
48 * - def points to the definition
49 * - the netfs_data will be passed to the functions pointed to in *def
50 * - all attached caches will be searched to see if they contain this object
51 * - index objects aren't stored on disk until there's a dependent file that
52 * needs storing
53 * - other objects are stored in a selected cache immediately, and all the
54 * indices forming the path to it are instantiated if necessary
55 * - we never let on to the netfs about errors
56 * - we may set a negative cookie pointer, but that's okay
57 */
58struct fscache_cookie *__fscache_acquire_cookie(
59 struct fscache_cookie *parent,
60 const struct fscache_cookie_def *def,
61 void *netfs_data,
62 bool enable)
63{
64 struct fscache_cookie *cookie;
65
66 BUG_ON(!def);
67
68 _enter("{%s},{%s},%p,%u",
69 parent ? (char *) parent->def->name : "<no-parent>",
70 def->name, netfs_data, enable);
71
72 fscache_stat(&fscache_n_acquires);
73
74 /* if there's no parent cookie, then we don't create one here either */
75 if (!parent) {
76 fscache_stat(&fscache_n_acquires_null);
77 _leave(" [no parent]");
78 return NULL;
79 }
80
81 /* validate the definition */
82 BUG_ON(!def->get_key);
83 BUG_ON(!def->name[0]);
84
85 BUG_ON(def->type == FSCACHE_COOKIE_TYPE_INDEX &&
86 parent->def->type != FSCACHE_COOKIE_TYPE_INDEX);
87
88 /* allocate and initialise a cookie */
89 cookie = kmem_cache_alloc(fscache_cookie_jar, GFP_KERNEL);
90 if (!cookie) {
91 fscache_stat(&fscache_n_acquires_oom);
92 _leave(" [ENOMEM]");
93 return NULL;
94 }
95
96 atomic_set(&cookie->usage, 1);
97 atomic_set(&cookie->n_children, 0);
98
99 /* We keep the active count elevated until relinquishment to prevent an
100 * attempt to wake up every time the object operations queue quiesces.
101 */
102 atomic_set(&cookie->n_active, 1);
103
104 atomic_inc(&parent->usage);
105 atomic_inc(&parent->n_children);
106
107 cookie->def = def;
108 cookie->parent = parent;
109 cookie->netfs_data = netfs_data;
110 cookie->flags = (1 << FSCACHE_COOKIE_NO_DATA_YET);
111
112 /* radix tree insertion won't use the preallocation pool unless it's
113 * told it may not wait */
114 INIT_RADIX_TREE(&cookie->stores, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
115
116 switch (cookie->def->type) {
117 case FSCACHE_COOKIE_TYPE_INDEX:
118 fscache_stat(&fscache_n_cookie_index);
119 break;
120 case FSCACHE_COOKIE_TYPE_DATAFILE:
121 fscache_stat(&fscache_n_cookie_data);
122 break;
123 default:
124 fscache_stat(&fscache_n_cookie_special);
125 break;
126 }
127
128 if (enable) {
129 /* if the object is an index then we need do nothing more here
130 * - we create indices on disk when we need them as an index
131 * may exist in multiple caches */
132 if (cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX) {
133 if (fscache_acquire_non_index_cookie(cookie) == 0) {
134 set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags);
135 } else {
136 atomic_dec(&parent->n_children);
137 __fscache_cookie_put(cookie);
138 fscache_stat(&fscache_n_acquires_nobufs);
139 _leave(" = NULL");
140 return NULL;
141 }
142 } else {
143 set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags);
144 }
145 }
146
147 fscache_stat(&fscache_n_acquires_ok);
148 _leave(" = %p", cookie);
149 return cookie;
150}
151EXPORT_SYMBOL(__fscache_acquire_cookie);
152
153/*
154 * Enable a cookie to permit it to accept new operations.
155 */
156void __fscache_enable_cookie(struct fscache_cookie *cookie,
157 bool (*can_enable)(void *data),
158 void *data)
159{
160 _enter("%p", cookie);
161
162 wait_on_bit_lock(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK,
163 TASK_UNINTERRUPTIBLE);
164
165 if (test_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags))
166 goto out_unlock;
167
168 if (can_enable && !can_enable(data)) {
169 /* The netfs decided it didn't want to enable after all */
170 } else if (cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX) {
171 /* Wait for outstanding disablement to complete */
172 __fscache_wait_on_invalidate(cookie);
173
174 if (fscache_acquire_non_index_cookie(cookie) == 0)
175 set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags);
176 } else {
177 set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags);
178 }
179
180out_unlock:
181 clear_bit_unlock(FSCACHE_COOKIE_ENABLEMENT_LOCK, &cookie->flags);
182 wake_up_bit(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK);
183}
184EXPORT_SYMBOL(__fscache_enable_cookie);
185
186/*
187 * acquire a non-index cookie
188 * - this must make sure the index chain is instantiated and instantiate the
189 * object representation too
190 */
191static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
192{
193 struct fscache_object *object;
194 struct fscache_cache *cache;
195 uint64_t i_size;
196 int ret;
197
198 _enter("");
199
200 set_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags);
201
202 /* now we need to see whether the backing objects for this cookie yet
203 * exist, if not there'll be nothing to search */
204 down_read(&fscache_addremove_sem);
205
206 if (list_empty(&fscache_cache_list)) {
207 up_read(&fscache_addremove_sem);
208 _leave(" = 0 [no caches]");
209 return 0;
210 }
211
212 /* select a cache in which to store the object */
213 cache = fscache_select_cache_for_object(cookie->parent);
214 if (!cache) {
215 up_read(&fscache_addremove_sem);
216 fscache_stat(&fscache_n_acquires_no_cache);
217 _leave(" = -ENOMEDIUM [no cache]");
218 return -ENOMEDIUM;
219 }
220
221 _debug("cache %s", cache->tag->name);
222
223 set_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags);
224
225 /* ask the cache to allocate objects for this cookie and its parent
226 * chain */
227 ret = fscache_alloc_object(cache, cookie);
228 if (ret < 0) {
229 up_read(&fscache_addremove_sem);
230 _leave(" = %d", ret);
231 return ret;
232 }
233
234 /* pass on how big the object we're caching is supposed to be */
235 cookie->def->get_attr(cookie->netfs_data, &i_size);
236
237 spin_lock(&cookie->lock);
238 if (hlist_empty(&cookie->backing_objects)) {
239 spin_unlock(&cookie->lock);
240 goto unavailable;
241 }
242
243 object = hlist_entry(cookie->backing_objects.first,
244 struct fscache_object, cookie_link);
245
246 fscache_set_store_limit(object, i_size);
247
248 /* initiate the process of looking up all the objects in the chain
249 * (done by fscache_initialise_object()) */
250 fscache_raise_event(object, FSCACHE_OBJECT_EV_NEW_CHILD);
251
252 spin_unlock(&cookie->lock);
253
254 /* we may be required to wait for lookup to complete at this point */
255 if (!fscache_defer_lookup) {
256 _debug("non-deferred lookup %p", &cookie->flags);
257 wait_on_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP,
258 TASK_UNINTERRUPTIBLE);
259 _debug("complete");
260 if (test_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags))
261 goto unavailable;
262 }
263
264 up_read(&fscache_addremove_sem);
265 _leave(" = 0 [deferred]");
266 return 0;
267
268unavailable:
269 up_read(&fscache_addremove_sem);
270 _leave(" = -ENOBUFS");
271 return -ENOBUFS;
272}
273
274/*
275 * recursively allocate cache object records for a cookie/cache combination
276 * - caller must be holding the addremove sem
277 */
278static int fscache_alloc_object(struct fscache_cache *cache,
279 struct fscache_cookie *cookie)
280{
281 struct fscache_object *object;
282 int ret;
283
284 _enter("%p,%p{%s}", cache, cookie, cookie->def->name);
285
286 spin_lock(&cookie->lock);
287 hlist_for_each_entry(object, &cookie->backing_objects,
288 cookie_link) {
289 if (object->cache == cache)
290 goto object_already_extant;
291 }
292 spin_unlock(&cookie->lock);
293
294 /* ask the cache to allocate an object (we may end up with duplicate
295 * objects at this stage, but we sort that out later) */
296 fscache_stat(&fscache_n_cop_alloc_object);
297 object = cache->ops->alloc_object(cache, cookie);
298 fscache_stat_d(&fscache_n_cop_alloc_object);
299 if (IS_ERR(object)) {
300 fscache_stat(&fscache_n_object_no_alloc);
301 ret = PTR_ERR(object);
302 goto error;
303 }
304
305 fscache_stat(&fscache_n_object_alloc);
306
307 object->debug_id = atomic_inc_return(&fscache_object_debug_id);
308
309 _debug("ALLOC OBJ%x: %s {%lx}",
310 object->debug_id, cookie->def->name, object->events);
311
312 ret = fscache_alloc_object(cache, cookie->parent);
313 if (ret < 0)
314 goto error_put;
315
316 /* only attach if we managed to allocate all we needed, otherwise
317 * discard the object we just allocated and instead use the one
318 * attached to the cookie */
319 if (fscache_attach_object(cookie, object) < 0) {
320 fscache_stat(&fscache_n_cop_put_object);
321 cache->ops->put_object(object);
322 fscache_stat_d(&fscache_n_cop_put_object);
323 }
324
325 _leave(" = 0");
326 return 0;
327
328object_already_extant:
329 ret = -ENOBUFS;
330 if (fscache_object_is_dying(object) ||
331 fscache_cache_is_broken(object)) {
332 spin_unlock(&cookie->lock);
333 goto error;
334 }
335 spin_unlock(&cookie->lock);
336 _leave(" = 0 [found]");
337 return 0;
338
339error_put:
340 fscache_stat(&fscache_n_cop_put_object);
341 cache->ops->put_object(object);
342 fscache_stat_d(&fscache_n_cop_put_object);
343error:
344 _leave(" = %d", ret);
345 return ret;
346}
347
348/*
349 * attach a cache object to a cookie
350 */
351static int fscache_attach_object(struct fscache_cookie *cookie,
352 struct fscache_object *object)
353{
354 struct fscache_object *p;
355 struct fscache_cache *cache = object->cache;
356 int ret;
357
358 _enter("{%s},{OBJ%x}", cookie->def->name, object->debug_id);
359
360 spin_lock(&cookie->lock);
361
362 /* there may be multiple initial creations of this object, but we only
363 * want one */
364 ret = -EEXIST;
365 hlist_for_each_entry(p, &cookie->backing_objects, cookie_link) {
366 if (p->cache == object->cache) {
367 if (fscache_object_is_dying(p))
368 ret = -ENOBUFS;
369 goto cant_attach_object;
370 }
371 }
372
373 /* pin the parent object */
374 spin_lock_nested(&cookie->parent->lock, 1);
375 hlist_for_each_entry(p, &cookie->parent->backing_objects,
376 cookie_link) {
377 if (p->cache == object->cache) {
378 if (fscache_object_is_dying(p)) {
379 ret = -ENOBUFS;
380 spin_unlock(&cookie->parent->lock);
381 goto cant_attach_object;
382 }
383 object->parent = p;
384 spin_lock(&p->lock);
385 p->n_children++;
386 spin_unlock(&p->lock);
387 break;
388 }
389 }
390 spin_unlock(&cookie->parent->lock);
391
392 /* attach to the cache's object list */
393 if (list_empty(&object->cache_link)) {
394 spin_lock(&cache->object_list_lock);
395 list_add(&object->cache_link, &cache->object_list);
396 spin_unlock(&cache->object_list_lock);
397 }
398
399 /* attach to the cookie */
400 object->cookie = cookie;
401 atomic_inc(&cookie->usage);
402 hlist_add_head(&object->cookie_link, &cookie->backing_objects);
403
404 fscache_objlist_add(object);
405 ret = 0;
406
407cant_attach_object:
408 spin_unlock(&cookie->lock);
409 _leave(" = %d", ret);
410 return ret;
411}
412
413/*
414 * Invalidate an object. Callable with spinlocks held.
415 */
416void __fscache_invalidate(struct fscache_cookie *cookie)
417{
418 struct fscache_object *object;
419
420 _enter("{%s}", cookie->def->name);
421
422 fscache_stat(&fscache_n_invalidates);
423
424 /* Only permit invalidation of data files. Invalidating an index will
425 * require the caller to release all its attachments to the tree rooted
426 * there, and if it's doing that, it may as well just retire the
427 * cookie.
428 */
429 ASSERTCMP(cookie->def->type, ==, FSCACHE_COOKIE_TYPE_DATAFILE);
430
431 /* We will be updating the cookie too. */
432 BUG_ON(!cookie->def->get_aux);
433
434 /* If there's an object, we tell the object state machine to handle the
435 * invalidation on our behalf, otherwise there's nothing to do.
436 */
437 if (!hlist_empty(&cookie->backing_objects)) {
438 spin_lock(&cookie->lock);
439
440 if (fscache_cookie_enabled(cookie) &&
441 !hlist_empty(&cookie->backing_objects) &&
442 !test_and_set_bit(FSCACHE_COOKIE_INVALIDATING,
443 &cookie->flags)) {
444 object = hlist_entry(cookie->backing_objects.first,
445 struct fscache_object,
446 cookie_link);
447 if (fscache_object_is_live(object))
448 fscache_raise_event(
449 object, FSCACHE_OBJECT_EV_INVALIDATE);
450 }
451
452 spin_unlock(&cookie->lock);
453 }
454
455 _leave("");
456}
457EXPORT_SYMBOL(__fscache_invalidate);
458
459/*
460 * Wait for object invalidation to complete.
461 */
462void __fscache_wait_on_invalidate(struct fscache_cookie *cookie)
463{
464 _enter("%p", cookie);
465
466 wait_on_bit(&cookie->flags, FSCACHE_COOKIE_INVALIDATING,
467 TASK_UNINTERRUPTIBLE);
468
469 _leave("");
470}
471EXPORT_SYMBOL(__fscache_wait_on_invalidate);
472
473/*
474 * update the index entries backing a cookie
475 */
476void __fscache_update_cookie(struct fscache_cookie *cookie)
477{
478 struct fscache_object *object;
479
480 fscache_stat(&fscache_n_updates);
481
482 if (!cookie) {
483 fscache_stat(&fscache_n_updates_null);
484 _leave(" [no cookie]");
485 return;
486 }
487
488 _enter("{%s}", cookie->def->name);
489
490 BUG_ON(!cookie->def->get_aux);
491
492 spin_lock(&cookie->lock);
493
494 if (fscache_cookie_enabled(cookie)) {
495 /* update the index entry on disk in each cache backing this
496 * cookie.
497 */
498 hlist_for_each_entry(object,
499 &cookie->backing_objects, cookie_link) {
500 fscache_raise_event(object, FSCACHE_OBJECT_EV_UPDATE);
501 }
502 }
503
504 spin_unlock(&cookie->lock);
505 _leave("");
506}
507EXPORT_SYMBOL(__fscache_update_cookie);
508
509/*
510 * Disable a cookie to stop it from accepting new requests from the netfs.
511 */
512void __fscache_disable_cookie(struct fscache_cookie *cookie, bool invalidate)
513{
514 struct fscache_object *object;
515 bool awaken = false;
516
517 _enter("%p,%u", cookie, invalidate);
518
519 ASSERTCMP(atomic_read(&cookie->n_active), >, 0);
520
521 if (atomic_read(&cookie->n_children) != 0) {
522 pr_err("Cookie '%s' still has children\n",
523 cookie->def->name);
524 BUG();
525 }
526
527 wait_on_bit_lock(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK,
528 TASK_UNINTERRUPTIBLE);
529 if (!test_and_clear_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags))
530 goto out_unlock_enable;
531
532 /* If the cookie is being invalidated, wait for that to complete first
533 * so that we can reuse the flag.
534 */
535 __fscache_wait_on_invalidate(cookie);
536
537 /* Dispose of the backing objects */
538 set_bit(FSCACHE_COOKIE_INVALIDATING, &cookie->flags);
539
540 spin_lock(&cookie->lock);
541 if (!hlist_empty(&cookie->backing_objects)) {
542 hlist_for_each_entry(object, &cookie->backing_objects, cookie_link) {
543 if (invalidate)
544 set_bit(FSCACHE_OBJECT_RETIRED, &object->flags);
545 fscache_raise_event(object, FSCACHE_OBJECT_EV_KILL);
546 }
547 } else {
548 if (test_and_clear_bit(FSCACHE_COOKIE_INVALIDATING, &cookie->flags))
549 awaken = true;
550 }
551 spin_unlock(&cookie->lock);
552 if (awaken)
553 wake_up_bit(&cookie->flags, FSCACHE_COOKIE_INVALIDATING);
554
555 /* Wait for cessation of activity requiring access to the netfs (when
556 * n_active reaches 0). This makes sure outstanding reads and writes
557 * have completed.
558 */
559 if (!atomic_dec_and_test(&cookie->n_active))
560 wait_on_atomic_t(&cookie->n_active, fscache_wait_atomic_t,
561 TASK_UNINTERRUPTIBLE);
562
563 /* Reset the cookie state if it wasn't relinquished */
564 if (!test_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags)) {
565 atomic_inc(&cookie->n_active);
566 set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags);
567 }
568
569out_unlock_enable:
570 clear_bit_unlock(FSCACHE_COOKIE_ENABLEMENT_LOCK, &cookie->flags);
571 wake_up_bit(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK);
572 _leave("");
573}
574EXPORT_SYMBOL(__fscache_disable_cookie);
575
576/*
577 * release a cookie back to the cache
578 * - the object will be marked as recyclable on disk if retire is true
579 * - all dependents of this cookie must have already been unregistered
580 * (indices/files/pages)
581 */
582void __fscache_relinquish_cookie(struct fscache_cookie *cookie, bool retire)
583{
584 fscache_stat(&fscache_n_relinquishes);
585 if (retire)
586 fscache_stat(&fscache_n_relinquishes_retire);
587
588 if (!cookie) {
589 fscache_stat(&fscache_n_relinquishes_null);
590 _leave(" [no cookie]");
591 return;
592 }
593
594 _enter("%p{%s,%p,%d},%d",
595 cookie, cookie->def->name, cookie->netfs_data,
596 atomic_read(&cookie->n_active), retire);
597
598 /* No further netfs-accessing operations on this cookie permitted */
599 set_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags);
600
601 __fscache_disable_cookie(cookie, retire);
602
603 /* Clear pointers back to the netfs */
604 cookie->netfs_data = NULL;
605 cookie->def = NULL;
606 BUG_ON(cookie->stores.rnode);
607
608 if (cookie->parent) {
609 ASSERTCMP(atomic_read(&cookie->parent->usage), >, 0);
610 ASSERTCMP(atomic_read(&cookie->parent->n_children), >, 0);
611 atomic_dec(&cookie->parent->n_children);
612 }
613
614 /* Dispose of the netfs's link to the cookie */
615 ASSERTCMP(atomic_read(&cookie->usage), >, 0);
616 fscache_cookie_put(cookie);
617
618 _leave("");
619}
620EXPORT_SYMBOL(__fscache_relinquish_cookie);
621
622/*
623 * destroy a cookie
624 */
625void __fscache_cookie_put(struct fscache_cookie *cookie)
626{
627 struct fscache_cookie *parent;
628
629 _enter("%p", cookie);
630
631 for (;;) {
632 _debug("FREE COOKIE %p", cookie);
633 parent = cookie->parent;
634 BUG_ON(!hlist_empty(&cookie->backing_objects));
635 kmem_cache_free(fscache_cookie_jar, cookie);
636
637 if (!parent)
638 break;
639
640 cookie = parent;
641 BUG_ON(atomic_read(&cookie->usage) <= 0);
642 if (!atomic_dec_and_test(&cookie->usage))
643 break;
644 }
645
646 _leave("");
647}
648
649/*
650 * check the consistency between the netfs inode and the backing cache
651 *
652 * NOTE: it only serves no-index type
653 */
654int __fscache_check_consistency(struct fscache_cookie *cookie)
655{
656 struct fscache_operation *op;
657 struct fscache_object *object;
658 bool wake_cookie = false;
659 int ret;
660
661 _enter("%p,", cookie);
662
663 ASSERTCMP(cookie->def->type, ==, FSCACHE_COOKIE_TYPE_DATAFILE);
664
665 if (fscache_wait_for_deferred_lookup(cookie) < 0)
666 return -ERESTARTSYS;
667
668 if (hlist_empty(&cookie->backing_objects))
669 return 0;
670
671 op = kzalloc(sizeof(*op), GFP_NOIO | __GFP_NOMEMALLOC | __GFP_NORETRY);
672 if (!op)
673 return -ENOMEM;
674
675 fscache_operation_init(op, NULL, NULL, NULL);
676 op->flags = FSCACHE_OP_MYTHREAD |
677 (1 << FSCACHE_OP_WAITING) |
678 (1 << FSCACHE_OP_UNUSE_COOKIE);
679
680 spin_lock(&cookie->lock);
681
682 if (!fscache_cookie_enabled(cookie) ||
683 hlist_empty(&cookie->backing_objects))
684 goto inconsistent;
685 object = hlist_entry(cookie->backing_objects.first,
686 struct fscache_object, cookie_link);
687 if (test_bit(FSCACHE_IOERROR, &object->cache->flags))
688 goto inconsistent;
689
690 op->debug_id = atomic_inc_return(&fscache_op_debug_id);
691
692 __fscache_use_cookie(cookie);
693 if (fscache_submit_op(object, op) < 0)
694 goto submit_failed;
695
696 /* the work queue now carries its own ref on the object */
697 spin_unlock(&cookie->lock);
698
699 ret = fscache_wait_for_operation_activation(object, op, NULL, NULL);
700 if (ret == 0) {
701 /* ask the cache to honour the operation */
702 ret = object->cache->ops->check_consistency(op);
703 fscache_op_complete(op, false);
704 } else if (ret == -ENOBUFS) {
705 ret = 0;
706 }
707
708 fscache_put_operation(op);
709 _leave(" = %d", ret);
710 return ret;
711
712submit_failed:
713 wake_cookie = __fscache_unuse_cookie(cookie);
714inconsistent:
715 spin_unlock(&cookie->lock);
716 if (wake_cookie)
717 __fscache_wake_unused_cookie(cookie);
718 kfree(op);
719 _leave(" = -ESTALE");
720 return -ESTALE;
721}
722EXPORT_SYMBOL(__fscache_check_consistency);
1/* netfs cookie management
2 *
3 * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 * See Documentation/filesystems/caching/netfs-api.txt for more information on
12 * the netfs API.
13 */
14
15#define FSCACHE_DEBUG_LEVEL COOKIE
16#include <linux/module.h>
17#include <linux/slab.h>
18#include "internal.h"
19
20struct kmem_cache *fscache_cookie_jar;
21
22static atomic_t fscache_object_debug_id = ATOMIC_INIT(0);
23
24static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie);
25static int fscache_alloc_object(struct fscache_cache *cache,
26 struct fscache_cookie *cookie);
27static int fscache_attach_object(struct fscache_cookie *cookie,
28 struct fscache_object *object);
29
30/*
31 * initialise an cookie jar slab element prior to any use
32 */
33void fscache_cookie_init_once(void *_cookie)
34{
35 struct fscache_cookie *cookie = _cookie;
36
37 memset(cookie, 0, sizeof(*cookie));
38 spin_lock_init(&cookie->lock);
39 spin_lock_init(&cookie->stores_lock);
40 INIT_HLIST_HEAD(&cookie->backing_objects);
41}
42
43/*
44 * request a cookie to represent an object (index, datafile, xattr, etc)
45 * - parent specifies the parent object
46 * - the top level index cookie for each netfs is stored in the fscache_netfs
47 * struct upon registration
48 * - def points to the definition
49 * - the netfs_data will be passed to the functions pointed to in *def
50 * - all attached caches will be searched to see if they contain this object
51 * - index objects aren't stored on disk until there's a dependent file that
52 * needs storing
53 * - other objects are stored in a selected cache immediately, and all the
54 * indices forming the path to it are instantiated if necessary
55 * - we never let on to the netfs about errors
56 * - we may set a negative cookie pointer, but that's okay
57 */
58struct fscache_cookie *__fscache_acquire_cookie(
59 struct fscache_cookie *parent,
60 const struct fscache_cookie_def *def,
61 void *netfs_data)
62{
63 struct fscache_cookie *cookie;
64
65 BUG_ON(!def);
66
67 _enter("{%s},{%s},%p",
68 parent ? (char *) parent->def->name : "<no-parent>",
69 def->name, netfs_data);
70
71 fscache_stat(&fscache_n_acquires);
72
73 /* if there's no parent cookie, then we don't create one here either */
74 if (!parent) {
75 fscache_stat(&fscache_n_acquires_null);
76 _leave(" [no parent]");
77 return NULL;
78 }
79
80 /* validate the definition */
81 BUG_ON(!def->get_key);
82 BUG_ON(!def->name[0]);
83
84 BUG_ON(def->type == FSCACHE_COOKIE_TYPE_INDEX &&
85 parent->def->type != FSCACHE_COOKIE_TYPE_INDEX);
86
87 /* allocate and initialise a cookie */
88 cookie = kmem_cache_alloc(fscache_cookie_jar, GFP_KERNEL);
89 if (!cookie) {
90 fscache_stat(&fscache_n_acquires_oom);
91 _leave(" [ENOMEM]");
92 return NULL;
93 }
94
95 atomic_set(&cookie->usage, 1);
96 atomic_set(&cookie->n_children, 0);
97
98 atomic_inc(&parent->usage);
99 atomic_inc(&parent->n_children);
100
101 cookie->def = def;
102 cookie->parent = parent;
103 cookie->netfs_data = netfs_data;
104 cookie->flags = 0;
105
106 /* radix tree insertion won't use the preallocation pool unless it's
107 * told it may not wait */
108 INIT_RADIX_TREE(&cookie->stores, GFP_NOFS & ~__GFP_WAIT);
109
110 switch (cookie->def->type) {
111 case FSCACHE_COOKIE_TYPE_INDEX:
112 fscache_stat(&fscache_n_cookie_index);
113 break;
114 case FSCACHE_COOKIE_TYPE_DATAFILE:
115 fscache_stat(&fscache_n_cookie_data);
116 break;
117 default:
118 fscache_stat(&fscache_n_cookie_special);
119 break;
120 }
121
122 /* if the object is an index then we need do nothing more here - we
123 * create indices on disk when we need them as an index may exist in
124 * multiple caches */
125 if (cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX) {
126 if (fscache_acquire_non_index_cookie(cookie) < 0) {
127 atomic_dec(&parent->n_children);
128 __fscache_cookie_put(cookie);
129 fscache_stat(&fscache_n_acquires_nobufs);
130 _leave(" = NULL");
131 return NULL;
132 }
133 }
134
135 fscache_stat(&fscache_n_acquires_ok);
136 _leave(" = %p", cookie);
137 return cookie;
138}
139EXPORT_SYMBOL(__fscache_acquire_cookie);
140
141/*
142 * acquire a non-index cookie
143 * - this must make sure the index chain is instantiated and instantiate the
144 * object representation too
145 */
146static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
147{
148 struct fscache_object *object;
149 struct fscache_cache *cache;
150 uint64_t i_size;
151 int ret;
152
153 _enter("");
154
155 cookie->flags = 1 << FSCACHE_COOKIE_UNAVAILABLE;
156
157 /* now we need to see whether the backing objects for this cookie yet
158 * exist, if not there'll be nothing to search */
159 down_read(&fscache_addremove_sem);
160
161 if (list_empty(&fscache_cache_list)) {
162 up_read(&fscache_addremove_sem);
163 _leave(" = 0 [no caches]");
164 return 0;
165 }
166
167 /* select a cache in which to store the object */
168 cache = fscache_select_cache_for_object(cookie->parent);
169 if (!cache) {
170 up_read(&fscache_addremove_sem);
171 fscache_stat(&fscache_n_acquires_no_cache);
172 _leave(" = -ENOMEDIUM [no cache]");
173 return -ENOMEDIUM;
174 }
175
176 _debug("cache %s", cache->tag->name);
177
178 cookie->flags =
179 (1 << FSCACHE_COOKIE_LOOKING_UP) |
180 (1 << FSCACHE_COOKIE_CREATING) |
181 (1 << FSCACHE_COOKIE_NO_DATA_YET);
182
183 /* ask the cache to allocate objects for this cookie and its parent
184 * chain */
185 ret = fscache_alloc_object(cache, cookie);
186 if (ret < 0) {
187 up_read(&fscache_addremove_sem);
188 _leave(" = %d", ret);
189 return ret;
190 }
191
192 /* pass on how big the object we're caching is supposed to be */
193 cookie->def->get_attr(cookie->netfs_data, &i_size);
194
195 spin_lock(&cookie->lock);
196 if (hlist_empty(&cookie->backing_objects)) {
197 spin_unlock(&cookie->lock);
198 goto unavailable;
199 }
200
201 object = hlist_entry(cookie->backing_objects.first,
202 struct fscache_object, cookie_link);
203
204 fscache_set_store_limit(object, i_size);
205
206 /* initiate the process of looking up all the objects in the chain
207 * (done by fscache_initialise_object()) */
208 fscache_enqueue_object(object);
209
210 spin_unlock(&cookie->lock);
211
212 /* we may be required to wait for lookup to complete at this point */
213 if (!fscache_defer_lookup) {
214 _debug("non-deferred lookup %p", &cookie->flags);
215 wait_on_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP,
216 fscache_wait_bit, TASK_UNINTERRUPTIBLE);
217 _debug("complete");
218 if (test_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags))
219 goto unavailable;
220 }
221
222 up_read(&fscache_addremove_sem);
223 _leave(" = 0 [deferred]");
224 return 0;
225
226unavailable:
227 up_read(&fscache_addremove_sem);
228 _leave(" = -ENOBUFS");
229 return -ENOBUFS;
230}
231
232/*
233 * recursively allocate cache object records for a cookie/cache combination
234 * - caller must be holding the addremove sem
235 */
236static int fscache_alloc_object(struct fscache_cache *cache,
237 struct fscache_cookie *cookie)
238{
239 struct fscache_object *object;
240 struct hlist_node *_n;
241 int ret;
242
243 _enter("%p,%p{%s}", cache, cookie, cookie->def->name);
244
245 spin_lock(&cookie->lock);
246 hlist_for_each_entry(object, _n, &cookie->backing_objects,
247 cookie_link) {
248 if (object->cache == cache)
249 goto object_already_extant;
250 }
251 spin_unlock(&cookie->lock);
252
253 /* ask the cache to allocate an object (we may end up with duplicate
254 * objects at this stage, but we sort that out later) */
255 fscache_stat(&fscache_n_cop_alloc_object);
256 object = cache->ops->alloc_object(cache, cookie);
257 fscache_stat_d(&fscache_n_cop_alloc_object);
258 if (IS_ERR(object)) {
259 fscache_stat(&fscache_n_object_no_alloc);
260 ret = PTR_ERR(object);
261 goto error;
262 }
263
264 fscache_stat(&fscache_n_object_alloc);
265
266 object->debug_id = atomic_inc_return(&fscache_object_debug_id);
267
268 _debug("ALLOC OBJ%x: %s {%lx}",
269 object->debug_id, cookie->def->name, object->events);
270
271 ret = fscache_alloc_object(cache, cookie->parent);
272 if (ret < 0)
273 goto error_put;
274
275 /* only attach if we managed to allocate all we needed, otherwise
276 * discard the object we just allocated and instead use the one
277 * attached to the cookie */
278 if (fscache_attach_object(cookie, object) < 0) {
279 fscache_stat(&fscache_n_cop_put_object);
280 cache->ops->put_object(object);
281 fscache_stat_d(&fscache_n_cop_put_object);
282 }
283
284 _leave(" = 0");
285 return 0;
286
287object_already_extant:
288 ret = -ENOBUFS;
289 if (object->state >= FSCACHE_OBJECT_DYING) {
290 spin_unlock(&cookie->lock);
291 goto error;
292 }
293 spin_unlock(&cookie->lock);
294 _leave(" = 0 [found]");
295 return 0;
296
297error_put:
298 fscache_stat(&fscache_n_cop_put_object);
299 cache->ops->put_object(object);
300 fscache_stat_d(&fscache_n_cop_put_object);
301error:
302 _leave(" = %d", ret);
303 return ret;
304}
305
306/*
307 * attach a cache object to a cookie
308 */
309static int fscache_attach_object(struct fscache_cookie *cookie,
310 struct fscache_object *object)
311{
312 struct fscache_object *p;
313 struct fscache_cache *cache = object->cache;
314 struct hlist_node *_n;
315 int ret;
316
317 _enter("{%s},{OBJ%x}", cookie->def->name, object->debug_id);
318
319 spin_lock(&cookie->lock);
320
321 /* there may be multiple initial creations of this object, but we only
322 * want one */
323 ret = -EEXIST;
324 hlist_for_each_entry(p, _n, &cookie->backing_objects, cookie_link) {
325 if (p->cache == object->cache) {
326 if (p->state >= FSCACHE_OBJECT_DYING)
327 ret = -ENOBUFS;
328 goto cant_attach_object;
329 }
330 }
331
332 /* pin the parent object */
333 spin_lock_nested(&cookie->parent->lock, 1);
334 hlist_for_each_entry(p, _n, &cookie->parent->backing_objects,
335 cookie_link) {
336 if (p->cache == object->cache) {
337 if (p->state >= FSCACHE_OBJECT_DYING) {
338 ret = -ENOBUFS;
339 spin_unlock(&cookie->parent->lock);
340 goto cant_attach_object;
341 }
342 object->parent = p;
343 spin_lock(&p->lock);
344 p->n_children++;
345 spin_unlock(&p->lock);
346 break;
347 }
348 }
349 spin_unlock(&cookie->parent->lock);
350
351 /* attach to the cache's object list */
352 if (list_empty(&object->cache_link)) {
353 spin_lock(&cache->object_list_lock);
354 list_add(&object->cache_link, &cache->object_list);
355 spin_unlock(&cache->object_list_lock);
356 }
357
358 /* attach to the cookie */
359 object->cookie = cookie;
360 atomic_inc(&cookie->usage);
361 hlist_add_head(&object->cookie_link, &cookie->backing_objects);
362
363 fscache_objlist_add(object);
364 ret = 0;
365
366cant_attach_object:
367 spin_unlock(&cookie->lock);
368 _leave(" = %d", ret);
369 return ret;
370}
371
372/*
373 * update the index entries backing a cookie
374 */
375void __fscache_update_cookie(struct fscache_cookie *cookie)
376{
377 struct fscache_object *object;
378 struct hlist_node *_p;
379
380 fscache_stat(&fscache_n_updates);
381
382 if (!cookie) {
383 fscache_stat(&fscache_n_updates_null);
384 _leave(" [no cookie]");
385 return;
386 }
387
388 _enter("{%s}", cookie->def->name);
389
390 BUG_ON(!cookie->def->get_aux);
391
392 spin_lock(&cookie->lock);
393
394 /* update the index entry on disk in each cache backing this cookie */
395 hlist_for_each_entry(object, _p,
396 &cookie->backing_objects, cookie_link) {
397 fscache_raise_event(object, FSCACHE_OBJECT_EV_UPDATE);
398 }
399
400 spin_unlock(&cookie->lock);
401 _leave("");
402}
403EXPORT_SYMBOL(__fscache_update_cookie);
404
405/*
406 * release a cookie back to the cache
407 * - the object will be marked as recyclable on disk if retire is true
408 * - all dependents of this cookie must have already been unregistered
409 * (indices/files/pages)
410 */
411void __fscache_relinquish_cookie(struct fscache_cookie *cookie, int retire)
412{
413 struct fscache_cache *cache;
414 struct fscache_object *object;
415 unsigned long event;
416
417 fscache_stat(&fscache_n_relinquishes);
418 if (retire)
419 fscache_stat(&fscache_n_relinquishes_retire);
420
421 if (!cookie) {
422 fscache_stat(&fscache_n_relinquishes_null);
423 _leave(" [no cookie]");
424 return;
425 }
426
427 _enter("%p{%s,%p},%d",
428 cookie, cookie->def->name, cookie->netfs_data, retire);
429
430 if (atomic_read(&cookie->n_children) != 0) {
431 printk(KERN_ERR "FS-Cache: Cookie '%s' still has children\n",
432 cookie->def->name);
433 BUG();
434 }
435
436 /* wait for the cookie to finish being instantiated (or to fail) */
437 if (test_bit(FSCACHE_COOKIE_CREATING, &cookie->flags)) {
438 fscache_stat(&fscache_n_relinquishes_waitcrt);
439 wait_on_bit(&cookie->flags, FSCACHE_COOKIE_CREATING,
440 fscache_wait_bit, TASK_UNINTERRUPTIBLE);
441 }
442
443 event = retire ? FSCACHE_OBJECT_EV_RETIRE : FSCACHE_OBJECT_EV_RELEASE;
444
445 spin_lock(&cookie->lock);
446
447 /* break links with all the active objects */
448 while (!hlist_empty(&cookie->backing_objects)) {
449 object = hlist_entry(cookie->backing_objects.first,
450 struct fscache_object,
451 cookie_link);
452
453 _debug("RELEASE OBJ%x", object->debug_id);
454
455 /* detach each cache object from the object cookie */
456 spin_lock(&object->lock);
457 hlist_del_init(&object->cookie_link);
458
459 cache = object->cache;
460 object->cookie = NULL;
461 fscache_raise_event(object, event);
462 spin_unlock(&object->lock);
463
464 if (atomic_dec_and_test(&cookie->usage))
465 /* the cookie refcount shouldn't be reduced to 0 yet */
466 BUG();
467 }
468
469 /* detach pointers back to the netfs */
470 cookie->netfs_data = NULL;
471 cookie->def = NULL;
472
473 spin_unlock(&cookie->lock);
474
475 if (cookie->parent) {
476 ASSERTCMP(atomic_read(&cookie->parent->usage), >, 0);
477 ASSERTCMP(atomic_read(&cookie->parent->n_children), >, 0);
478 atomic_dec(&cookie->parent->n_children);
479 }
480
481 /* finally dispose of the cookie */
482 ASSERTCMP(atomic_read(&cookie->usage), >, 0);
483 fscache_cookie_put(cookie);
484
485 _leave("");
486}
487EXPORT_SYMBOL(__fscache_relinquish_cookie);
488
489/*
490 * destroy a cookie
491 */
492void __fscache_cookie_put(struct fscache_cookie *cookie)
493{
494 struct fscache_cookie *parent;
495
496 _enter("%p", cookie);
497
498 for (;;) {
499 _debug("FREE COOKIE %p", cookie);
500 parent = cookie->parent;
501 BUG_ON(!hlist_empty(&cookie->backing_objects));
502 kmem_cache_free(fscache_cookie_jar, cookie);
503
504 if (!parent)
505 break;
506
507 cookie = parent;
508 BUG_ON(atomic_read(&cookie->usage) <= 0);
509 if (!atomic_dec_and_test(&cookie->usage))
510 break;
511 }
512
513 _leave("");
514}