/* * look an object up in the cache from which it was allocated * - we hold an "access lock" on the parent object, so the parent object cannot * be withdrawn by either party till we've finished */ static const struct fscache_state *fscache_look_up_object(struct fscache_object *object, int event) { struct fscache_cookie *cookie = object->cookie; struct fscache_object *parent = object->parent; int ret; _enter("{OBJ%x},%d", object->debug_id, event); object->oob_table = fscache_osm_lookup_oob; ASSERT(parent != NULL); ASSERTCMP(parent->n_ops, >, 0); ASSERTCMP(parent->n_obj_ops, >, 0); /* make sure the parent is still available */ ASSERT(fscache_object_is_available(parent)); if (fscache_object_is_dying(parent) || test_bit(FSCACHE_IOERROR, &object->cache->flags) || !fscache_use_cookie(object)) { _leave(" [unavailable]"); return transit_to(LOOKUP_FAILURE); } _debug("LOOKUP \"%s\" in \"%s\"", cookie->def->name, object->cache->tag->name); fscache_stat(&fscache_n_object_lookups); fscache_stat(&fscache_n_cop_lookup_object); ret = object->cache->ops->lookup_object(object); fscache_stat_d(&fscache_n_cop_lookup_object); fscache_unuse_cookie(object); if (ret == -ETIMEDOUT) { /* probably stuck behind another object, so move this one to * the back of the queue */ fscache_stat(&fscache_n_object_lookups_timed_out); _leave(" [timeout]"); return NO_TRANSIT; } if (ret < 0) { _leave(" [error]"); return transit_to(LOOKUP_FAILURE); } _leave(" [ok]"); return transit_to(OBJECT_AVAILABLE); }
/* * initialise an object * - check the specified object's parent to see if we can make use of it * immediately to do a creation * - we may need to start the process of creating a parent and we need to wait * for the parent's lookup and creation to complete if it's not there yet */ static const struct fscache_state *fscache_initialise_object(struct fscache_object *object, int event) { struct fscache_object *parent; bool success; _enter("{OBJ%x},%d", object->debug_id, event); ASSERT(list_empty(&object->dep_link)); parent = object->parent; if (!parent) { _leave(" [no parent]"); return transit_to(DROP_OBJECT); } _debug("parent: %s of:%lx", parent->state->name, parent->flags); if (fscache_object_is_dying(parent)) { _leave(" [bad parent]"); return transit_to(DROP_OBJECT); } if (fscache_object_is_available(parent)) { _leave(" [ready]"); return transit_to(PARENT_READY); } _debug("wait"); spin_lock(&parent->lock); fscache_stat(&fscache_n_cop_grab_object); success = false; if (fscache_object_is_live(parent) && object->cache->ops->grab_object(object)) { list_add(&object->dep_link, &parent->dependents); success = true; } fscache_stat_d(&fscache_n_cop_grab_object); spin_unlock(&parent->lock); if (!success) { _leave(" [grab failed]"); return transit_to(DROP_OBJECT); } /* fscache_acquire_non_index_cookie() uses this * to wake the chain up */ fscache_raise_event(parent, FSCACHE_OBJECT_EV_NEW_CHILD); _leave(" [wait]"); return transit_to(WAIT_FOR_PARENT); }
/* * look an object up in the cache from which it was allocated * - we hold an "access lock" on the parent object, so the parent object cannot * be withdrawn by either party till we've finished * - an object's cookie is pinned until we clear FSCACHE_COOKIE_CREATING on the * leaf-most cookies of the object and all its children */ static void fscache_lookup_object(struct fscache_object *object) { struct fscache_cookie *cookie = object->cookie; struct fscache_object *parent; int ret; _enter(""); parent = object->parent; ASSERT(parent != NULL); ASSERTCMP(parent->n_ops, >, 0); ASSERTCMP(parent->n_obj_ops, >, 0); /* make sure the parent is still available */ ASSERTCMP(parent->state, >=, FSCACHE_OBJECT_AVAILABLE); if (parent->state >= FSCACHE_OBJECT_DYING || test_bit(FSCACHE_IOERROR, &object->cache->flags)) { _debug("unavailable"); set_bit(FSCACHE_OBJECT_EV_WITHDRAW, &object->events); _leave(""); return; } _debug("LOOKUP \"%s/%s\" in \"%s\"", parent->cookie->def->name, cookie->def->name, object->cache->tag->name); fscache_stat(&fscache_n_object_lookups); fscache_stat(&fscache_n_cop_lookup_object); ret = object->cache->ops->lookup_object(object); fscache_stat_d(&fscache_n_cop_lookup_object); if (test_bit(FSCACHE_OBJECT_EV_ERROR, &object->events)) set_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags); if (ret == -ETIMEDOUT) { /* probably stuck behind another object, so move this one to * the back of the queue */ fscache_stat(&fscache_n_object_lookups_timed_out); set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events); } _leave(""); }
/* * initialise an object * - check the specified object's parent to see if we can make use of it * immediately to do a creation * - we may need to start the process of creating a parent and we need to wait * for the parent's lookup and creation to complete if it's not there yet * - an object's cookie is pinned until we clear FSCACHE_COOKIE_CREATING on the * leaf-most cookies of the object and all its children */ static void fscache_initialise_object(struct fscache_object *object) { struct fscache_object *parent; _enter(""); ASSERT(object->cookie != NULL); ASSERT(object->cookie->parent != NULL); ASSERT(list_empty(&object->work.link)); if (object->events & ((1 << FSCACHE_OBJECT_EV_ERROR) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_WITHDRAW))) { _debug("abort init %lx", object->events); spin_lock(&object->lock); object->state = FSCACHE_OBJECT_ABORT_INIT; spin_unlock(&object->lock); return; } spin_lock(&object->cookie->lock); spin_lock_nested(&object->cookie->parent->lock, 1); parent = object->parent; if (!parent) { _debug("no parent"); set_bit(FSCACHE_OBJECT_EV_WITHDRAW, &object->events); } else { spin_lock(&object->lock); spin_lock_nested(&parent->lock, 1); _debug("parent %s", fscache_object_states[parent->state]); if (parent->state >= FSCACHE_OBJECT_DYING) { _debug("bad parent"); set_bit(FSCACHE_OBJECT_EV_WITHDRAW, &object->events); } else if (parent->state < FSCACHE_OBJECT_AVAILABLE) { _debug("wait"); /* we may get woken up in this state by child objects * binding on to us, so we need to make sure we don't * add ourself to the list multiple times */ if (list_empty(&object->dep_link)) { fscache_stat(&fscache_n_cop_grab_object); object->cache->ops->grab_object(object); fscache_stat_d(&fscache_n_cop_grab_object); list_add(&object->dep_link, &parent->dependents); /* fscache_acquire_non_index_cookie() uses this * to wake the chain up */ if (parent->state == FSCACHE_OBJECT_INIT) fscache_enqueue_object(parent); } } else { _debug("go"); parent->n_ops++; parent->n_obj_ops++; object->lookup_jif = jiffies; object->state = FSCACHE_OBJECT_LOOKING_UP; set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events); } spin_unlock(&parent->lock); spin_unlock(&object->lock); } spin_unlock(&object->cookie->parent->lock); spin_unlock(&object->cookie->lock); _leave(""); }
/* * process events that have been sent to an object's state machine * - initiates parent lookup * - does object lookup * - does object creation * - does object recycling and retirement * - does object withdrawal */ static void fscache_object_state_machine(struct fscache_object *object) { enum fscache_object_state new_state; struct fscache_cookie *cookie; ASSERT(object != NULL); _enter("{OBJ%x,%s,%lx}", object->debug_id, fscache_object_states[object->state], object->events); switch (object->state) { /* wait for the parent object to become ready */ case FSCACHE_OBJECT_INIT: object->event_mask = ULONG_MAX & ~(1 << FSCACHE_OBJECT_EV_CLEARED); fscache_initialise_object(object); goto done; /* look up the object metadata on disk */ case FSCACHE_OBJECT_LOOKING_UP: fscache_lookup_object(object); goto lookup_transit; /* create the object metadata on disk */ case FSCACHE_OBJECT_CREATING: fscache_lookup_object(object); goto lookup_transit; /* handle an object becoming available; start pending * operations and queue dependent operations for processing */ case FSCACHE_OBJECT_AVAILABLE: fscache_object_available(object); goto active_transit; /* normal running state */ case FSCACHE_OBJECT_ACTIVE: goto active_transit; /* Invalidate an object on disk */ case FSCACHE_OBJECT_INVALIDATING: clear_bit(FSCACHE_OBJECT_EV_INVALIDATE, &object->events); fscache_stat(&fscache_n_invalidates_run); fscache_stat(&fscache_n_cop_invalidate_object); fscache_invalidate_object(object); fscache_stat_d(&fscache_n_cop_invalidate_object); fscache_raise_event(object, FSCACHE_OBJECT_EV_UPDATE); goto active_transit; /* update the object metadata on disk */ case FSCACHE_OBJECT_UPDATING: clear_bit(FSCACHE_OBJECT_EV_UPDATE, &object->events); fscache_stat(&fscache_n_updates_run); fscache_stat(&fscache_n_cop_update_object); object->cache->ops->update_object(object); fscache_stat_d(&fscache_n_cop_update_object); goto active_transit; /* handle an object dying during lookup or creation */ case FSCACHE_OBJECT_LC_DYING: object->event_mask &= ~(1 << FSCACHE_OBJECT_EV_UPDATE); fscache_stat(&fscache_n_cop_lookup_complete); object->cache->ops->lookup_complete(object); fscache_stat_d(&fscache_n_cop_lookup_complete); spin_lock(&object->lock); object->state = FSCACHE_OBJECT_DYING; cookie = object->cookie; if (cookie) { if (test_and_clear_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags)) wake_up_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP); if (test_and_clear_bit(FSCACHE_COOKIE_CREATING, &cookie->flags)) wake_up_bit(&cookie->flags, FSCACHE_COOKIE_CREATING); } spin_unlock(&object->lock); fscache_done_parent_op(object); /* wait for completion of all active operations on this object * and the death of all child objects of this object */ case FSCACHE_OBJECT_DYING: dying: clear_bit(FSCACHE_OBJECT_EV_CLEARED, &object->events); spin_lock(&object->lock); _debug("dying OBJ%x {%d,%d}", object->debug_id, object->n_ops, object->n_children); if (object->n_ops == 0 && object->n_children == 0) { object->event_mask &= ~(1 << FSCACHE_OBJECT_EV_CLEARED); object->event_mask |= (1 << FSCACHE_OBJECT_EV_WITHDRAW) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_ERROR); } else { object->event_mask &= ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_ERROR)); object->event_mask |= 1 << FSCACHE_OBJECT_EV_CLEARED; } spin_unlock(&object->lock); fscache_enqueue_dependents(object); fscache_start_operations(object); goto terminal_transit; /* handle an abort during initialisation */ case FSCACHE_OBJECT_ABORT_INIT: _debug("handle abort init %lx", object->events); object->event_mask &= ~(1 << FSCACHE_OBJECT_EV_UPDATE); spin_lock(&object->lock); fscache_dequeue_object(object); object->state = FSCACHE_OBJECT_DYING; if (test_and_clear_bit(FSCACHE_COOKIE_CREATING, &object->cookie->flags)) wake_up_bit(&object->cookie->flags, FSCACHE_COOKIE_CREATING); spin_unlock(&object->lock); goto dying; /* handle the netfs releasing an object and possibly marking it * obsolete too */ case FSCACHE_OBJECT_RELEASING: case FSCACHE_OBJECT_RECYCLING: object->event_mask &= ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_ERROR)); fscache_release_object(object); spin_lock(&object->lock); object->state = FSCACHE_OBJECT_DEAD; spin_unlock(&object->lock); fscache_stat(&fscache_n_object_dead); goto terminal_transit; /* handle the parent cache of this object being withdrawn from * active service */ case FSCACHE_OBJECT_WITHDRAWING: object->event_mask &= ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_ERROR)); fscache_withdraw_object(object); spin_lock(&object->lock); object->state = FSCACHE_OBJECT_DEAD; spin_unlock(&object->lock); fscache_stat(&fscache_n_object_dead); goto terminal_transit; /* complain about the object being woken up once it is * deceased */ case FSCACHE_OBJECT_DEAD: printk(KERN_ERR "FS-Cache:" " Unexpected event in dead state %lx\n", object->events & object->event_mask); BUG(); default: printk(KERN_ERR "FS-Cache: Unknown object state %u\n", object->state); BUG(); } /* determine the transition from a lookup state */ lookup_transit: switch (fls(object->events & object->event_mask) - 1) { case FSCACHE_OBJECT_EV_WITHDRAW: case FSCACHE_OBJECT_EV_RETIRE: case FSCACHE_OBJECT_EV_RELEASE: case FSCACHE_OBJECT_EV_ERROR: new_state = FSCACHE_OBJECT_LC_DYING; goto change_state; case FSCACHE_OBJECT_EV_REQUEUE: goto done; case -1: goto done; /* sleep until event */ default: goto unsupported_event; } /* determine the transition from an active state */ active_transit: switch (fls(object->events & object->event_mask) - 1) { case FSCACHE_OBJECT_EV_WITHDRAW: case FSCACHE_OBJECT_EV_RETIRE: case FSCACHE_OBJECT_EV_RELEASE: case FSCACHE_OBJECT_EV_ERROR: new_state = FSCACHE_OBJECT_DYING; goto change_state; case FSCACHE_OBJECT_EV_INVALIDATE: new_state = FSCACHE_OBJECT_INVALIDATING; goto change_state; case FSCACHE_OBJECT_EV_UPDATE: new_state = FSCACHE_OBJECT_UPDATING; goto change_state; case -1: new_state = FSCACHE_OBJECT_ACTIVE; goto change_state; /* sleep until event */ default: goto unsupported_event; } /* determine the transition from a terminal state */ terminal_transit: switch (fls(object->events & object->event_mask) - 1) { case FSCACHE_OBJECT_EV_WITHDRAW: new_state = FSCACHE_OBJECT_WITHDRAWING; goto change_state; case FSCACHE_OBJECT_EV_RETIRE: new_state = FSCACHE_OBJECT_RECYCLING; goto change_state; case FSCACHE_OBJECT_EV_RELEASE: new_state = FSCACHE_OBJECT_RELEASING; goto change_state; case FSCACHE_OBJECT_EV_ERROR: new_state = FSCACHE_OBJECT_WITHDRAWING; goto change_state; case FSCACHE_OBJECT_EV_CLEARED: new_state = FSCACHE_OBJECT_DYING; goto change_state; case -1: goto done; /* sleep until event */ default: goto unsupported_event; } change_state: spin_lock(&object->lock); object->state = new_state; spin_unlock(&object->lock); done: _leave(" [->%s]", fscache_object_states[object->state]); return; unsupported_event: printk(KERN_ERR "FS-Cache:" " Unsupported event %lx [mask %lx] in state %s\n", object->events, object->event_mask, fscache_object_states[object->state]); BUG(); }
static void fscache_object_state_machine(struct fscache_object *object) { enum fscache_object_state new_state; struct fscache_cookie *cookie; ASSERT(object != NULL); _enter("{OBJ%x,%s,%lx}", object->debug_id, fscache_object_states[object->state], object->events); switch (object->state) { case FSCACHE_OBJECT_INIT: object->event_mask = ULONG_MAX & ~(1 << FSCACHE_OBJECT_EV_CLEARED); fscache_initialise_object(object); goto done; case FSCACHE_OBJECT_LOOKING_UP: fscache_lookup_object(object); goto lookup_transit; case FSCACHE_OBJECT_CREATING: fscache_lookup_object(object); goto lookup_transit; case FSCACHE_OBJECT_AVAILABLE: fscache_object_available(object); goto active_transit; case FSCACHE_OBJECT_ACTIVE: goto active_transit; case FSCACHE_OBJECT_UPDATING: clear_bit(FSCACHE_OBJECT_EV_UPDATE, &object->events); fscache_stat(&fscache_n_updates_run); fscache_stat(&fscache_n_cop_update_object); object->cache->ops->update_object(object); fscache_stat_d(&fscache_n_cop_update_object); goto active_transit; case FSCACHE_OBJECT_LC_DYING: object->event_mask &= ~(1 << FSCACHE_OBJECT_EV_UPDATE); fscache_stat(&fscache_n_cop_lookup_complete); object->cache->ops->lookup_complete(object); fscache_stat_d(&fscache_n_cop_lookup_complete); spin_lock(&object->lock); object->state = FSCACHE_OBJECT_DYING; cookie = object->cookie; if (cookie) { if (test_and_clear_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags)) wake_up_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP); if (test_and_clear_bit(FSCACHE_COOKIE_CREATING, &cookie->flags)) wake_up_bit(&cookie->flags, FSCACHE_COOKIE_CREATING); } spin_unlock(&object->lock); fscache_done_parent_op(object); case FSCACHE_OBJECT_DYING: dying: clear_bit(FSCACHE_OBJECT_EV_CLEARED, &object->events); spin_lock(&object->lock); _debug("dying OBJ%x {%d,%d}", object->debug_id, object->n_ops, object->n_children); if (object->n_ops == 0 && object->n_children == 0) { object->event_mask &= ~(1 << FSCACHE_OBJECT_EV_CLEARED); object->event_mask |= (1 << FSCACHE_OBJECT_EV_WITHDRAW) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_ERROR); } else { object->event_mask &= ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_ERROR)); object->event_mask |= 1 << FSCACHE_OBJECT_EV_CLEARED; } spin_unlock(&object->lock); fscache_enqueue_dependents(object); fscache_start_operations(object); goto terminal_transit; case FSCACHE_OBJECT_ABORT_INIT: _debug("handle abort init %lx", object->events); object->event_mask &= ~(1 << FSCACHE_OBJECT_EV_UPDATE); spin_lock(&object->lock); fscache_dequeue_object(object); object->state = FSCACHE_OBJECT_DYING; if (test_and_clear_bit(FSCACHE_COOKIE_CREATING, &object->cookie->flags)) wake_up_bit(&object->cookie->flags, FSCACHE_COOKIE_CREATING); spin_unlock(&object->lock); goto dying; case FSCACHE_OBJECT_RELEASING: case FSCACHE_OBJECT_RECYCLING: object->event_mask &= ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_ERROR)); fscache_release_object(object); spin_lock(&object->lock); object->state = FSCACHE_OBJECT_DEAD; spin_unlock(&object->lock); fscache_stat(&fscache_n_object_dead); goto terminal_transit; case FSCACHE_OBJECT_WITHDRAWING: object->event_mask &= ~((1 << FSCACHE_OBJECT_EV_WITHDRAW) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_ERROR)); fscache_withdraw_object(object); spin_lock(&object->lock); object->state = FSCACHE_OBJECT_DEAD; spin_unlock(&object->lock); fscache_stat(&fscache_n_object_dead); goto terminal_transit; case FSCACHE_OBJECT_DEAD: printk(KERN_ERR "FS-Cache:" " Unexpected event in dead state %lx\n", object->events & object->event_mask); BUG(); default: printk(KERN_ERR "FS-Cache: Unknown object state %u\n", object->state); BUG(); } lookup_transit: switch (fls(object->events & object->event_mask) - 1) { case FSCACHE_OBJECT_EV_WITHDRAW: case FSCACHE_OBJECT_EV_RETIRE: case FSCACHE_OBJECT_EV_RELEASE: case FSCACHE_OBJECT_EV_ERROR: new_state = FSCACHE_OBJECT_LC_DYING; goto change_state; case FSCACHE_OBJECT_EV_REQUEUE: goto done; case -1: goto done; default: goto unsupported_event; } active_transit: switch (fls(object->events & object->event_mask) - 1) { case FSCACHE_OBJECT_EV_WITHDRAW: case FSCACHE_OBJECT_EV_RETIRE: case FSCACHE_OBJECT_EV_RELEASE: case FSCACHE_OBJECT_EV_ERROR: new_state = FSCACHE_OBJECT_DYING; goto change_state; case FSCACHE_OBJECT_EV_UPDATE: new_state = FSCACHE_OBJECT_UPDATING; goto change_state; case -1: new_state = FSCACHE_OBJECT_ACTIVE; goto change_state; default: goto unsupported_event; } terminal_transit: switch (fls(object->events & object->event_mask) - 1) { case FSCACHE_OBJECT_EV_WITHDRAW: new_state = FSCACHE_OBJECT_WITHDRAWING; goto change_state; case FSCACHE_OBJECT_EV_RETIRE: new_state = FSCACHE_OBJECT_RECYCLING; goto change_state; case FSCACHE_OBJECT_EV_RELEASE: new_state = FSCACHE_OBJECT_RELEASING; goto change_state; case FSCACHE_OBJECT_EV_ERROR: new_state = FSCACHE_OBJECT_WITHDRAWING; goto change_state; case FSCACHE_OBJECT_EV_CLEARED: new_state = FSCACHE_OBJECT_DYING; goto change_state; case -1: goto done; default: goto unsupported_event; } change_state: spin_lock(&object->lock); object->state = new_state; spin_unlock(&object->lock); done: _leave(" [->%s]", fscache_object_states[object->state]); return; unsupported_event: printk(KERN_ERR "FS-Cache:" " Unsupported event %lx [mask %lx] in state %s\n", object->events, object->event_mask, fscache_object_states[object->state]); BUG(); }
static void fscache_initialise_object(struct fscache_object *object) { struct fscache_object *parent; _enter(""); ASSERT(object->cookie != NULL); ASSERT(object->cookie->parent != NULL); if (object->events & ((1 << FSCACHE_OBJECT_EV_ERROR) | (1 << FSCACHE_OBJECT_EV_RELEASE) | (1 << FSCACHE_OBJECT_EV_RETIRE) | (1 << FSCACHE_OBJECT_EV_WITHDRAW))) { _debug("abort init %lx", object->events); spin_lock(&object->lock); object->state = FSCACHE_OBJECT_ABORT_INIT; spin_unlock(&object->lock); return; } spin_lock(&object->cookie->lock); spin_lock_nested(&object->cookie->parent->lock, 1); parent = object->parent; if (!parent) { _debug("no parent"); set_bit(FSCACHE_OBJECT_EV_WITHDRAW, &object->events); } else { spin_lock(&object->lock); spin_lock_nested(&parent->lock, 1); _debug("parent %s", fscache_object_states[parent->state]); if (parent->state >= FSCACHE_OBJECT_DYING) { _debug("bad parent"); set_bit(FSCACHE_OBJECT_EV_WITHDRAW, &object->events); } else if (parent->state < FSCACHE_OBJECT_AVAILABLE) { _debug("wait"); if (list_empty(&object->dep_link)) { fscache_stat(&fscache_n_cop_grab_object); object->cache->ops->grab_object(object); fscache_stat_d(&fscache_n_cop_grab_object); list_add(&object->dep_link, &parent->dependents); if (parent->state == FSCACHE_OBJECT_INIT) fscache_enqueue_object(parent); } } else { _debug("go"); parent->n_ops++; parent->n_obj_ops++; object->lookup_jif = jiffies; object->state = FSCACHE_OBJECT_LOOKING_UP; set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events); } spin_unlock(&parent->lock); spin_unlock(&object->lock); } spin_unlock(&object->cookie->parent->lock); spin_unlock(&object->cookie->lock); _leave(""); }