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>
18 #include <linux/prefetch.h>
21 static const struct fscache_state
*fscache_abort_initialisation(struct fscache_object
*, int);
22 static const struct fscache_state
*fscache_kill_dependents(struct fscache_object
*, int);
23 static const struct fscache_state
*fscache_drop_object(struct fscache_object
*, int);
24 static const struct fscache_state
*fscache_initialise_object(struct fscache_object
*, int);
25 static const struct fscache_state
*fscache_invalidate_object(struct fscache_object
*, int);
26 static const struct fscache_state
*fscache_jumpstart_dependents(struct fscache_object
*, int);
27 static const struct fscache_state
*fscache_kill_object(struct fscache_object
*, int);
28 static const struct fscache_state
*fscache_lookup_failure(struct fscache_object
*, int);
29 static const struct fscache_state
*fscache_look_up_object(struct fscache_object
*, int);
30 static const struct fscache_state
*fscache_object_available(struct fscache_object
*, int);
31 static const struct fscache_state
*fscache_parent_ready(struct fscache_object
*, int);
32 static const struct fscache_state
*fscache_update_object(struct fscache_object
*, int);
34 #define __STATE_NAME(n) fscache_osm_##n
35 #define STATE(n) (&__STATE_NAME(n))
38 * Define a work state. Work states are execution states. No event processing
39 * is performed by them. The function attached to a work state returns a
40 * pointer indicating the next state to which the state machine should
41 * transition. Returning NO_TRANSIT repeats the current state, but goes back
42 * to the scheduler first.
44 #define WORK_STATE(n, sn, f) \
45 const struct fscache_state __STATE_NAME(n) = { \
52 * Returns from work states.
54 #define transit_to(state) ({ prefetch(&STATE(state)->work); STATE(state); })
56 #define NO_TRANSIT ((struct fscache_state *)NULL)
59 * Define a wait state. Wait states are event processing states. No execution
60 * is performed by them. Wait states are just tables of "if event X occurs,
61 * clear it and transition to state Y". The dispatcher returns to the
62 * scheduler if none of the events in which the wait state has an interest are
65 #define WAIT_STATE(n, sn, ...) \
66 const struct fscache_state __STATE_NAME(n) = { \
70 .transitions = { __VA_ARGS__, { 0, NULL } } \
73 #define TRANSIT_TO(state, emask) \
74 { .events = (emask), .transit_to = STATE(state) }
77 * The object state machine.
79 static WORK_STATE(INIT_OBJECT
, "INIT", fscache_initialise_object
);
80 static WORK_STATE(PARENT_READY
, "PRDY", fscache_parent_ready
);
81 static WORK_STATE(ABORT_INIT
, "ABRT", fscache_abort_initialisation
);
82 static WORK_STATE(LOOK_UP_OBJECT
, "LOOK", fscache_look_up_object
);
83 static WORK_STATE(CREATE_OBJECT
, "CRTO", fscache_look_up_object
);
84 static WORK_STATE(OBJECT_AVAILABLE
, "AVBL", fscache_object_available
);
85 static WORK_STATE(JUMPSTART_DEPS
, "JUMP", fscache_jumpstart_dependents
);
87 static WORK_STATE(INVALIDATE_OBJECT
, "INVL", fscache_invalidate_object
);
88 static WORK_STATE(UPDATE_OBJECT
, "UPDT", fscache_update_object
);
90 static WORK_STATE(LOOKUP_FAILURE
, "LCFL", fscache_lookup_failure
);
91 static WORK_STATE(KILL_OBJECT
, "KILL", fscache_kill_object
);
92 static WORK_STATE(KILL_DEPENDENTS
, "KDEP", fscache_kill_dependents
);
93 static WORK_STATE(DROP_OBJECT
, "DROP", fscache_drop_object
);
94 static WORK_STATE(OBJECT_DEAD
, "DEAD", (void*)2UL);
96 static WAIT_STATE(WAIT_FOR_INIT
, "?INI",
97 TRANSIT_TO(INIT_OBJECT
, 1 << FSCACHE_OBJECT_EV_NEW_CHILD
));
99 static WAIT_STATE(WAIT_FOR_PARENT
, "?PRN",
100 TRANSIT_TO(PARENT_READY
, 1 << FSCACHE_OBJECT_EV_PARENT_READY
));
102 static WAIT_STATE(WAIT_FOR_CMD
, "?CMD",
103 TRANSIT_TO(INVALIDATE_OBJECT
, 1 << FSCACHE_OBJECT_EV_INVALIDATE
),
104 TRANSIT_TO(UPDATE_OBJECT
, 1 << FSCACHE_OBJECT_EV_UPDATE
),
105 TRANSIT_TO(JUMPSTART_DEPS
, 1 << FSCACHE_OBJECT_EV_NEW_CHILD
));
107 static WAIT_STATE(WAIT_FOR_CLEARANCE
, "?CLR",
108 TRANSIT_TO(KILL_OBJECT
, 1 << FSCACHE_OBJECT_EV_CLEARED
));
111 * Out-of-band event transition tables. These are for handling unexpected
112 * events, such as an I/O error. If an OOB event occurs, the state machine
113 * clears and disables the event and forces a transition to the nominated work
114 * state (acurrently executing work states will complete first).
116 * In such a situation, object->state remembers the state the machine should
117 * have been in/gone to and returning NO_TRANSIT returns to that.
119 static const struct fscache_transition fscache_osm_init_oob
[] = {
120 TRANSIT_TO(ABORT_INIT
,
121 (1 << FSCACHE_OBJECT_EV_ERROR
) |
122 (1 << FSCACHE_OBJECT_EV_KILL
)),
126 static const struct fscache_transition fscache_osm_lookup_oob
[] = {
127 TRANSIT_TO(LOOKUP_FAILURE
,
128 (1 << FSCACHE_OBJECT_EV_ERROR
) |
129 (1 << FSCACHE_OBJECT_EV_KILL
)),
133 static const struct fscache_transition fscache_osm_run_oob
[] = {
134 TRANSIT_TO(KILL_OBJECT
,
135 (1 << FSCACHE_OBJECT_EV_ERROR
) |
136 (1 << FSCACHE_OBJECT_EV_KILL
)),
140 static int fscache_get_object(struct fscache_object
*);
141 static void fscache_put_object(struct fscache_object
*);
142 static bool fscache_enqueue_dependents(struct fscache_object
*, int);
143 static void fscache_dequeue_object(struct fscache_object
*);
146 * we need to notify the parent when an op completes that we had outstanding
149 static inline void fscache_done_parent_op(struct fscache_object
*object
)
151 struct fscache_object
*parent
= object
->parent
;
153 _enter("OBJ%x {OBJ%x,%x}",
154 object
->debug_id
, parent
->debug_id
, parent
->n_ops
);
156 spin_lock_nested(&parent
->lock
, 1);
159 if (parent
->n_ops
== 0)
160 fscache_raise_event(parent
, FSCACHE_OBJECT_EV_CLEARED
);
161 spin_unlock(&parent
->lock
);
165 * Object state machine dispatcher.
167 static void fscache_object_sm_dispatcher(struct fscache_object
*object
)
169 const struct fscache_transition
*t
;
170 const struct fscache_state
*state
, *new_state
;
171 unsigned long events
, event_mask
;
174 ASSERT(object
!= NULL
);
176 _enter("{OBJ%x,%s,%lx}",
177 object
->debug_id
, object
->state
->name
, object
->events
);
179 event_mask
= object
->event_mask
;
181 object
->event_mask
= 0; /* Mask normal event handling */
182 state
= object
->state
;
184 events
= object
->events
;
186 /* Handle any out-of-band events (typically an error) */
187 if (events
& object
->oob_event_mask
) {
188 _debug("{OBJ%x} oob %lx",
189 object
->debug_id
, events
& object
->oob_event_mask
);
190 for (t
= object
->oob_table
; t
->events
; t
++) {
191 if (events
& t
->events
) {
192 state
= t
->transit_to
;
193 ASSERT(state
->work
!= NULL
);
194 event
= fls(events
& t
->events
) - 1;
195 __clear_bit(event
, &object
->oob_event_mask
);
196 clear_bit(event
, &object
->events
);
197 goto execute_work_state
;
202 /* Wait states are just transition tables */
204 if (events
& event_mask
) {
205 for (t
= state
->transitions
; t
->events
; t
++) {
206 if (events
& t
->events
) {
207 new_state
= t
->transit_to
;
208 event
= fls(events
& t
->events
) - 1;
209 clear_bit(event
, &object
->events
);
210 _debug("{OBJ%x} ev %d: %s -> %s",
211 object
->debug_id
, event
,
212 state
->name
, new_state
->name
);
213 object
->state
= state
= new_state
;
214 goto execute_work_state
;
218 /* The event mask didn't include all the tabled bits */
221 /* Randomly woke up */
226 _debug("{OBJ%x} exec %s", object
->debug_id
, state
->name
);
228 new_state
= state
->work(object
, event
);
230 if (new_state
== NO_TRANSIT
) {
231 _debug("{OBJ%x} %s notrans", object
->debug_id
, state
->name
);
232 fscache_enqueue_object(object
);
233 event_mask
= object
->oob_event_mask
;
237 _debug("{OBJ%x} %s -> %s",
238 object
->debug_id
, state
->name
, new_state
->name
);
239 object
->state
= state
= new_state
;
242 if (unlikely(state
->work
== ((void *)2UL))) {
249 /* Transited to wait state */
250 event_mask
= object
->oob_event_mask
;
251 for (t
= state
->transitions
; t
->events
; t
++)
252 event_mask
|= t
->events
;
255 object
->event_mask
= event_mask
;
257 events
= object
->events
;
258 if (events
& event_mask
)
260 _leave(" [msk %lx]", event_mask
);
266 static void fscache_object_work_func(struct work_struct
*work
)
268 struct fscache_object
*object
=
269 container_of(work
, struct fscache_object
, work
);
272 _enter("{OBJ%x}", object
->debug_id
);
275 fscache_object_sm_dispatcher(object
);
276 fscache_hist(fscache_objs_histogram
, start
);
277 fscache_put_object(object
);
281 * fscache_object_init - Initialise a cache object description
282 * @object: Object description
283 * @cookie: Cookie object will be attached to
284 * @cache: Cache in which backing object will be found
286 * Initialise a cache object description to its basic values.
288 * See Documentation/filesystems/caching/backend-api.txt for a complete
291 void fscache_object_init(struct fscache_object
*object
,
292 struct fscache_cookie
*cookie
,
293 struct fscache_cache
*cache
)
295 const struct fscache_transition
*t
;
297 atomic_inc(&cache
->object_count
);
299 object
->state
= STATE(WAIT_FOR_INIT
);
300 object
->oob_table
= fscache_osm_init_oob
;
301 object
->flags
= 1 << FSCACHE_OBJECT_IS_LIVE
;
302 spin_lock_init(&object
->lock
);
303 INIT_LIST_HEAD(&object
->cache_link
);
304 INIT_HLIST_NODE(&object
->cookie_link
);
305 INIT_WORK(&object
->work
, fscache_object_work_func
);
306 INIT_LIST_HEAD(&object
->dependents
);
307 INIT_LIST_HEAD(&object
->dep_link
);
308 INIT_LIST_HEAD(&object
->pending_ops
);
309 object
->n_children
= 0;
310 object
->n_ops
= object
->n_in_progress
= object
->n_exclusive
= 0;
312 object
->store_limit
= 0;
313 object
->store_limit_l
= 0;
314 object
->cache
= cache
;
315 object
->cookie
= cookie
;
316 object
->parent
= NULL
;
318 object
->oob_event_mask
= 0;
319 for (t
= object
->oob_table
; t
->events
; t
++)
320 object
->oob_event_mask
|= t
->events
;
321 object
->event_mask
= object
->oob_event_mask
;
322 for (t
= object
->state
->transitions
; t
->events
; t
++)
323 object
->event_mask
|= t
->events
;
325 EXPORT_SYMBOL(fscache_object_init
);
328 * Abort object initialisation before we start it.
330 static const struct fscache_state
*fscache_abort_initialisation(struct fscache_object
*object
,
333 _enter("{OBJ%x},%d", object
->debug_id
, event
);
335 object
->oob_event_mask
= 0;
336 fscache_dequeue_object(object
);
337 return transit_to(KILL_OBJECT
);
341 * initialise an object
342 * - check the specified object's parent to see if we can make use of it
343 * immediately to do a creation
344 * - we may need to start the process of creating a parent and we need to wait
345 * for the parent's lookup and creation to complete if it's not there yet
347 static const struct fscache_state
*fscache_initialise_object(struct fscache_object
*object
,
350 struct fscache_object
*parent
;
353 _enter("{OBJ%x},%d", object
->debug_id
, event
);
355 ASSERT(list_empty(&object
->dep_link
));
357 parent
= object
->parent
;
359 _leave(" [no parent]");
360 return transit_to(DROP_OBJECT
);
363 _debug("parent: %s of:%lx", parent
->state
->name
, parent
->flags
);
365 if (fscache_object_is_dying(parent
)) {
366 _leave(" [bad parent]");
367 return transit_to(DROP_OBJECT
);
370 if (fscache_object_is_available(parent
)) {
372 return transit_to(PARENT_READY
);
377 spin_lock(&parent
->lock
);
378 fscache_stat(&fscache_n_cop_grab_object
);
380 if (fscache_object_is_live(parent
) &&
381 object
->cache
->ops
->grab_object(object
)) {
382 list_add(&object
->dep_link
, &parent
->dependents
);
385 fscache_stat_d(&fscache_n_cop_grab_object
);
386 spin_unlock(&parent
->lock
);
388 _leave(" [grab failed]");
389 return transit_to(DROP_OBJECT
);
392 /* fscache_acquire_non_index_cookie() uses this
393 * to wake the chain up */
394 fscache_raise_event(parent
, FSCACHE_OBJECT_EV_NEW_CHILD
);
396 return transit_to(WAIT_FOR_PARENT
);
400 * Once the parent object is ready, we should kick off our lookup op.
402 static const struct fscache_state
*fscache_parent_ready(struct fscache_object
*object
,
405 struct fscache_object
*parent
= object
->parent
;
407 _enter("{OBJ%x},%d", object
->debug_id
, event
);
409 ASSERT(parent
!= NULL
);
411 spin_lock(&parent
->lock
);
414 object
->lookup_jif
= jiffies
;
415 spin_unlock(&parent
->lock
);
418 return transit_to(LOOK_UP_OBJECT
);
422 * look an object up in the cache from which it was allocated
423 * - we hold an "access lock" on the parent object, so the parent object cannot
424 * be withdrawn by either party till we've finished
426 static const struct fscache_state
*fscache_look_up_object(struct fscache_object
*object
,
429 struct fscache_cookie
*cookie
= object
->cookie
;
430 struct fscache_object
*parent
= object
->parent
;
433 _enter("{OBJ%x},%d", object
->debug_id
, event
);
435 object
->oob_table
= fscache_osm_lookup_oob
;
437 ASSERT(parent
!= NULL
);
438 ASSERTCMP(parent
->n_ops
, >, 0);
439 ASSERTCMP(parent
->n_obj_ops
, >, 0);
441 /* make sure the parent is still available */
442 ASSERT(fscache_object_is_available(parent
));
444 if (fscache_object_is_dying(parent
) ||
445 test_bit(FSCACHE_IOERROR
, &object
->cache
->flags
) ||
446 !fscache_use_cookie(object
)) {
447 _leave(" [unavailable]");
448 return transit_to(LOOKUP_FAILURE
);
451 _debug("LOOKUP \"%s\" in \"%s\"",
452 cookie
->def
->name
, object
->cache
->tag
->name
);
454 fscache_stat(&fscache_n_object_lookups
);
455 fscache_stat(&fscache_n_cop_lookup_object
);
456 ret
= object
->cache
->ops
->lookup_object(object
);
457 fscache_stat_d(&fscache_n_cop_lookup_object
);
459 fscache_unuse_cookie(object
);
461 if (ret
== -ETIMEDOUT
) {
462 /* probably stuck behind another object, so move this one to
463 * the back of the queue */
464 fscache_stat(&fscache_n_object_lookups_timed_out
);
465 _leave(" [timeout]");
471 return transit_to(LOOKUP_FAILURE
);
475 return transit_to(OBJECT_AVAILABLE
);
479 * fscache_object_lookup_negative - Note negative cookie lookup
480 * @object: Object pointing to cookie to mark
482 * Note negative lookup, permitting those waiting to read data from an already
483 * existing backing object to continue as there's no data for them to read.
485 void fscache_object_lookup_negative(struct fscache_object
*object
)
487 struct fscache_cookie
*cookie
= object
->cookie
;
489 _enter("{OBJ%x,%s}", object
->debug_id
, object
->state
->name
);
491 if (!test_and_set_bit(FSCACHE_OBJECT_IS_LOOKED_UP
, &object
->flags
)) {
492 fscache_stat(&fscache_n_object_lookups_negative
);
494 /* Allow write requests to begin stacking up and read requests to begin
497 set_bit(FSCACHE_COOKIE_NO_DATA_YET
, &cookie
->flags
);
499 _debug("wake up lookup %p", &cookie
->flags
);
500 clear_bit_unlock(FSCACHE_COOKIE_LOOKING_UP
, &cookie
->flags
);
501 wake_up_bit(&cookie
->flags
, FSCACHE_COOKIE_LOOKING_UP
);
505 EXPORT_SYMBOL(fscache_object_lookup_negative
);
508 * fscache_obtained_object - Note successful object lookup or creation
509 * @object: Object pointing to cookie to mark
511 * Note successful lookup and/or creation, permitting those waiting to write
512 * data to a backing object to continue.
514 * Note that after calling this, an object's cookie may be relinquished by the
515 * netfs, and so must be accessed with object lock held.
517 void fscache_obtained_object(struct fscache_object
*object
)
519 struct fscache_cookie
*cookie
= object
->cookie
;
521 _enter("{OBJ%x,%s}", object
->debug_id
, object
->state
->name
);
523 /* if we were still looking up, then we must have a positive lookup
524 * result, in which case there may be data available */
525 if (!test_and_set_bit(FSCACHE_OBJECT_IS_LOOKED_UP
, &object
->flags
)) {
526 fscache_stat(&fscache_n_object_lookups_positive
);
528 /* We do (presumably) have data */
529 clear_bit_unlock(FSCACHE_COOKIE_NO_DATA_YET
, &cookie
->flags
);
531 /* Allow write requests to begin stacking up and read requests
532 * to begin shovelling data.
534 clear_bit_unlock(FSCACHE_COOKIE_LOOKING_UP
, &cookie
->flags
);
535 wake_up_bit(&cookie
->flags
, FSCACHE_COOKIE_LOOKING_UP
);
537 fscache_stat(&fscache_n_object_created
);
540 set_bit(FSCACHE_OBJECT_IS_AVAILABLE
, &object
->flags
);
543 EXPORT_SYMBOL(fscache_obtained_object
);
546 * handle an object that has just become available
548 static const struct fscache_state
*fscache_object_available(struct fscache_object
*object
,
551 _enter("{OBJ%x},%d", object
->debug_id
, event
);
553 object
->oob_table
= fscache_osm_run_oob
;
555 spin_lock(&object
->lock
);
557 fscache_done_parent_op(object
);
558 if (object
->n_in_progress
== 0) {
559 if (object
->n_ops
> 0) {
560 ASSERTCMP(object
->n_ops
, >=, object
->n_obj_ops
);
561 fscache_start_operations(object
);
563 ASSERT(list_empty(&object
->pending_ops
));
566 spin_unlock(&object
->lock
);
568 fscache_stat(&fscache_n_cop_lookup_complete
);
569 object
->cache
->ops
->lookup_complete(object
);
570 fscache_stat_d(&fscache_n_cop_lookup_complete
);
572 fscache_hist(fscache_obj_instantiate_histogram
, object
->lookup_jif
);
573 fscache_stat(&fscache_n_object_avail
);
576 return transit_to(JUMPSTART_DEPS
);
580 * Wake up this object's dependent objects now that we've become available.
582 static const struct fscache_state
*fscache_jumpstart_dependents(struct fscache_object
*object
,
585 _enter("{OBJ%x},%d", object
->debug_id
, event
);
587 if (!fscache_enqueue_dependents(object
, FSCACHE_OBJECT_EV_PARENT_READY
))
588 return NO_TRANSIT
; /* Not finished; requeue */
589 return transit_to(WAIT_FOR_CMD
);
593 * Handle lookup or creation failute.
595 static const struct fscache_state
*fscache_lookup_failure(struct fscache_object
*object
,
598 struct fscache_cookie
*cookie
;
600 _enter("{OBJ%x},%d", object
->debug_id
, event
);
602 object
->oob_event_mask
= 0;
604 fscache_stat(&fscache_n_cop_lookup_complete
);
605 object
->cache
->ops
->lookup_complete(object
);
606 fscache_stat_d(&fscache_n_cop_lookup_complete
);
608 cookie
= object
->cookie
;
609 set_bit(FSCACHE_COOKIE_UNAVAILABLE
, &cookie
->flags
);
610 if (test_and_clear_bit(FSCACHE_COOKIE_LOOKING_UP
, &cookie
->flags
))
611 wake_up_bit(&cookie
->flags
, FSCACHE_COOKIE_LOOKING_UP
);
613 fscache_done_parent_op(object
);
614 return transit_to(KILL_OBJECT
);
618 * Wait for completion of all active operations on this object and the death of
619 * all child objects of this object.
621 static const struct fscache_state
*fscache_kill_object(struct fscache_object
*object
,
624 _enter("{OBJ%x,%d,%d},%d",
625 object
->debug_id
, object
->n_ops
, object
->n_children
, event
);
627 clear_bit(FSCACHE_OBJECT_IS_LIVE
, &object
->flags
);
628 object
->oob_event_mask
= 0;
630 if (list_empty(&object
->dependents
) &&
631 object
->n_ops
== 0 &&
632 object
->n_children
== 0)
633 return transit_to(DROP_OBJECT
);
635 if (object
->n_in_progress
== 0) {
636 spin_lock(&object
->lock
);
637 if (object
->n_ops
> 0 && object
->n_in_progress
== 0)
638 fscache_start_operations(object
);
639 spin_unlock(&object
->lock
);
642 if (!list_empty(&object
->dependents
))
643 return transit_to(KILL_DEPENDENTS
);
645 return transit_to(WAIT_FOR_CLEARANCE
);
649 * Kill dependent objects.
651 static const struct fscache_state
*fscache_kill_dependents(struct fscache_object
*object
,
654 _enter("{OBJ%x},%d", object
->debug_id
, event
);
656 if (!fscache_enqueue_dependents(object
, FSCACHE_OBJECT_EV_KILL
))
657 return NO_TRANSIT
; /* Not finished */
658 return transit_to(WAIT_FOR_CLEARANCE
);
662 * Drop an object's attachments
664 static const struct fscache_state
*fscache_drop_object(struct fscache_object
*object
,
667 struct fscache_object
*parent
= object
->parent
;
668 struct fscache_cookie
*cookie
= object
->cookie
;
669 struct fscache_cache
*cache
= object
->cache
;
672 _enter("{OBJ%x,%d},%d", object
->debug_id
, object
->n_children
, event
);
674 ASSERT(cookie
!= NULL
);
675 ASSERT(!hlist_unhashed(&object
->cookie_link
));
677 /* Make sure the cookie no longer points here and that the netfs isn't
680 spin_lock(&cookie
->lock
);
681 hlist_del_init(&object
->cookie_link
);
682 if (test_and_clear_bit(FSCACHE_COOKIE_INVALIDATING
, &cookie
->flags
))
684 spin_unlock(&cookie
->lock
);
687 wake_up_bit(&cookie
->flags
, FSCACHE_COOKIE_INVALIDATING
);
689 /* Prevent a race with our last child, which has to signal EV_CLEARED
690 * before dropping our spinlock.
692 spin_lock(&object
->lock
);
693 spin_unlock(&object
->lock
);
695 /* Discard from the cache's collection of objects */
696 spin_lock(&cache
->object_list_lock
);
697 list_del_init(&object
->cache_link
);
698 spin_unlock(&cache
->object_list_lock
);
700 fscache_stat(&fscache_n_cop_drop_object
);
701 cache
->ops
->drop_object(object
);
702 fscache_stat_d(&fscache_n_cop_drop_object
);
704 /* The parent object wants to know when all it dependents have gone */
706 _debug("release parent OBJ%x {%d}",
707 parent
->debug_id
, parent
->n_children
);
709 spin_lock(&parent
->lock
);
710 parent
->n_children
--;
711 if (parent
->n_children
== 0)
712 fscache_raise_event(parent
, FSCACHE_OBJECT_EV_CLEARED
);
713 spin_unlock(&parent
->lock
);
714 object
->parent
= NULL
;
717 /* this just shifts the object release to the work processor */
718 fscache_put_object(object
);
719 fscache_stat(&fscache_n_object_dead
);
722 return transit_to(OBJECT_DEAD
);
726 * get a ref on an object
728 static int fscache_get_object(struct fscache_object
*object
)
732 fscache_stat(&fscache_n_cop_grab_object
);
733 ret
= object
->cache
->ops
->grab_object(object
) ? 0 : -EAGAIN
;
734 fscache_stat_d(&fscache_n_cop_grab_object
);
739 * Discard a ref on an object
741 static void fscache_put_object(struct fscache_object
*object
)
743 fscache_stat(&fscache_n_cop_put_object
);
744 object
->cache
->ops
->put_object(object
);
745 fscache_stat_d(&fscache_n_cop_put_object
);
749 * fscache_object_destroy - Note that a cache object is about to be destroyed
750 * @object: The object to be destroyed
752 * Note the imminent destruction and deallocation of a cache object record.
754 void fscache_object_destroy(struct fscache_object
*object
)
756 fscache_objlist_remove(object
);
758 /* We can get rid of the cookie now */
759 fscache_cookie_put(object
->cookie
);
760 object
->cookie
= NULL
;
762 EXPORT_SYMBOL(fscache_object_destroy
);
765 * enqueue an object for metadata-type processing
767 void fscache_enqueue_object(struct fscache_object
*object
)
769 _enter("{OBJ%x}", object
->debug_id
);
771 if (fscache_get_object(object
) >= 0) {
772 wait_queue_head_t
*cong_wq
=
773 &get_cpu_var(fscache_object_cong_wait
);
775 if (queue_work(fscache_object_wq
, &object
->work
)) {
776 if (fscache_object_congested())
779 fscache_put_object(object
);
781 put_cpu_var(fscache_object_cong_wait
);
786 * fscache_object_sleep_till_congested - Sleep until object wq is congested
787 * @timeoutp: Scheduler sleep timeout
789 * Allow an object handler to sleep until the object workqueue is congested.
791 * The caller must set up a wake up event before calling this and must have set
792 * the appropriate sleep mode (such as TASK_UNINTERRUPTIBLE) and tested its own
793 * condition before calling this function as no test is made here.
795 * %true is returned if the object wq is congested, %false otherwise.
797 bool fscache_object_sleep_till_congested(signed long *timeoutp
)
799 wait_queue_head_t
*cong_wq
= &__get_cpu_var(fscache_object_cong_wait
);
802 if (fscache_object_congested())
805 add_wait_queue_exclusive(cong_wq
, &wait
);
806 if (!fscache_object_congested())
807 *timeoutp
= schedule_timeout(*timeoutp
);
808 finish_wait(cong_wq
, &wait
);
810 return fscache_object_congested();
812 EXPORT_SYMBOL_GPL(fscache_object_sleep_till_congested
);
815 * Enqueue the dependents of an object for metadata-type processing.
817 * If we don't manage to finish the list before the scheduler wants to run
818 * again then return false immediately. We return true if the list was
821 static bool fscache_enqueue_dependents(struct fscache_object
*object
, int event
)
823 struct fscache_object
*dep
;
826 _enter("{OBJ%x}", object
->debug_id
);
828 if (list_empty(&object
->dependents
))
831 spin_lock(&object
->lock
);
833 while (!list_empty(&object
->dependents
)) {
834 dep
= list_entry(object
->dependents
.next
,
835 struct fscache_object
, dep_link
);
836 list_del_init(&dep
->dep_link
);
838 fscache_raise_event(dep
, event
);
839 fscache_put_object(dep
);
841 if (!list_empty(&object
->dependents
) && need_resched()) {
847 spin_unlock(&object
->lock
);
852 * remove an object from whatever queue it's waiting on
854 static void fscache_dequeue_object(struct fscache_object
*object
)
856 _enter("{OBJ%x}", object
->debug_id
);
858 if (!list_empty(&object
->dep_link
)) {
859 spin_lock(&object
->parent
->lock
);
860 list_del_init(&object
->dep_link
);
861 spin_unlock(&object
->parent
->lock
);
868 * fscache_check_aux - Ask the netfs whether an object on disk is still valid
869 * @object: The object to ask about
870 * @data: The auxiliary data for the object
871 * @datalen: The size of the auxiliary data
873 * This function consults the netfs about the coherency state of an object.
874 * The caller must be holding a ref on cookie->n_active (held by
875 * fscache_look_up_object() on behalf of the cache backend during object lookup
878 enum fscache_checkaux
fscache_check_aux(struct fscache_object
*object
,
879 const void *data
, uint16_t datalen
)
881 enum fscache_checkaux result
;
883 if (!object
->cookie
->def
->check_aux
) {
884 fscache_stat(&fscache_n_checkaux_none
);
885 return FSCACHE_CHECKAUX_OKAY
;
888 result
= object
->cookie
->def
->check_aux(object
->cookie
->netfs_data
,
891 /* entry okay as is */
892 case FSCACHE_CHECKAUX_OKAY
:
893 fscache_stat(&fscache_n_checkaux_okay
);
896 /* entry requires update */
897 case FSCACHE_CHECKAUX_NEEDS_UPDATE
:
898 fscache_stat(&fscache_n_checkaux_update
);
901 /* entry requires deletion */
902 case FSCACHE_CHECKAUX_OBSOLETE
:
903 fscache_stat(&fscache_n_checkaux_obsolete
);
912 EXPORT_SYMBOL(fscache_check_aux
);
915 * Asynchronously invalidate an object.
917 static const struct fscache_state
*_fscache_invalidate_object(struct fscache_object
*object
,
920 struct fscache_operation
*op
;
921 struct fscache_cookie
*cookie
= object
->cookie
;
923 _enter("{OBJ%x},%d", object
->debug_id
, event
);
925 /* We're going to need the cookie. If the cookie is not available then
926 * retire the object instead.
928 if (!fscache_use_cookie(object
)) {
929 ASSERT(object
->cookie
->stores
.rnode
== NULL
);
930 set_bit(FSCACHE_COOKIE_RETIRED
, &cookie
->flags
);
931 _leave(" [no cookie]");
932 return transit_to(KILL_OBJECT
);
935 /* Reject any new read/write ops and abort any that are pending. */
936 fscache_invalidate_writes(cookie
);
937 clear_bit(FSCACHE_OBJECT_PENDING_WRITE
, &object
->flags
);
938 fscache_cancel_all_ops(object
);
940 /* Now we have to wait for in-progress reads and writes */
941 op
= kzalloc(sizeof(*op
), GFP_KERNEL
);
945 fscache_operation_init(op
, object
->cache
->ops
->invalidate_object
, NULL
);
946 op
->flags
= FSCACHE_OP_ASYNC
|
947 (1 << FSCACHE_OP_EXCLUSIVE
) |
948 (1 << FSCACHE_OP_UNUSE_COOKIE
);
950 spin_lock(&cookie
->lock
);
951 if (fscache_submit_exclusive_op(object
, op
) < 0)
952 goto submit_op_failed
;
953 spin_unlock(&cookie
->lock
);
954 fscache_put_operation(op
);
956 /* Once we've completed the invalidation, we know there will be no data
957 * stored in the cache and thus we can reinstate the data-check-skip
960 set_bit(FSCACHE_COOKIE_NO_DATA_YET
, &cookie
->flags
);
962 /* We can allow read and write requests to come in once again. They'll
963 * queue up behind our exclusive invalidation operation.
965 if (test_and_clear_bit(FSCACHE_COOKIE_INVALIDATING
, &cookie
->flags
))
966 wake_up_bit(&cookie
->flags
, FSCACHE_COOKIE_INVALIDATING
);
968 return transit_to(UPDATE_OBJECT
);
971 clear_bit(FSCACHE_OBJECT_IS_LIVE
, &object
->flags
);
972 fscache_unuse_cookie(object
);
974 return transit_to(KILL_OBJECT
);
977 clear_bit(FSCACHE_OBJECT_IS_LIVE
, &object
->flags
);
978 spin_unlock(&cookie
->lock
);
981 return transit_to(KILL_OBJECT
);
984 static const struct fscache_state
*fscache_invalidate_object(struct fscache_object
*object
,
987 const struct fscache_state
*s
;
989 fscache_stat(&fscache_n_invalidates_run
);
990 fscache_stat(&fscache_n_cop_invalidate_object
);
991 s
= _fscache_invalidate_object(object
, event
);
992 fscache_stat_d(&fscache_n_cop_invalidate_object
);
997 * Asynchronously update an object.
999 static const struct fscache_state
*fscache_update_object(struct fscache_object
*object
,
1002 _enter("{OBJ%x},%d", object
->debug_id
, event
);
1004 fscache_stat(&fscache_n_updates_run
);
1005 fscache_stat(&fscache_n_cop_update_object
);
1006 object
->cache
->ops
->update_object(object
);
1007 fscache_stat_d(&fscache_n_cop_update_object
);
1010 return transit_to(WAIT_FOR_CMD
);