lkml.org 
[lkml]   [2021]   [Dec]   [17]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
SubjectRe: [PATCH v3 17/68] fscache: Implement simple cookie state machine
From
Date
On Thu, 2021-12-16 at 16:10 +0000, David Howells wrote:
> Implement a very simple cookie state machine to handle lookup,
> invalidation, withdrawal, relinquishment and, to be added later, commit on
> LRU discard.
>
> Three cache methods are provided: ->lookup_cookie() to look up and, if
> necessary, create a data storage object; ->withdraw_cookie() to free the
> resources associated with that object and potentially delete it; and
> ->prepare_to_write(), to do prepare for changes to the cached data to be
> modified locally.
>
> Changes
> =======
> ver #3:
> - Fix a race between LRU discard and relinquishment whereby the former
> would override the latter and thus the latter would never happen[1].
>
> ver #2:
> - Don't hold n_accesses elevated whilst cache is bound to a cookie, but
> rather add a flag that prevents the state machine from being queued when
> n_accesses reaches 0.
>
> Signed-off-by: David Howells <dhowells@redhat.com>
> cc: linux-cachefs@redhat.com
> Link: https://lore.kernel.org/r/599331.1639410068@warthog.procyon.org.uk/ [1]
> Link: https://lore.kernel.org/r/163819599657.215744.15799615296912341745.stgit@warthog.procyon.org.uk/ # v1
> Link: https://lore.kernel.org/r/163906903925.143852.1805855338154353867.stgit@warthog.procyon.org.uk/ # v2
> ---
>
> fs/fscache/cookie.c | 313 +++++++++++++++++++++++++++++++++++-----
> include/linux/fscache-cache.h | 27 +++
> include/trace/events/fscache.h | 4 +
> 3 files changed, 300 insertions(+), 44 deletions(-)
>
> diff --git a/fs/fscache/cookie.c b/fs/fscache/cookie.c
> index 04d2127bd354..336046de08ee 100644
> --- a/fs/fscache/cookie.c
> +++ b/fs/fscache/cookie.c
> @@ -15,7 +15,8 @@
>
> struct kmem_cache *fscache_cookie_jar;
>
> -static void fscache_drop_cookie(struct fscache_cookie *cookie);
> +static void fscache_cookie_worker(struct work_struct *work);
> +static void fscache_unhash_cookie(struct fscache_cookie *cookie);
>
> #define fscache_cookie_hash_shift 15
> static struct hlist_bl_head fscache_cookie_hash[1 << fscache_cookie_hash_shift];
> @@ -62,6 +63,19 @@ static void fscache_free_cookie(struct fscache_cookie *cookie)
> kmem_cache_free(fscache_cookie_jar, cookie);
> }
>
> +static void __fscache_queue_cookie(struct fscache_cookie *cookie)
> +{
> + if (!queue_work(fscache_wq, &cookie->work))
> + fscache_put_cookie(cookie, fscache_cookie_put_over_queued);
> +}
> +
> +static void fscache_queue_cookie(struct fscache_cookie *cookie,
> + enum fscache_cookie_trace where)
> +{
> + fscache_get_cookie(cookie, where);
> + __fscache_queue_cookie(cookie);
> +}
> +
> /*
> * Initialise the access gate on a cookie by setting a flag to prevent the
> * state machine from being queued when the access counter transitions to 0.
> @@ -98,9 +112,8 @@ void fscache_end_cookie_access(struct fscache_cookie *cookie,
> trace_fscache_access(cookie->debug_id, refcount_read(&cookie->ref),
> n_accesses, why);
> if (n_accesses == 0 &&
> - !test_bit(FSCACHE_COOKIE_NO_ACCESS_WAKE, &cookie->flags)) {
> - // PLACEHOLDER: Need to poke the state machine
> - }
> + !test_bit(FSCACHE_COOKIE_NO_ACCESS_WAKE, &cookie->flags))
> + fscache_queue_cookie(cookie, fscache_cookie_get_end_access);
> }
> EXPORT_SYMBOL(fscache_end_cookie_access);
>
> @@ -171,35 +184,58 @@ static inline void wake_up_cookie_state(struct fscache_cookie *cookie)
> wake_up_var(&cookie->state);
> }
>
> +/*
> + * Change the state a cookie is at and wake up anyone waiting for that. Impose
> + * an ordering between the stuff stored in the cookie and the state member.
> + * Paired with fscache_cookie_state().
> + */
> static void __fscache_set_cookie_state(struct fscache_cookie *cookie,
> enum fscache_cookie_state state)
> {
> - cookie->state = state;
> + smp_store_release(&cookie->state, state);
> }
>
> -/*
> - * Change the state a cookie is at and wake up anyone waiting for that - but
> - * only if the cookie isn't already marked as being in a cleanup state.
> - */
> -void fscache_set_cookie_state(struct fscache_cookie *cookie,
> - enum fscache_cookie_state state)
> +static void fscache_set_cookie_state(struct fscache_cookie *cookie,
> + enum fscache_cookie_state state)
> {
> - bool changed = false;
> -
> spin_lock(&cookie->lock);
> - switch (cookie->state) {
> - case FSCACHE_COOKIE_STATE_RELINQUISHING:
> - break;
> - default:
> - __fscache_set_cookie_state(cookie, state);
> - changed = true;
> - break;
> - }
> + __fscache_set_cookie_state(cookie, state);
> spin_unlock(&cookie->lock);
> - if (changed)
> - wake_up_cookie_state(cookie);
> + wake_up_cookie_state(cookie);
> +}
> +
> +/**
> + * fscache_cookie_lookup_negative - Note negative lookup
> + * @cookie: The cookie that was being looked up
> + *
> + * Note that some part of the metadata path in the cache doesn't exist and so
> + * we can release any waiting readers in the certain knowledge that there's
> + * nothing for them to actually read.
> + *
> + * This function uses no locking and must only be called from the state machine.
> + */
> +void fscache_cookie_lookup_negative(struct fscache_cookie *cookie)
> +{
> + set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
> + fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_CREATING);
> +}
> +EXPORT_SYMBOL(fscache_cookie_lookup_negative);
> +
> +/**
> + * fscache_caching_failed - Report that a failure stopped caching on a cookie
> + * @cookie: The cookie that was affected
> + *
> + * Tell fscache that caching on a cookie needs to be stopped due to some sort
> + * of failure.
> + *
> + * This function uses no locking and must only be called from the state machine.
> + */
> +void fscache_caching_failed(struct fscache_cookie *cookie)
> +{
> + clear_bit(FSCACHE_COOKIE_IS_CACHING, &cookie->flags);
> + fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_FAILED);
> }
> -EXPORT_SYMBOL(fscache_set_cookie_state);
> +EXPORT_SYMBOL(fscache_caching_failed);
>
> /*
> * Set the index key in a cookie. The cookie struct has space for a 16-byte
> @@ -291,10 +327,10 @@ static struct fscache_cookie *fscache_alloc_cookie(
>
> refcount_set(&cookie->ref, 1);
> cookie->debug_id = atomic_inc_return(&fscache_cookie_debug_id);
> - cookie->state = FSCACHE_COOKIE_STATE_QUIESCENT;
> spin_lock_init(&cookie->lock);
> INIT_LIST_HEAD(&cookie->commit_link);
> - INIT_WORK(&cookie->work, NULL /* PLACEHOLDER */);
> + INIT_WORK(&cookie->work, fscache_cookie_worker);
> + __fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_QUIESCENT);
>
> write_lock(&fscache_cookies_lock);
> list_add_tail(&cookie->proc_link, &fscache_cookies);
> @@ -417,6 +453,192 @@ struct fscache_cookie *__fscache_acquire_cookie(
> }
> EXPORT_SYMBOL(__fscache_acquire_cookie);
>
> +/*
> + * Prepare a cache object to be written to.
> + */
> +static void fscache_prepare_to_write(struct fscache_cookie *cookie)
> +{
> + cookie->volume->cache->ops->prepare_to_write(cookie);
> +}
> +
> +/*
> + * Look up a cookie in the cache.
> + */
> +static void fscache_perform_lookup(struct fscache_cookie *cookie)
> +{
> + enum fscache_access_trace trace = fscache_access_lookup_cookie_end_failed;
> + bool need_withdraw = false;
> +
> + _enter("");
> +
> + if (!cookie->volume->cache_priv) {
> + fscache_create_volume(cookie->volume, true);
> + if (!cookie->volume->cache_priv) {
> + fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_QUIESCENT);
> + goto out;
> + }
> + }
> +
> + if (!cookie->volume->cache->ops->lookup_cookie(cookie)) {
> + if (cookie->state != FSCACHE_COOKIE_STATE_FAILED)
> + fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_QUIESCENT);
> + need_withdraw = true;
> + _leave(" [fail]");
> + goto out;
> + }
> +
> + fscache_see_cookie(cookie, fscache_cookie_see_active);
> + fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_ACTIVE);
> + trace = fscache_access_lookup_cookie_end;
> +
> +out:
> + fscache_end_cookie_access(cookie, trace);
> + if (need_withdraw)
> + fscache_withdraw_cookie(cookie);
> + fscache_end_volume_access(cookie->volume, cookie, trace);
> +}
> +
> +/*
> + * Perform work upon the cookie, such as committing its cache state,
> + * relinquishing it or withdrawing the backing cache. We're protected from the
> + * cache going away under us as object withdrawal must come through this
> + * non-reentrant work item.
> + */
> +static void fscache_cookie_state_machine(struct fscache_cookie *cookie)
> +{
> + enum fscache_cookie_state state;
> + bool wake = false;
> +
> + _enter("c=%x", cookie->debug_id);
> +
> +again:
> + spin_lock(&cookie->lock);
> +again_locked:
> + state = cookie->state;
> + switch (state) {
> + case FSCACHE_COOKIE_STATE_QUIESCENT:
> + /* The QUIESCENT state is jumped to the LOOKING_UP state by
> + * fscache_use_cookie().
> + */
> +
> + if (atomic_read(&cookie->n_accesses) == 0 &&
> + test_bit(FSCACHE_COOKIE_DO_RELINQUISH, &cookie->flags)) {
> + __fscache_set_cookie_state(cookie,
> + FSCACHE_COOKIE_STATE_RELINQUISHING);
> + wake = true;
> + goto again_locked;
> + }
> + break;
> +
> + case FSCACHE_COOKIE_STATE_LOOKING_UP:
> + spin_unlock(&cookie->lock);
> + fscache_init_access_gate(cookie);
> + fscache_perform_lookup(cookie);
> + goto again;
> +
> + case FSCACHE_COOKIE_STATE_ACTIVE:
> + if (test_and_clear_bit(FSCACHE_COOKIE_DO_PREP_TO_WRITE, &cookie->flags)) {
> + spin_unlock(&cookie->lock);
> + fscache_prepare_to_write(cookie);
> + spin_lock(&cookie->lock);
> + }
> + fallthrough;
> +
> + case FSCACHE_COOKIE_STATE_FAILED:
> + if (atomic_read(&cookie->n_accesses) != 0)
> + break;
> + if (test_bit(FSCACHE_COOKIE_DO_RELINQUISH, &cookie->flags)) {
> + __fscache_set_cookie_state(cookie,
> + FSCACHE_COOKIE_STATE_RELINQUISHING);
> + wake = true;
> + goto again_locked;
> + }
> + if (test_bit(FSCACHE_COOKIE_DO_WITHDRAW, &cookie->flags)) {
> + __fscache_set_cookie_state(cookie,
> + FSCACHE_COOKIE_STATE_WITHDRAWING);
> + wake = true;
> + goto again_locked;
> + }
> + break;
> +
> + case FSCACHE_COOKIE_STATE_RELINQUISHING:
> + case FSCACHE_COOKIE_STATE_WITHDRAWING:
> + if (cookie->cache_priv) {
> + spin_unlock(&cookie->lock);
> + cookie->volume->cache->ops->withdraw_cookie(cookie);
> + spin_lock(&cookie->lock);
> + }
> +
> + switch (state) {
> + case FSCACHE_COOKIE_STATE_RELINQUISHING:
> + fscache_see_cookie(cookie, fscache_cookie_see_relinquish);
> + fscache_unhash_cookie(cookie);
> + __fscache_set_cookie_state(cookie,
> + FSCACHE_COOKIE_STATE_DROPPED);
> + wake = true;
> + goto out;
> + case FSCACHE_COOKIE_STATE_WITHDRAWING:
> + fscache_see_cookie(cookie, fscache_cookie_see_withdraw);
> + break;
> + default:
> + BUG();
> + }
> +

Ugh, the nested switch here is a bit hard to follow. It makes it seem
like the state could change due to the withdraw_cookie and you're
checking it again, but it doesn't do that.

This would be clearer if you just duplicated the withdraw_cookie stanza
for both states and moved the stuff below here to a helper or to a new
goto block.

> + clear_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &cookie->flags);
> + clear_bit(FSCACHE_COOKIE_DO_WITHDRAW, &cookie->flags);
> + clear_bit(FSCACHE_COOKIE_DO_LRU_DISCARD, &cookie->flags);
> + clear_bit(FSCACHE_COOKIE_DO_PREP_TO_WRITE, &cookie->flags);
> + set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
> + __fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_QUIESCENT);
> + wake = true;
> + goto again_locked;
> +
> + case FSCACHE_COOKIE_STATE_DROPPED:
> + break;
> +
> + default:
> + WARN_ONCE(1, "Cookie %x in unexpected state %u\n",
> + cookie->debug_id, state);
> + break;
> + }
> +
> +out:
> + spin_unlock(&cookie->lock);
> + if (wake)
> + wake_up_cookie_state(cookie);
> + _leave("");
> +}
> +
> +static void fscache_cookie_worker(struct work_struct *work)
> +{
> + struct fscache_cookie *cookie = container_of(work, struct fscache_cookie, work);
> +
> + fscache_see_cookie(cookie, fscache_cookie_see_work);
> + fscache_cookie_state_machine(cookie);
> + fscache_put_cookie(cookie, fscache_cookie_put_work);
> +}
> +
> +/*
> + * Wait for the object to become inactive. The cookie's work item will be
> + * scheduled when someone transitions n_accesses to 0 - but if someone's
> + * already done that, schedule it anyway.
> + */
> +static void __fscache_withdraw_cookie(struct fscache_cookie *cookie)
> +{
> + int n_accesses;
> + bool unpinned;
> +
> + unpinned = test_and_clear_bit(FSCACHE_COOKIE_NO_ACCESS_WAKE, &cookie->flags);
> +
> + /* Need to read the access count after unpinning */
> + n_accesses = atomic_read(&cookie->n_accesses);
> + if (unpinned)
> + trace_fscache_access(cookie->debug_id, refcount_read(&cookie->ref),
> + n_accesses, fscache_access_cache_unpin);
> + if (n_accesses == 0)
> + fscache_queue_cookie(cookie, fscache_cookie_get_end_access);
> +}
> +
> /*
> * Remove a cookie from the hash table.
> */
> @@ -432,21 +654,27 @@ static void fscache_unhash_cookie(struct fscache_cookie *cookie)
> hlist_bl_del(&cookie->hash_link);
> clear_bit(FSCACHE_COOKIE_IS_HASHED, &cookie->flags);
> hlist_bl_unlock(h);
> + fscache_stat(&fscache_n_relinquishes_dropped);
> }
>
> -/*
> - * Finalise a cookie after all its resources have been disposed of.
> - */
> -static void fscache_drop_cookie(struct fscache_cookie *cookie)
> +static void fscache_drop_withdraw_cookie(struct fscache_cookie *cookie)
> {
> - spin_lock(&cookie->lock);
> - __fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_DROPPED);
> - spin_unlock(&cookie->lock);
> - wake_up_cookie_state(cookie);
> + __fscache_withdraw_cookie(cookie);
> +}
>
> - fscache_unhash_cookie(cookie);
> - fscache_stat(&fscache_n_relinquishes_dropped);
> +/**
> + * fscache_withdraw_cookie - Mark a cookie for withdrawal
> + * @cookie: The cookie to be withdrawn.
> + *
> + * Allow the cache backend to withdraw the backing for a cookie for its own
> + * reasons, even if that cookie is in active use.
> + */
> +void fscache_withdraw_cookie(struct fscache_cookie *cookie)
> +{
> + set_bit(FSCACHE_COOKIE_DO_WITHDRAW, &cookie->flags);
> + fscache_drop_withdraw_cookie(cookie);
> }
> +EXPORT_SYMBOL(fscache_withdraw_cookie);
>
> /*
> * Allow the netfs to release a cookie back to the cache.
> @@ -473,12 +701,13 @@ void __fscache_relinquish_cookie(struct fscache_cookie *cookie, bool retire)
> ASSERTCMP(atomic_read(&cookie->volume->n_cookies), >, 0);
> atomic_dec(&cookie->volume->n_cookies);
>
> - set_bit(FSCACHE_COOKIE_DO_RELINQUISH, &cookie->flags);
> -
> - if (test_bit(FSCACHE_COOKIE_HAS_BEEN_CACHED, &cookie->flags))
> - ; // PLACEHOLDER: Do something here if the cookie was cached
> - else
> - fscache_drop_cookie(cookie);
> + if (test_bit(FSCACHE_COOKIE_HAS_BEEN_CACHED, &cookie->flags)) {
> + set_bit(FSCACHE_COOKIE_DO_RELINQUISH, &cookie->flags);
> + fscache_drop_withdraw_cookie(cookie);
> + } else {
> + fscache_set_cookie_state(cookie, FSCACHE_COOKIE_STATE_DROPPED);
> + fscache_unhash_cookie(cookie);
> + }
> fscache_put_cookie(cookie, fscache_cookie_put_relinquish);
> }
> EXPORT_SYMBOL(__fscache_relinquish_cookie);
> diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
> index 936ef731bbc7..ae6a75976450 100644
> --- a/include/linux/fscache-cache.h
> +++ b/include/linux/fscache-cache.h
> @@ -57,6 +57,15 @@ struct fscache_cache_ops {
>
> /* Free the cache's data attached to a volume */
> void (*free_volume)(struct fscache_volume *volume);
> +
> + /* Look up a cookie in the cache */
> + bool (*lookup_cookie)(struct fscache_cookie *cookie);
> +
> + /* Withdraw an object without any cookie access counts held */
> + void (*withdraw_cookie)(struct fscache_cookie *cookie);
> +
> + /* Prepare to write to a live cache object */
> + void (*prepare_to_write)(struct fscache_cookie *cookie);
> };
>
> extern struct workqueue_struct *fscache_wq;
> @@ -72,6 +81,7 @@ extern int fscache_add_cache(struct fscache_cache *cache,
> void *cache_priv);
> extern void fscache_withdraw_cache(struct fscache_cache *cache);
> extern void fscache_withdraw_volume(struct fscache_volume *volume);
> +extern void fscache_withdraw_cookie(struct fscache_cookie *cookie);
>
> extern void fscache_io_error(struct fscache_cache *cache);
>
> @@ -85,8 +95,21 @@ extern void fscache_put_cookie(struct fscache_cookie *cookie,
> enum fscache_cookie_trace where);
> extern void fscache_end_cookie_access(struct fscache_cookie *cookie,
> enum fscache_access_trace why);
> -extern void fscache_set_cookie_state(struct fscache_cookie *cookie,
> - enum fscache_cookie_state state);
> +extern void fscache_cookie_lookup_negative(struct fscache_cookie *cookie);
> +extern void fscache_caching_failed(struct fscache_cookie *cookie);
> +
> +/**
> + * fscache_cookie_state - Read the state of a cookie
> + * @cookie: The cookie to query
> + *
> + * Get the state of a cookie, imposing an ordering between the cookie contents
> + * and the state value. Paired with fscache_set_cookie_state().
> + */
> +static inline
> +enum fscache_cookie_state fscache_cookie_state(struct fscache_cookie *cookie)
> +{
> + return smp_load_acquire(&cookie->state);
> +}
>
> /**
> * fscache_get_key - Get a pointer to the cookie key
> diff --git a/include/trace/events/fscache.h b/include/trace/events/fscache.h
> index 1d576bd8112e..030c97bb9c8b 100644
> --- a/include/trace/events/fscache.h
> +++ b/include/trace/events/fscache.h
> @@ -68,6 +68,8 @@ enum fscache_access_trace {
> fscache_access_acquire_volume_end,
> fscache_access_cache_pin,
> fscache_access_cache_unpin,
> + fscache_access_lookup_cookie_end,
> + fscache_access_lookup_cookie_end_failed,
> fscache_access_relinquish_volume,
> fscache_access_relinquish_volume_end,
> fscache_access_unlive,
> @@ -124,6 +126,8 @@ enum fscache_access_trace {
> EM(fscache_access_acquire_volume_end, "END acq_vol") \
> EM(fscache_access_cache_pin, "PIN cache ") \
> EM(fscache_access_cache_unpin, "UNPIN cache ") \
> + EM(fscache_access_lookup_cookie_end, "END lookup ") \
> + EM(fscache_access_lookup_cookie_end_failed,"END lookupf") \
> EM(fscache_access_relinquish_volume, "BEGIN rlq_vol") \
> EM(fscache_access_relinquish_volume_end,"END rlq_vol") \
> E_(fscache_access_unlive, "END unlive ")
>
>

--
Jeff Layton <jlayton@kernel.org>

\
 
 \ /
  Last update: 2021-12-17 20:08    [W:0.464 / U:2.024 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site