/** * fscache_obtained_object - Note successful object lookup or creation * @object: Object pointing to cookie to mark * * Note successful lookup and/or creation, permitting those waiting to write * data to a backing object to continue. * * Note that after calling this, an object's cookie may be relinquished by the * netfs, and so must be accessed with object lock held. */ void fscache_obtained_object(struct fscache_object *object) { struct fscache_cookie *cookie = object->cookie; _enter("{OBJ%x,%s}", object->debug_id, object->state->name); /* if we were still looking up, then we must have a positive lookup * result, in which case there may be data available */ if (!test_and_set_bit(FSCACHE_OBJECT_IS_LOOKED_UP, &object->flags)) { fscache_stat(&fscache_n_object_lookups_positive); /* We do (presumably) have data */ clear_bit_unlock(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); clear_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags); /* Allow write requests to begin stacking up and read requests * to begin shovelling data. */ clear_bit_unlock(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags); wake_up_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP); } else { fscache_stat(&fscache_n_object_created); } set_bit(FSCACHE_OBJECT_IS_AVAILABLE, &object->flags); _leave(""); }
/* * submit an exclusive operation for an object * - other ops are excluded from running simultaneously with this one * - this gets any extra refs it needs on an op */ int fscache_submit_exclusive_op(struct fscache_object *object, struct fscache_operation *op) { int ret; _enter("{OBJ%x OP%x},", object->debug_id, op->debug_id); spin_lock(&object->lock); ASSERTCMP(object->n_ops, >=, object->n_in_progress); ASSERTCMP(object->n_ops, >=, object->n_exclusive); ret = -ENOBUFS; if (fscache_object_is_active(object)) { op->object = object; object->n_ops++; object->n_exclusive++; /* reads and writes must wait */ if (object->n_ops > 0) { atomic_inc(&op->usage); list_add_tail(&op->pend_link, &object->pending_ops); fscache_stat(&fscache_n_op_pend); } else if (!list_empty(&object->pending_ops)) { atomic_inc(&op->usage); list_add_tail(&op->pend_link, &object->pending_ops); fscache_stat(&fscache_n_op_pend); fscache_start_operations(object); } else { ASSERTCMP(object->n_in_progress, ==, 0); fscache_run_op(object, op); } /* need to issue a new write op after this */ clear_bit(FSCACHE_OBJECT_PENDING_WRITE, &object->flags); ret = 0; } else if (object->state == FSCACHE_OBJECT_CREATING) {
/* * 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); }
/* * decide whether a page can be released, possibly by cancelling a store to it * - we're allowed to sleep if __GFP_DIRECT_RECLAIM is flagged */ bool __fscache_maybe_release_page(struct fscache_cookie *cookie, struct page *page, gfp_t gfp) { struct page *xpage; void *val; _enter("%p,%p,%x", cookie, page, gfp); try_again: rcu_read_lock(); val = radix_tree_lookup(&cookie->stores, page->index); if (!val) { rcu_read_unlock(); fscache_stat(&fscache_n_store_vmscan_not_storing); __fscache_uncache_page(cookie, page); return true; } /* see if the page is actually undergoing storage - if so we can't get * rid of it till the cache has finished with it */ if (radix_tree_tag_get(&cookie->stores, page->index, FSCACHE_COOKIE_STORING_TAG)) { rcu_read_unlock(); goto page_busy; } /* the page is pending storage, so we attempt to cancel the store and * discard the store request so that the page can be reclaimed */ spin_lock(&cookie->stores_lock); rcu_read_unlock(); if (radix_tree_tag_get(&cookie->stores, page->index, FSCACHE_COOKIE_STORING_TAG)) { /* the page started to undergo storage whilst we were looking, * so now we can only wait or return */ spin_unlock(&cookie->stores_lock); goto page_busy; } xpage = radix_tree_delete(&cookie->stores, page->index); spin_unlock(&cookie->stores_lock); if (xpage) { fscache_stat(&fscache_n_store_vmscan_cancelled); fscache_stat(&fscache_n_store_radix_deletes); ASSERTCMP(xpage, ==, page); } else {
/** * fscache_enqueue_operation - Enqueue an operation for processing * @op: The operation to enqueue * * Enqueue an operation for processing by the FS-Cache thread pool. * * This will get its own ref on the object. */ void fscache_enqueue_operation(struct fscache_operation *op) { _enter("{OBJ%x OP%x,%u}", op->object->debug_id, op->debug_id, atomic_read(&op->usage)); fscache_set_op_state(op, "EnQ"); ASSERT(list_empty(&op->pend_link)); ASSERT(op->processor != NULL); ASSERT(fscache_object_is_available(op->object)); ASSERTCMP(atomic_read(&op->usage), >, 0); ASSERTCMP(op->state, ==, FSCACHE_OP_ST_IN_PROGRESS); fscache_stat(&fscache_n_op_enqueue); switch (op->flags & FSCACHE_OP_TYPE) { case FSCACHE_OP_FAST: _debug("queue fast"); atomic_inc(&op->usage); if (!schedule_work(&op->fast_work)) fscache_put_operation(op); break; case FSCACHE_OP_SLOW: _debug("queue slow"); slow_work_enqueue(&op->slow_work); break; case FSCACHE_OP_MYTHREAD: _debug("queue for caller's attention"); break; default: printk(KERN_ERR "FS-Cache: Unexpected op type %lx", op->flags); BUG(); break; } }
/** * fscache_enqueue_operation - Enqueue an operation for processing * @op: The operation to enqueue * * Enqueue an operation for processing by the FS-Cache thread pool. * * This will get its own ref on the object. */ void fscache_enqueue_operation(struct fscache_operation *op) { _enter("{OBJ%x OP%x,%u}", op->object->debug_id, op->debug_id, atomic_read(&op->usage)); ASSERT(list_empty(&op->pend_link)); ASSERT(op->processor != NULL); ASSERT(fscache_object_is_available(op->object)); ASSERTCMP(atomic_read(&op->usage), >, 0); ASSERTCMP(op->state, ==, FSCACHE_OP_ST_IN_PROGRESS); fscache_stat(&fscache_n_op_enqueue); switch (op->flags & FSCACHE_OP_TYPE) { case FSCACHE_OP_ASYNC: _debug("queue async"); atomic_inc(&op->usage); if (!queue_work(fscache_op_wq, &op->work)) fscache_put_operation(op); break; case FSCACHE_OP_MYTHREAD: _debug("queue for caller's attention"); break; default: pr_err("Unexpected op type %lx", op->flags); BUG(); break; } }
/** * fscache_object_lookup_negative - Note negative cookie lookup * @object: Object pointing to cookie to mark * * Note negative lookup, permitting those waiting to read data from an already * existing backing object to continue as there's no data for them to read. */ void fscache_object_lookup_negative(struct fscache_object *object) { struct fscache_cookie *cookie = object->cookie; _enter("{OBJ%x,%s}", object->debug_id, fscache_object_states[object->state]); spin_lock(&object->lock); if (object->state == FSCACHE_OBJECT_LOOKING_UP) { fscache_stat(&fscache_n_object_lookups_negative); /* transit here to allow write requests to begin stacking up * and read requests to begin returning ENODATA */ object->state = FSCACHE_OBJECT_CREATING; spin_unlock(&object->lock); set_bit(FSCACHE_COOKIE_PENDING_FILL, &cookie->flags); set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); _debug("wake up lookup %p", &cookie->flags); smp_mb__before_clear_bit(); clear_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags); smp_mb__after_clear_bit(); wake_up_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP); set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events); } else { ASSERTCMP(object->state, ==, FSCACHE_OBJECT_CREATING); spin_unlock(&object->lock); } _leave(""); }
/** * fscache_enqueue_operation - Enqueue an operation for processing * @op: The operation to enqueue * * Enqueue an operation for processing by the FS-Cache thread pool. * * This will get its own ref on the object. */ void fscache_enqueue_operation(struct fscache_operation *op) { _enter("{OBJ%x OP%x,%u}", op->object->debug_id, op->debug_id, atomic_read(&op->usage)); ASSERT(list_empty(&op->pend_link)); ASSERT(op->processor != NULL); ASSERTCMP(op->object->state, >=, FSCACHE_OBJECT_AVAILABLE); ASSERTCMP(atomic_read(&op->usage), >, 0); fscache_stat(&fscache_n_op_enqueue); switch (op->flags & FSCACHE_OP_TYPE) { case FSCACHE_OP_ASYNC: _debug("queue async"); atomic_inc(&op->usage); if (!queue_work(fscache_op_wq, &op->work)) fscache_put_operation(op); break; case FSCACHE_OP_MYTHREAD: _debug("queue for caller's attention"); break; default: // printk(KERN_ERR "FS-Cache: Unexpected op type %lx", ; BUG(); break; } }
/* * 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; _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); object->cache->ops->lookup_object(object); if (test_bit(FSCACHE_OBJECT_EV_ERROR, &object->events)) set_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags); _leave(""); }
bool __fscache_maybe_release_page(struct fscache_cookie *cookie, struct page *page, gfp_t gfp) { struct page *xpage; void *val; _enter("%p,%p,%x", cookie, page, gfp); rcu_read_lock(); val = radix_tree_lookup(&cookie->stores, page->index); if (!val) { rcu_read_unlock(); fscache_stat(&fscache_n_store_vmscan_not_storing); __fscache_uncache_page(cookie, page); return true; } /* */ if (radix_tree_tag_get(&cookie->stores, page->index, FSCACHE_COOKIE_STORING_TAG)) { rcu_read_unlock(); goto page_busy; } /* */ spin_lock(&cookie->stores_lock); rcu_read_unlock(); if (radix_tree_tag_get(&cookie->stores, page->index, FSCACHE_COOKIE_STORING_TAG)) { /* */ spin_unlock(&cookie->stores_lock); goto page_busy; } xpage = radix_tree_delete(&cookie->stores, page->index); spin_unlock(&cookie->stores_lock); if (xpage) { fscache_stat(&fscache_n_store_vmscan_cancelled); fscache_stat(&fscache_n_store_radix_deletes); ASSERTCMP(xpage, ==, page); } else {
/* * 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(""); }
/* * start an op running */ static void fscache_run_op(struct fscache_object *object, struct fscache_operation *op) { object->n_in_progress++; if (test_and_clear_bit(FSCACHE_OP_WAITING, &op->flags)) wake_up_bit(&op->flags, FSCACHE_OP_WAITING); if (op->processor) fscache_enqueue_operation(op); fscache_stat(&fscache_n_op_run); }
/* * 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); }
/** * fscache_obtained_object - Note successful object lookup or creation * @object: Object pointing to cookie to mark * * Note successful lookup and/or creation, permitting those waiting to write * data to a backing object to continue. * * Note that after calling this, an object's cookie may be relinquished by the * netfs, and so must be accessed with object lock held. */ void fscache_obtained_object(struct fscache_object *object) { struct fscache_cookie *cookie = object->cookie; _enter("{OBJ%x,%s}", object->debug_id, fscache_object_states[object->state]); /* if we were still looking up, then we must have a positive lookup * result, in which case there may be data available */ spin_lock(&object->lock); if (object->state == FSCACHE_OBJECT_LOOKING_UP) { fscache_stat(&fscache_n_object_lookups_positive); clear_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); object->state = FSCACHE_OBJECT_AVAILABLE; spin_unlock(&object->lock); smp_mb__before_clear_bit(); clear_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags); smp_mb__after_clear_bit(); wake_up_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP); set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events); } else { ASSERTCMP(object->state, ==, FSCACHE_OBJECT_CREATING); fscache_stat(&fscache_n_object_created); object->state = FSCACHE_OBJECT_AVAILABLE; spin_unlock(&object->lock); set_bit(FSCACHE_OBJECT_EV_REQUEUE, &object->events); smp_wmb(); } if (test_and_clear_bit(FSCACHE_COOKIE_CREATING, &cookie->flags)) wake_up_bit(&cookie->flags, FSCACHE_COOKIE_CREATING); _leave(""); }
/** * fscache_operation_init - Do basic initialisation of an operation * @op: The operation to initialise * @release: The release function to assign * * Do basic initialisation of an operation. The caller must still set flags, * object and processor if needed. */ void fscache_operation_init(struct fscache_operation *op, fscache_operation_processor_t processor, fscache_operation_cancel_t cancel, fscache_operation_release_t release) { INIT_WORK(&op->work, fscache_op_work_func); atomic_set(&op->usage, 1); op->state = FSCACHE_OP_ST_INITIALISED; op->debug_id = atomic_inc_return(&fscache_op_debug_id); op->processor = processor; op->cancel = cancel ?: fscache_operation_dummy_cancel; op->release = release; INIT_LIST_HEAD(&op->pend_link); fscache_stat(&fscache_n_op_initialised); }
/** * fscache_object_lookup_negative - Note negative cookie lookup * @object: Object pointing to cookie to mark * * Note negative lookup, permitting those waiting to read data from an already * existing backing object to continue as there's no data for them to read. */ void fscache_object_lookup_negative(struct fscache_object *object) { struct fscache_cookie *cookie = object->cookie; _enter("{OBJ%x,%s}", object->debug_id, object->state->name); if (!test_and_set_bit(FSCACHE_OBJECT_IS_LOOKED_UP, &object->flags)) { fscache_stat(&fscache_n_object_lookups_negative); /* Allow write requests to begin stacking up and read requests to begin * returning ENODATA. */ set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); clear_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags); _debug("wake up lookup %p", &cookie->flags); clear_bit_unlock(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags); wake_up_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP); } _leave(""); }
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(""); }
/* * 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(""); }
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(); }
/* * 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(); }