Commit caaef690 authored by David Howells's avatar David Howells
Browse files

FS-Cache: Fix object state machine to have separate work and wait states 



Fix object state machine to have separate work and wait states as that makes
it easier to envision.

There are now three kinds of state:

 (1) Work state.  This is an execution state.  No event processing is performed
     by a work state.  The function attached to a work state returns a pointer
     indicating the next state to which the OSM should transition.  Returning
     NO_TRANSIT repeats the current state, but goes back to the scheduler
     first.

 (2) Wait state.  This is an event processing state.  No execution is
     performed by a wait state.  Wait states are just tables of "if event X
     occurs, clear it and transition to state Y".  The dispatcher returns to
     the scheduler if none of the events in which the wait state has an
     interest are currently pending.

 (3) Out-of-band state.  This is a special work state.  Transitions to normal
     states can be overridden when an unexpected event occurs (eg. I/O error).
     Instead the dispatcher disables and clears the OOB event and transits to
     the specified work state.  This then acts as an ordinary work state,
     though object->state points to the overridden destination.  Returning
     NO_TRANSIT resumes the overridden transition.

In addition, the states have names in their definitions, so there's no need for
tables of state names.  Further, the EV_REQUEUE event is no longer necessary as
that is automatic for work states.

Since the states are now separate structs rather than values in an enum, it's
not possible to use comparisons other than (non-)equality between them, so use
some object->flags to indicate what phase an object is in.

The EV_RELEASE, EV_RETIRE and EV_WITHDRAW events have been squished into one
(EV_KILL).  An object flag now carries the information about retirement.

Similarly, the RELEASING, RECYCLING and WITHDRAWING states have been merged
into an KILL_OBJECT state and additional states have been added for handling
waiting dependent objects (JUMPSTART_DEPS and KILL_DEPENDENTS).

A state has also been added for synchronising with parent object initialisation
(WAIT_FOR_PARENT) and another for initiating look up (PARENT_READY).

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Tested-By: default avatarMilosz Tanski <milosz@adfin.com>
Acked-by: default avatarJeff Layton <jlayton@redhat.com>
parent 493f7bc1

fs/cachefiles/interface.c

+1 −1
Original line number Diff line number Diff line
@@ -263,7 +263,7 @@ static void cachefiles_drop_object(struct fscache_object *_object) 
#endif



	/* delete retired objects */

	if (object->fscache.state == FSCACHE_OBJECT_RECYCLING &&

	if (test_bit(FSCACHE_OBJECT_RETIRE, &object->fscache.flags) &&

	    _object != cache->cache.fsdef

	    ) {

		_debug("- retire object OBJ%x", object->fscache.debug_id);

fs/cachefiles/namei.c

+2 −2
Original line number Diff line number Diff line
@@ -38,7 +38,7 @@ void __cachefiles_printk_object(struct cachefiles_object *object, 
	printk(KERN_ERR "%sobject: OBJ%x\n",

	       prefix, object->fscache.debug_id);

	printk(KERN_ERR "%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",

	       prefix, fscache_object_states[object->fscache.state],

	       prefix, object->fscache.state->name,

	       object->fscache.flags, work_busy(&object->fscache.work),

	       object->fscache.events, object->fscache.event_mask);

	printk(KERN_ERR "%sops=%u inp=%u exc=%u\n",
@@ -127,7 +127,7 @@ static void cachefiles_mark_object_buried(struct cachefiles_cache *cache, 
found_dentry:

	kdebug("preemptive burial: OBJ%x [%s] %p",

	       object->fscache.debug_id,

	       fscache_object_states[object->fscache.state],

	       object->fscache.state->name,

	       dentry);



	if (fscache_object_is_live(&object->fscache)) {

fs/fscache/cache.c

+17 −15
Original line number Diff line number Diff line
@@ -224,8 +224,10 @@ int fscache_add_cache(struct fscache_cache *cache, 
	BUG_ON(!ifsdef);



	cache->flags = 0;

	ifsdef->event_mask = ULONG_MAX & ~(1 << FSCACHE_OBJECT_EV_CLEARED);

	ifsdef->state = FSCACHE_OBJECT_ACTIVE;

	ifsdef->event_mask =

		((1 << NR_FSCACHE_OBJECT_EVENTS) - 1) &

		~(1 << FSCACHE_OBJECT_EV_CLEARED);

	__set_bit(FSCACHE_OBJECT_IS_AVAILABLE, &ifsdef->flags);



	if (!tagname)

		tagname = cache->identifier;
@@ -330,25 +332,25 @@ static void fscache_withdraw_all_objects(struct fscache_cache *cache, 
{

	struct fscache_object *object;



	while (!list_empty(&cache->object_list)) {

		spin_lock(&cache->object_list_lock);



	while (!list_empty(&cache->object_list)) {

		if (!list_empty(&cache->object_list)) {

			object = list_entry(cache->object_list.next,

					    struct fscache_object, cache_link);

			list_move_tail(&object->cache_link, dying_objects);



			_debug("withdraw %p", object->cookie);



		spin_lock(&object->lock);

		spin_unlock(&cache->object_list_lock);

		fscache_raise_event(object, FSCACHE_OBJECT_EV_WITHDRAW);

		spin_unlock(&object->lock);



		cond_resched();

		spin_lock(&cache->object_list_lock);

			/* This must be done under object_list_lock to prevent

			 * a race with fscache_drop_object().

			 */

			fscache_raise_event(object, FSCACHE_OBJECT_EV_KILL);

		}



		spin_unlock(&cache->object_list_lock);

		cond_resched();

	}

}



/**

fs/fscache/cookie.c

+4 −5
Original line number Diff line number Diff line
@@ -205,7 +205,7 @@ static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie) 


	/* initiate the process of looking up all the objects in the chain

	 * (done by fscache_initialise_object()) */

	fscache_enqueue_object(object);

	fscache_raise_event(object, FSCACHE_OBJECT_EV_NEW_CHILD);



	spin_unlock(&cookie->lock);
@@ -469,7 +469,6 @@ void __fscache_relinquish_cookie(struct fscache_cookie *cookie, int retire) 
{

	struct fscache_cache *cache;

	struct fscache_object *object;

	unsigned long event;



	fscache_stat(&fscache_n_relinquishes);

	if (retire)
@@ -497,8 +496,6 @@ void __fscache_relinquish_cookie(struct fscache_cookie *cookie, int retire) 
			    fscache_wait_bit, TASK_UNINTERRUPTIBLE);

	}



	event = retire ? FSCACHE_OBJECT_EV_RETIRE : FSCACHE_OBJECT_EV_RELEASE;



try_again:

	spin_lock(&cookie->lock);
@@ -533,7 +530,9 @@ try_again: 


		cache = object->cache;

		object->cookie = NULL;

		fscache_raise_event(object, event);

		if (retire)

			set_bit(FSCACHE_OBJECT_RETIRE, &object->flags);

		fscache_raise_event(object, FSCACHE_OBJECT_EV_KILL);

		spin_unlock(&object->lock);



		if (atomic_dec_and_test(&cookie->usage))

fs/fscache/internal.h

+4 −4
Original line number Diff line number Diff line
@@ -97,10 +97,6 @@ extern int fscache_wait_bit_interruptible(void *); 
/*

 * object.c

 */

extern const char fscache_object_states_short[FSCACHE_OBJECT__NSTATES][5];



extern void fscache_withdrawing_object(struct fscache_cache *,

				       struct fscache_object *);

extern void fscache_enqueue_object(struct fscache_object *);



/*
@@ -291,6 +287,10 @@ static inline void fscache_raise_event(struct fscache_object *object, 
				       unsigned event)

{

	BUG_ON(event >= NR_FSCACHE_OBJECT_EVENTS);

#if 0

	printk("*** fscache_raise_event(OBJ%d{%lx},%x)\n",

	       object->debug_id, object->event_mask, (1 << event));

#endif

	if (!test_and_set_bit(event, &object->events) &&

	    test_bit(event, &object->event_mask))

		fscache_enqueue_object(object);

CRA Git | Maintained and supported by SUSTech CRA and CCSE