1 /* FS-Cache object state machine handler
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
11 * See Documentation/filesystems/caching/object.txt for a description of the
12 * object state machine and the in-kernel representations.
15 #define FSCACHE_DEBUG_LEVEL COOKIE
16 #include <linux/module.h>
17 #include <linux/slab.h>
20 const char *fscache_object_states[FSCACHE_OBJECT__NSTATES] = {
21 [FSCACHE_OBJECT_INIT] = "OBJECT_INIT",
22 [FSCACHE_OBJECT_LOOKING_UP] = "OBJECT_LOOKING_UP",
23 [FSCACHE_OBJECT_CREATING] = "OBJECT_CREATING",
24 [FSCACHE_OBJECT_AVAILABLE] = "OBJECT_AVAILABLE",
25 [FSCACHE_OBJECT_ACTIVE] = "OBJECT_ACTIVE",
26 [FSCACHE_OBJECT_INVALIDATING] = "OBJECT_INVALIDATING",
27 [FSCACHE_OBJECT_UPDATING] = "OBJECT_UPDATING",
28 [FSCACHE_OBJECT_DYING] = "OBJECT_DYING",
29 [FSCACHE_OBJECT_LC_DYING] = "OBJECT_LC_DYING",
30 [FSCACHE_OBJECT_ABORT_INIT] = "OBJECT_ABORT_INIT",
31 [FSCACHE_OBJECT_RELEASING] = "OBJECT_RELEASING",
32 [FSCACHE_OBJECT_RECYCLING] = "OBJECT_RECYCLING",
33 [FSCACHE_OBJECT_WITHDRAWING] = "OBJECT_WITHDRAWING",
34 [FSCACHE_OBJECT_DEAD] = "OBJECT_DEAD",
36 EXPORT_SYMBOL(fscache_object_states);
38 const char fscache_object_states_short[FSCACHE_OBJECT__NSTATES][5] = {
39 [FSCACHE_OBJECT_INIT] = "INIT",
40 [FSCACHE_OBJECT_LOOKING_UP] = "LOOK",
41 [FSCACHE_OBJECT_CREATING] = "CRTN",
42 [FSCACHE_OBJECT_AVAILABLE] = "AVBL",
43 [FSCACHE_OBJECT_ACTIVE] = "ACTV",
44 [FSCACHE_OBJECT_INVALIDATING] = "INVL",
45 [FSCACHE_OBJECT_UPDATING] = "UPDT",
46 [FSCACHE_OBJECT_DYING] = "DYNG",
47 [FSCACHE_OBJECT_LC_DYING] = "LCDY",
48 [FSCACHE_OBJECT_ABORT_INIT] = "ABTI",
49 [FSCACHE_OBJECT_RELEASING] = "RELS",
50 [FSCACHE_OBJECT_RECYCLING] = "RCYC",
51 [FSCACHE_OBJECT_WITHDRAWING] = "WTHD",
52 [FSCACHE_OBJECT_DEAD] = "DEAD",
55 static int fscache_get_object(struct fscache_object *);
56 static void fscache_put_object(struct fscache_object *);
57 static void fscache_initialise_object(struct fscache_object *);
58 static void fscache_lookup_object(struct fscache_object *);
59 static void fscache_object_available(struct fscache_object *);
60 static void fscache_invalidate_object(struct fscache_object *);
61 static void fscache_release_object(struct fscache_object *);
62 static void fscache_withdraw_object(struct fscache_object *);
63 static void fscache_enqueue_dependents(struct fscache_object *);
64 static void fscache_dequeue_object(struct fscache_object *);
67 * we need to notify the parent when an op completes that we had outstanding
70 static inline void fscache_done_parent_op(struct fscache_object *object)
72 struct fscache_object *parent = object->parent;
74 _enter("OBJ%x {OBJ%x,%x}",
75 object->debug_id, parent->debug_id, parent->n_ops);
77 spin_lock_nested(&parent->lock, 1);
80 if (parent->n_ops == 0)
81 fscache_raise_event(parent, FSCACHE_OBJECT_EV_CLEARED);
82 spin_unlock(&parent->lock);
86 * Notify netfs of invalidation completion.
88 static inline void fscache_invalidation_complete(struct fscache_cookie *cookie)
90 if (test_and_clear_bit(FSCACHE_COOKIE_INVALIDATING, &cookie->flags))
91 wake_up_bit(&cookie->flags, FSCACHE_COOKIE_INVALIDATING);
95 * process events that have been sent to an object's state machine
96 * - initiates parent lookup
97 * - does object lookup
98 * - does object creation
99 * - does object recycling and retirement
100 * - does object withdrawal
102 static void fscache_object_state_machine(struct fscache_object *object)
104 enum fscache_object_state new_state;
105 struct fscache_cookie *cookie;
108 ASSERT(object != NULL);
110 _enter("{OBJ%x,%s,%lx}",
111 object->debug_id, fscache_object_states[object->state],
114 switch (object->state) {
115 /* wait for the parent object to become ready */
116 case FSCACHE_OBJECT_INIT:
118 FSCACHE_OBJECT_EVENTS_MASK &
119 ~(1 << FSCACHE_OBJECT_EV_CLEARED);
120 fscache_initialise_object(object);
123 /* look up the object metadata on disk */
124 case FSCACHE_OBJECT_LOOKING_UP:
125 fscache_lookup_object(object);
128 /* create the object metadata on disk */
129 case FSCACHE_OBJECT_CREATING:
130 fscache_lookup_object(object);
133 /* handle an object becoming available; start pending
134 * operations and queue dependent operations for processing */
135 case FSCACHE_OBJECT_AVAILABLE:
136 fscache_object_available(object);
139 /* normal running state */
140 case FSCACHE_OBJECT_ACTIVE:
143 /* Invalidate an object on disk */
144 case FSCACHE_OBJECT_INVALIDATING:
145 clear_bit(FSCACHE_OBJECT_EV_INVALIDATE, &object->events);
146 fscache_stat(&fscache_n_invalidates_run);
147 fscache_stat(&fscache_n_cop_invalidate_object);
148 fscache_invalidate_object(object);
149 fscache_stat_d(&fscache_n_cop_invalidate_object);
150 fscache_raise_event(object, FSCACHE_OBJECT_EV_UPDATE);
153 /* update the object metadata on disk */
154 case FSCACHE_OBJECT_UPDATING:
155 clear_bit(FSCACHE_OBJECT_EV_UPDATE, &object->events);
156 fscache_stat(&fscache_n_updates_run);
157 fscache_stat(&fscache_n_cop_update_object);
158 object->cache->ops->update_object(object);
159 fscache_stat_d(&fscache_n_cop_update_object);
162 /* handle an object dying during lookup or creation */
163 case FSCACHE_OBJECT_LC_DYING:
164 object->event_mask &= ~(1 << FSCACHE_OBJECT_EV_UPDATE);
165 fscache_stat(&fscache_n_cop_lookup_complete);
166 object->cache->ops->lookup_complete(object);
167 fscache_stat_d(&fscache_n_cop_lookup_complete);
169 spin_lock(&object->lock);
170 object->state = FSCACHE_OBJECT_DYING;
171 cookie = object->cookie;
173 if (test_and_clear_bit(FSCACHE_COOKIE_LOOKING_UP,
175 wake_up_bit(&cookie->flags,
176 FSCACHE_COOKIE_LOOKING_UP);
177 if (test_and_clear_bit(FSCACHE_COOKIE_CREATING,
179 wake_up_bit(&cookie->flags,
180 FSCACHE_COOKIE_CREATING);
182 spin_unlock(&object->lock);
184 fscache_done_parent_op(object);
186 /* wait for completion of all active operations on this object
187 * and the death of all child objects of this object */
188 case FSCACHE_OBJECT_DYING:
190 clear_bit(FSCACHE_OBJECT_EV_CLEARED, &object->events);
191 spin_lock(&object->lock);
192 _debug("dying OBJ%x {%d,%d}",
193 object->debug_id, object->n_ops, object->n_children);
194 if (object->n_ops == 0 && object->n_children == 0) {
195 object->event_mask &=
196 ~(1 << FSCACHE_OBJECT_EV_CLEARED);
197 object->event_mask |=
198 (1 << FSCACHE_OBJECT_EV_WITHDRAW) |
199 (1 << FSCACHE_OBJECT_EV_RETIRE) |
200 (1 << FSCACHE_OBJECT_EV_RELEASE) |
201 (1 << FSCACHE_OBJECT_EV_ERROR);
203 object->event_mask &=
204 ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) |
205 (1 << FSCACHE_OBJECT_EV_RETIRE) |
206 (1 << FSCACHE_OBJECT_EV_RELEASE) |
207 (1 << FSCACHE_OBJECT_EV_ERROR));
208 object->event_mask |=
209 1 << FSCACHE_OBJECT_EV_CLEARED;
211 spin_unlock(&object->lock);
212 fscache_enqueue_dependents(object);
213 fscache_start_operations(object);
214 goto terminal_transit;
216 /* handle an abort during initialisation */
217 case FSCACHE_OBJECT_ABORT_INIT:
218 _debug("handle abort init %lx", object->events);
219 object->event_mask &= ~(1 << FSCACHE_OBJECT_EV_UPDATE);
221 spin_lock(&object->lock);
222 fscache_dequeue_object(object);
224 object->state = FSCACHE_OBJECT_DYING;
225 if (test_and_clear_bit(FSCACHE_COOKIE_CREATING,
226 &object->cookie->flags))
227 wake_up_bit(&object->cookie->flags,
228 FSCACHE_COOKIE_CREATING);
229 spin_unlock(&object->lock);
232 /* handle the netfs releasing an object and possibly marking it
234 case FSCACHE_OBJECT_RELEASING:
235 case FSCACHE_OBJECT_RECYCLING:
236 object->event_mask &=
237 ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) |
238 (1 << FSCACHE_OBJECT_EV_RETIRE) |
239 (1 << FSCACHE_OBJECT_EV_RELEASE) |
240 (1 << FSCACHE_OBJECT_EV_ERROR));
241 fscache_release_object(object);
242 spin_lock(&object->lock);
243 object->state = FSCACHE_OBJECT_DEAD;
244 spin_unlock(&object->lock);
245 fscache_stat(&fscache_n_object_dead);
246 goto terminal_transit;
248 /* handle the parent cache of this object being withdrawn from
250 case FSCACHE_OBJECT_WITHDRAWING:
251 object->event_mask &=
252 ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) |
253 (1 << FSCACHE_OBJECT_EV_RETIRE) |
254 (1 << FSCACHE_OBJECT_EV_RELEASE) |
255 (1 << FSCACHE_OBJECT_EV_ERROR));
256 fscache_withdraw_object(object);
257 spin_lock(&object->lock);
258 object->state = FSCACHE_OBJECT_DEAD;
259 spin_unlock(&object->lock);
260 fscache_stat(&fscache_n_object_dead);
261 goto terminal_transit;
263 /* complain about the object being woken up once it is
265 case FSCACHE_OBJECT_DEAD:
266 printk(KERN_ERR "FS-Cache:"
267 " Unexpected event in dead state %lx\n",
268 object->events & object->event_mask);
272 printk(KERN_ERR "FS-Cache: Unknown object state %u\n",
277 /* determine the transition from a lookup state */
279 event = fls(object->events & object->event_mask) - 1;
281 case FSCACHE_OBJECT_EV_WITHDRAW:
282 case FSCACHE_OBJECT_EV_RETIRE:
283 case FSCACHE_OBJECT_EV_RELEASE:
284 case FSCACHE_OBJECT_EV_ERROR:
285 new_state = FSCACHE_OBJECT_LC_DYING;
287 case FSCACHE_OBJECT_EV_INVALIDATE:
288 new_state = FSCACHE_OBJECT_INVALIDATING;
290 case FSCACHE_OBJECT_EV_REQUEUE:
293 goto done; /* sleep until event */
295 goto unsupported_event;
298 /* determine the transition from an active state */
300 event = fls(object->events & object->event_mask) - 1;
302 case FSCACHE_OBJECT_EV_WITHDRAW:
303 case FSCACHE_OBJECT_EV_RETIRE:
304 case FSCACHE_OBJECT_EV_RELEASE:
305 case FSCACHE_OBJECT_EV_ERROR:
306 new_state = FSCACHE_OBJECT_DYING;
308 case FSCACHE_OBJECT_EV_INVALIDATE:
309 new_state = FSCACHE_OBJECT_INVALIDATING;
311 case FSCACHE_OBJECT_EV_UPDATE:
312 new_state = FSCACHE_OBJECT_UPDATING;
315 new_state = FSCACHE_OBJECT_ACTIVE;
316 goto change_state; /* sleep until event */
318 goto unsupported_event;
321 /* determine the transition from a terminal state */
323 event = fls(object->events & object->event_mask) - 1;
325 case FSCACHE_OBJECT_EV_WITHDRAW:
326 new_state = FSCACHE_OBJECT_WITHDRAWING;
328 case FSCACHE_OBJECT_EV_RETIRE:
329 new_state = FSCACHE_OBJECT_RECYCLING;
331 case FSCACHE_OBJECT_EV_RELEASE:
332 new_state = FSCACHE_OBJECT_RELEASING;
334 case FSCACHE_OBJECT_EV_ERROR:
335 new_state = FSCACHE_OBJECT_WITHDRAWING;
337 case FSCACHE_OBJECT_EV_CLEARED:
338 new_state = FSCACHE_OBJECT_DYING;
341 goto done; /* sleep until event */
343 goto unsupported_event;
347 spin_lock(&object->lock);
348 object->state = new_state;
349 spin_unlock(&object->lock);
352 _leave(" [->%s]", fscache_object_states[object->state]);
356 printk(KERN_ERR "FS-Cache:"
357 " Unsupported event %d [%lx/%lx] in state %s\n",
358 event, object->events, object->event_mask,
359 fscache_object_states[object->state]);
366 static void fscache_object_work_func(struct work_struct *work)
368 struct fscache_object *object =
369 container_of(work, struct fscache_object, work);
372 _enter("{OBJ%x}", object->debug_id);
375 fscache_object_state_machine(object);
376 fscache_hist(fscache_objs_histogram, start);
377 if (object->events & object->event_mask)
378 fscache_enqueue_object(object);
379 clear_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events);
380 fscache_put_object(object);
384 * fscache_object_init - Initialise a cache object description
385 * @object: Object description
386 * @cookie: Cookie object will be attached to
387 * @cache: Cache in which backing object will be found
389 * Initialise a cache object description to its basic values.
391 * See Documentation/filesystems/caching/backend-api.txt for a complete
394 void fscache_object_init(struct fscache_object *object,
395 struct fscache_cookie *cookie,
396 struct fscache_cache *cache)
398 atomic_inc(&cache->object_count);
400 object->state = FSCACHE_OBJECT_INIT;
401 spin_lock_init(&object->lock);
402 INIT_LIST_HEAD(&object->cache_link);
403 INIT_HLIST_NODE(&object->cookie_link);
404 INIT_WORK(&object->work, fscache_object_work_func);
405 INIT_LIST_HEAD(&object->dependents);
406 INIT_LIST_HEAD(&object->dep_link);
407 INIT_LIST_HEAD(&object->pending_ops);
408 object->n_children = 0;
409 object->n_ops = object->n_in_progress = object->n_exclusive = 0;
410 object->events = object->event_mask = 0;
412 object->store_limit = 0;
413 object->store_limit_l = 0;
414 object->cache = cache;
415 object->cookie = cookie;
416 object->parent = NULL;
418 EXPORT_SYMBOL(fscache_object_init);
421 * initialise an object
422 * - check the specified object's parent to see if we can make use of it
423 * immediately to do a creation
424 * - we may need to start the process of creating a parent and we need to wait
425 * for the parent's lookup and creation to complete if it's not there yet
426 * - an object's cookie is pinned until we clear FSCACHE_COOKIE_CREATING on the
427 * leaf-most cookies of the object and all its children
429 static void fscache_initialise_object(struct fscache_object *object)
431 struct fscache_object *parent;
434 ASSERT(object->cookie != NULL);
435 ASSERT(object->cookie->parent != NULL);
437 if (object->events & ((1 << FSCACHE_OBJECT_EV_ERROR) |
438 (1 << FSCACHE_OBJECT_EV_RELEASE) |
439 (1 << FSCACHE_OBJECT_EV_RETIRE) |
440 (1 << FSCACHE_OBJECT_EV_WITHDRAW))) {
441 _debug("abort init %lx", object->events);
442 spin_lock(&object->lock);
443 object->state = FSCACHE_OBJECT_ABORT_INIT;
444 spin_unlock(&object->lock);
448 spin_lock(&object->cookie->lock);
449 spin_lock_nested(&object->cookie->parent->lock, 1);
451 parent = object->parent;
454 set_bit(FSCACHE_OBJECT_EV_WITHDRAW, &object->events);
456 spin_lock(&object->lock);
457 spin_lock_nested(&parent->lock, 1);
458 _debug("parent %s", fscache_object_states[parent->state]);
460 if (parent->state >= FSCACHE_OBJECT_DYING) {
461 _debug("bad parent");
462 set_bit(FSCACHE_OBJECT_EV_WITHDRAW, &object->events);
463 } else if (parent->state < FSCACHE_OBJECT_AVAILABLE) {
466 /* we may get woken up in this state by child objects
467 * binding on to us, so we need to make sure we don't
468 * add ourself to the list multiple times */
469 if (list_empty(&object->dep_link)) {
470 fscache_stat(&fscache_n_cop_grab_object);
471 object->cache->ops->grab_object(object);
472 fscache_stat_d(&fscache_n_cop_grab_object);
473 list_add(&object->dep_link,
474 &parent->dependents);
476 /* fscache_acquire_non_index_cookie() uses this
477 * to wake the chain up */
478 if (parent->state == FSCACHE_OBJECT_INIT)
479 fscache_enqueue_object(parent);
485 object->lookup_jif = jiffies;
486 object->state = FSCACHE_OBJECT_LOOKING_UP;
487 set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events);
490 spin_unlock(&parent->lock);
491 spin_unlock(&object->lock);
494 spin_unlock(&object->cookie->parent->lock);
495 spin_unlock(&object->cookie->lock);
500 * look an object up in the cache from which it was allocated
501 * - we hold an "access lock" on the parent object, so the parent object cannot
502 * be withdrawn by either party till we've finished
503 * - an object's cookie is pinned until we clear FSCACHE_COOKIE_CREATING on the
504 * leaf-most cookies of the object and all its children
506 static void fscache_lookup_object(struct fscache_object *object)
508 struct fscache_cookie *cookie = object->cookie;
509 struct fscache_object *parent;
514 parent = object->parent;
515 ASSERT(parent != NULL);
516 ASSERTCMP(parent->n_ops, >, 0);
517 ASSERTCMP(parent->n_obj_ops, >, 0);
519 /* make sure the parent is still available */
520 ASSERTCMP(parent->state, >=, FSCACHE_OBJECT_AVAILABLE);
522 if (parent->state >= FSCACHE_OBJECT_DYING ||
523 test_bit(FSCACHE_IOERROR, &object->cache->flags)) {
524 _debug("unavailable");
525 set_bit(FSCACHE_OBJECT_EV_WITHDRAW, &object->events);
530 _debug("LOOKUP \"%s/%s\" in \"%s\"",
531 parent->cookie->def->name, cookie->def->name,
532 object->cache->tag->name);
534 fscache_stat(&fscache_n_object_lookups);
535 fscache_stat(&fscache_n_cop_lookup_object);
536 ret = object->cache->ops->lookup_object(object);
537 fscache_stat_d(&fscache_n_cop_lookup_object);
539 if (test_bit(FSCACHE_OBJECT_EV_ERROR, &object->events))
540 set_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags);
542 if (ret == -ETIMEDOUT) {
543 /* probably stuck behind another object, so move this one to
544 * the back of the queue */
545 fscache_stat(&fscache_n_object_lookups_timed_out);
546 set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events);
553 * fscache_object_lookup_negative - Note negative cookie lookup
554 * @object: Object pointing to cookie to mark
556 * Note negative lookup, permitting those waiting to read data from an already
557 * existing backing object to continue as there's no data for them to read.
559 void fscache_object_lookup_negative(struct fscache_object *object)
561 struct fscache_cookie *cookie = object->cookie;
564 object->debug_id, fscache_object_states[object->state]);
566 spin_lock(&object->lock);
567 if (object->state == FSCACHE_OBJECT_LOOKING_UP) {
568 fscache_stat(&fscache_n_object_lookups_negative);
570 /* transit here to allow write requests to begin stacking up
571 * and read requests to begin returning ENODATA */
572 object->state = FSCACHE_OBJECT_CREATING;
573 spin_unlock(&object->lock);
575 set_bit(FSCACHE_COOKIE_PENDING_FILL, &cookie->flags);
576 set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags);
578 _debug("wake up lookup %p", &cookie->flags);
579 smp_mb__before_clear_bit();
580 clear_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags);
581 smp_mb__after_clear_bit();
582 wake_up_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP);
583 set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events);
585 ASSERTCMP(object->state, ==, FSCACHE_OBJECT_CREATING);
586 spin_unlock(&object->lock);
591 EXPORT_SYMBOL(fscache_object_lookup_negative);
594 * fscache_obtained_object - Note successful object lookup or creation
595 * @object: Object pointing to cookie to mark
597 * Note successful lookup and/or creation, permitting those waiting to write
598 * data to a backing object to continue.
600 * Note that after calling this, an object's cookie may be relinquished by the
601 * netfs, and so must be accessed with object lock held.
603 void fscache_obtained_object(struct fscache_object *object)
605 struct fscache_cookie *cookie = object->cookie;
608 object->debug_id, fscache_object_states[object->state]);
610 /* if we were still looking up, then we must have a positive lookup
611 * result, in which case there may be data available */
612 spin_lock(&object->lock);
613 if (object->state == FSCACHE_OBJECT_LOOKING_UP) {
614 fscache_stat(&fscache_n_object_lookups_positive);
616 clear_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags);
618 object->state = FSCACHE_OBJECT_AVAILABLE;
619 spin_unlock(&object->lock);
621 smp_mb__before_clear_bit();
622 clear_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags);
623 smp_mb__after_clear_bit();
624 wake_up_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP);
625 set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events);
627 ASSERTCMP(object->state, ==, FSCACHE_OBJECT_CREATING);
628 fscache_stat(&fscache_n_object_created);
630 object->state = FSCACHE_OBJECT_AVAILABLE;
631 spin_unlock(&object->lock);
632 set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events);
636 if (test_and_clear_bit(FSCACHE_COOKIE_CREATING, &cookie->flags))
637 wake_up_bit(&cookie->flags, FSCACHE_COOKIE_CREATING);
641 EXPORT_SYMBOL(fscache_obtained_object);
644 * handle an object that has just become available
646 static void fscache_object_available(struct fscache_object *object)
648 _enter("{OBJ%x}", object->debug_id);
650 spin_lock(&object->lock);
652 if (object->cookie &&
653 test_and_clear_bit(FSCACHE_COOKIE_CREATING, &object->cookie->flags))
654 wake_up_bit(&object->cookie->flags, FSCACHE_COOKIE_CREATING);
656 fscache_done_parent_op(object);
657 if (object->n_in_progress == 0) {
658 if (object->n_ops > 0) {
659 ASSERTCMP(object->n_ops, >=, object->n_obj_ops);
660 fscache_start_operations(object);
662 ASSERT(list_empty(&object->pending_ops));
665 spin_unlock(&object->lock);
667 fscache_stat(&fscache_n_cop_lookup_complete);
668 object->cache->ops->lookup_complete(object);
669 fscache_stat_d(&fscache_n_cop_lookup_complete);
670 fscache_enqueue_dependents(object);
672 fscache_hist(fscache_obj_instantiate_histogram, object->lookup_jif);
673 fscache_stat(&fscache_n_object_avail);
679 * drop an object's attachments
681 static void fscache_drop_object(struct fscache_object *object)
683 struct fscache_object *parent = object->parent;
684 struct fscache_cache *cache = object->cache;
686 _enter("{OBJ%x,%d}", object->debug_id, object->n_children);
688 ASSERTCMP(object->cookie, ==, NULL);
689 ASSERT(hlist_unhashed(&object->cookie_link));
691 spin_lock(&cache->object_list_lock);
692 list_del_init(&object->cache_link);
693 spin_unlock(&cache->object_list_lock);
695 fscache_stat(&fscache_n_cop_drop_object);
696 cache->ops->drop_object(object);
697 fscache_stat_d(&fscache_n_cop_drop_object);
700 _debug("release parent OBJ%x {%d}",
701 parent->debug_id, parent->n_children);
703 spin_lock(&parent->lock);
704 parent->n_children--;
705 if (parent->n_children == 0)
706 fscache_raise_event(parent, FSCACHE_OBJECT_EV_CLEARED);
707 spin_unlock(&parent->lock);
708 object->parent = NULL;
711 /* this just shifts the object release to the work processor */
712 fscache_put_object(object);
718 * release or recycle an object that the netfs has discarded
720 static void fscache_release_object(struct fscache_object *object)
724 fscache_drop_object(object);
728 * withdraw an object from active service
730 static void fscache_withdraw_object(struct fscache_object *object)
732 struct fscache_cookie *cookie;
737 spin_lock(&object->lock);
738 cookie = object->cookie;
740 /* need to get the cookie lock before the object lock, starting
741 * from the object pointer */
742 atomic_inc(&cookie->usage);
743 spin_unlock(&object->lock);
746 spin_lock(&cookie->lock);
747 spin_lock(&object->lock);
749 if (object->cookie == cookie) {
750 hlist_del_init(&object->cookie_link);
751 object->cookie = NULL;
752 fscache_invalidation_complete(cookie);
755 spin_unlock(&cookie->lock);
756 fscache_cookie_put(cookie);
758 fscache_cookie_put(cookie);
761 spin_unlock(&object->lock);
763 fscache_drop_object(object);
767 * withdraw an object from active service at the behest of the cache
768 * - need break the links to a cached object cookie
769 * - called under two situations:
770 * (1) recycler decides to reclaim an in-use object
771 * (2) a cache is unmounted
772 * - have to take care as the cookie can be being relinquished by the netfs
774 * - the object is pinned by the caller holding a refcount on it
776 void fscache_withdrawing_object(struct fscache_cache *cache,
777 struct fscache_object *object)
779 bool enqueue = false;
781 _enter(",OBJ%x", object->debug_id);
783 spin_lock(&object->lock);
784 if (object->state < FSCACHE_OBJECT_WITHDRAWING) {
785 object->state = FSCACHE_OBJECT_WITHDRAWING;
788 spin_unlock(&object->lock);
791 fscache_enqueue_object(object);
797 * get a ref on an object
799 static int fscache_get_object(struct fscache_object *object)
803 fscache_stat(&fscache_n_cop_grab_object);
804 ret = object->cache->ops->grab_object(object) ? 0 : -EAGAIN;
805 fscache_stat_d(&fscache_n_cop_grab_object);
810 * discard a ref on a work item
812 static void fscache_put_object(struct fscache_object *object)
814 fscache_stat(&fscache_n_cop_put_object);
815 object->cache->ops->put_object(object);
816 fscache_stat_d(&fscache_n_cop_put_object);
820 * enqueue an object for metadata-type processing
822 void fscache_enqueue_object(struct fscache_object *object)
824 _enter("{OBJ%x}", object->debug_id);
826 if (fscache_get_object(object) >= 0) {
827 wait_queue_head_t *cong_wq =
828 &get_cpu_var(fscache_object_cong_wait);
830 if (queue_work(fscache_object_wq, &object->work)) {
831 if (fscache_object_congested())
834 fscache_put_object(object);
836 put_cpu_var(fscache_object_cong_wait);
841 * fscache_object_sleep_till_congested - Sleep until object wq is congested
842 * @timoutp: Scheduler sleep timeout
844 * Allow an object handler to sleep until the object workqueue is congested.
846 * The caller must set up a wake up event before calling this and must have set
847 * the appropriate sleep mode (such as TASK_UNINTERRUPTIBLE) and tested its own
848 * condition before calling this function as no test is made here.
850 * %true is returned if the object wq is congested, %false otherwise.
852 bool fscache_object_sleep_till_congested(signed long *timeoutp)
854 wait_queue_head_t *cong_wq = &__get_cpu_var(fscache_object_cong_wait);
857 if (fscache_object_congested())
860 add_wait_queue_exclusive(cong_wq, &wait);
861 if (!fscache_object_congested())
862 *timeoutp = schedule_timeout(*timeoutp);
863 finish_wait(cong_wq, &wait);
865 return fscache_object_congested();
867 EXPORT_SYMBOL_GPL(fscache_object_sleep_till_congested);
870 * enqueue the dependents of an object for metadata-type processing
871 * - the caller must hold the object's lock
872 * - this may cause an already locked object to wind up being processed again
874 static void fscache_enqueue_dependents(struct fscache_object *object)
876 struct fscache_object *dep;
878 _enter("{OBJ%x}", object->debug_id);
880 if (list_empty(&object->dependents))
883 spin_lock(&object->lock);
885 while (!list_empty(&object->dependents)) {
886 dep = list_entry(object->dependents.next,
887 struct fscache_object, dep_link);
888 list_del_init(&dep->dep_link);
891 /* sort onto appropriate lists */
892 fscache_enqueue_object(dep);
893 fscache_put_object(dep);
895 if (!list_empty(&object->dependents))
896 cond_resched_lock(&object->lock);
899 spin_unlock(&object->lock);
903 * remove an object from whatever queue it's waiting on
904 * - the caller must hold object->lock
906 void fscache_dequeue_object(struct fscache_object *object)
908 _enter("{OBJ%x}", object->debug_id);
910 if (!list_empty(&object->dep_link)) {
911 spin_lock(&object->parent->lock);
912 list_del_init(&object->dep_link);
913 spin_unlock(&object->parent->lock);
920 * fscache_check_aux - Ask the netfs whether an object on disk is still valid
921 * @object: The object to ask about
922 * @data: The auxiliary data for the object
923 * @datalen: The size of the auxiliary data
925 * This function consults the netfs about the coherency state of an object
927 enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
928 const void *data, uint16_t datalen)
930 enum fscache_checkaux result;
932 if (!object->cookie->def->check_aux) {
933 fscache_stat(&fscache_n_checkaux_none);
934 return FSCACHE_CHECKAUX_OKAY;
937 result = object->cookie->def->check_aux(object->cookie->netfs_data,
940 /* entry okay as is */
941 case FSCACHE_CHECKAUX_OKAY:
942 fscache_stat(&fscache_n_checkaux_okay);
945 /* entry requires update */
946 case FSCACHE_CHECKAUX_NEEDS_UPDATE:
947 fscache_stat(&fscache_n_checkaux_update);
950 /* entry requires deletion */
951 case FSCACHE_CHECKAUX_OBSOLETE:
952 fscache_stat(&fscache_n_checkaux_obsolete);
961 EXPORT_SYMBOL(fscache_check_aux);
964 * Asynchronously invalidate an object.
966 static void fscache_invalidate_object(struct fscache_object *object)
968 struct fscache_operation *op;
969 struct fscache_cookie *cookie = object->cookie;
971 _enter("{OBJ%x}", object->debug_id);
973 /* Reject any new read/write ops and abort any that are pending. */
974 fscache_invalidate_writes(cookie);
975 clear_bit(FSCACHE_OBJECT_PENDING_WRITE, &object->flags);
976 fscache_cancel_all_ops(object);
978 /* Now we have to wait for in-progress reads and writes */
979 op = kzalloc(sizeof(*op), GFP_KERNEL);
981 fscache_raise_event(object, FSCACHE_OBJECT_EV_ERROR);
986 fscache_operation_init(op, object->cache->ops->invalidate_object, NULL);
987 op->flags = FSCACHE_OP_ASYNC | (1 << FSCACHE_OP_EXCLUSIVE);
989 spin_lock(&cookie->lock);
990 if (fscache_submit_exclusive_op(object, op) < 0)
991 goto submit_op_failed;
992 spin_unlock(&cookie->lock);
993 fscache_put_operation(op);
995 /* Once we've completed the invalidation, we know there will be no data
996 * stored in the cache and thus we can reinstate the data-check-skip
999 set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags);
1001 /* We can allow read and write requests to come in once again. They'll
1002 * queue up behind our exclusive invalidation operation.
1004 fscache_invalidation_complete(cookie);
1009 spin_unlock(&cookie->lock);
1011 fscache_raise_event(object, FSCACHE_OBJECT_EV_ERROR);