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

FS-Cache: Provide proper invalidation 



Provide a proper invalidation method rather than relying on the netfs retiring
the cookie it has and getting a new one.  The problem with this is that isn't
easy for the netfs to make sure that it has completed/cancelled all its
outstanding storage and retrieval operations on the cookie it is retiring.

Instead, have the cache provide an invalidation method that will cancel or wait
for all currently outstanding operations before invalidating the cache, and
will cause new operations to queue up behind that.  Whilst invalidation is in
progress, some requests will be rejected until the cache can stack a barrier on
the operation queue to cause new operations to be deferred behind it.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
parent 9f10523f

Documentation/filesystems/caching/backend-api.txt

+12 −0
Original line number Diff line number Diff line
@@ -308,6 +308,18 @@ performed on the denizens of the cache. These are held in a structure of type: 
     obtained by calling object->cookie->def->get_aux()/get_attr().





 (*) Invalidate data object [mandatory]:



	int (*invalidate_object)(struct fscache_operation *op)



     This is called to invalidate a data object (as pointed to by op->object).

     All the data stored for this object should be discarded and an

     attr_changed operation should be performed.  The caller will follow up

     with an object update operation.



     fscache_op_complete() must be called on op before returning.





 (*) Discard object [mandatory]:



	void (*drop_object)(struct fscache_object *object)

Documentation/filesystems/caching/netfs-api.txt

+38 −8
Original line number Diff line number Diff line
@@ -35,8 +35,9 @@ This document contains the following sections: 
	(12) Index and data file update

	(13) Miscellaneous cookie operations

	(14) Cookie unregistration

	(15) Index and data file invalidation

	(16) FS-Cache specific page flags.

	(15) Index invalidation

	(16) Data file invalidation

	(17) FS-Cache specific page flags.





=============================
@@ -767,13 +768,42 @@ the cookies for "child" indices, objects and pages have been relinquished 
first.





================================

INDEX AND DATA FILE INVALIDATION

================================

==================

INDEX INVALIDATION

==================



There is no direct way to invalidate an index subtree.  To do this, the caller

should relinquish and retire the cookie they have, and then acquire a new one.





======================

DATA FILE INVALIDATION

======================



Sometimes it will be necessary to invalidate an object that contains data.

Typically this will be necessary when the server tells the netfs of a foreign

change - at which point the netfs has to throw away all the state it had for an

inode and reload from the server.



To indicate that a cache object should be invalidated, the following function

can be called:



	void fscache_invalidate(struct fscache_cookie *cookie);



This can be called with spinlocks held as it defers the work to a thread pool.

All extant storage, retrieval and attribute change ops at this point are

cancelled and discarded.  Some future operations will be rejected until the

cache has had a chance to insert a barrier in the operations queue.  After

that, operations will be queued again behind the invalidation operation.



The invalidation operation will perform an attribute change operation and an

auxiliary data update operation as it is very likely these will have changed.



Using the following function, the netfs can wait for the invalidation operation

to have reached a point at which it can start submitting ordinary operations

once again:



There is no direct way to invalidate an index subtree or a data file.  To do

this, the caller should relinquish and retire the cookie they have, and then

acquire a new one.

	void fscache_wait_on_invalidate(struct fscache_cookie *cookie);





===========================

Documentation/filesystems/caching/object.txt

+15 −8
Original line number Diff line number Diff line
@@ -216,7 +216,14 @@ servicing netfs requests: 
     The normal running state.  In this state, requests the netfs makes will be

     passed on to the cache.



 (6) State FSCACHE_OBJECT_UPDATING.

 (6) State FSCACHE_OBJECT_INVALIDATING.



     The object is undergoing invalidation.  When the state comes here, it

     discards all pending read, write and attribute change operations as it is

     going to clear out the cache entirely and reinitialise it.  It will then

     continue to the FSCACHE_OBJECT_UPDATING state.



 (7) State FSCACHE_OBJECT_UPDATING.



     The state machine comes here to update the object in the cache from the

     netfs's records.  This involves updating the auxiliary data that is used
@@ -225,13 +232,13 @@ servicing netfs requests: 
And there are terminal states in which an object cleans itself up, deallocates

memory and potentially deletes stuff from disk:



 (7) State FSCACHE_OBJECT_LC_DYING.

 (8) State FSCACHE_OBJECT_LC_DYING.



     The object comes here if it is dying because of a lookup or creation

     error.  This would be due to a disk error or system error of some sort.

     Temporary data is cleaned up, and the parent is released.



 (8) State FSCACHE_OBJECT_DYING.

 (9) State FSCACHE_OBJECT_DYING.



     The object comes here if it is dying due to an error, because its parent

     cookie has been relinquished by the netfs or because the cache is being
@@ -241,27 +248,27 @@ memory and potentially deletes stuff from disk: 
     can destroy themselves.  This object waits for all its children to go away

     before advancing to the next state.



 (9) State FSCACHE_OBJECT_ABORT_INIT.

(10) State FSCACHE_OBJECT_ABORT_INIT.



     The object comes to this state if it was waiting on its parent in

     FSCACHE_OBJECT_INIT, but its parent died.  The object will destroy itself

     so that the parent may proceed from the FSCACHE_OBJECT_DYING state.



(10) State FSCACHE_OBJECT_RELEASING.

(11) State FSCACHE_OBJECT_RECYCLING.

(11) State FSCACHE_OBJECT_RELEASING.

(12) State FSCACHE_OBJECT_RECYCLING.



     The object comes to one of these two states when dying once it is rid of

     all its children, if it is dying because the netfs relinquished its

     cookie.  In the first state, the cached data is expected to persist, and

     in the second it will be deleted.



(12) State FSCACHE_OBJECT_WITHDRAWING.

(13) State FSCACHE_OBJECT_WITHDRAWING.



     The object transits to this state if the cache decides it wants to

     withdraw the object from service, perhaps to make space, but also due to

     error or just because the whole cache is being withdrawn.



(13) State FSCACHE_OBJECT_DEAD.

(14) State FSCACHE_OBJECT_DEAD.



     The object transits to this state when the in-memory object record is

     ready to be deleted.  The object processor shouldn't ever see an object in

fs/fscache/cookie.c

+60 −0
Original line number Diff line number Diff line
@@ -369,6 +369,66 @@ cant_attach_object: 
	return ret;

}



/*

 * Invalidate an object.  Callable with spinlocks held.

 */

void __fscache_invalidate(struct fscache_cookie *cookie)

{

	struct fscache_object *object;



	_enter("{%s}", cookie->def->name);



	fscache_stat(&fscache_n_invalidates);



	/* Only permit invalidation of data files.  Invalidating an index will

	 * require the caller to release all its attachments to the tree rooted

	 * there, and if it's doing that, it may as well just retire the

	 * cookie.

	 */

	ASSERTCMP(cookie->def->type, ==, FSCACHE_COOKIE_TYPE_DATAFILE);



	/* We will be updating the cookie too. */

	BUG_ON(!cookie->def->get_aux);



	/* If there's an object, we tell the object state machine to handle the

	 * invalidation on our behalf, otherwise there's nothing to do.

	 */

	if (!hlist_empty(&cookie->backing_objects)) {

		spin_lock(&cookie->lock);



		if (!hlist_empty(&cookie->backing_objects) &&

		    !test_and_set_bit(FSCACHE_COOKIE_INVALIDATING,

				      &cookie->flags)) {

			object = hlist_entry(cookie->backing_objects.first,

					     struct fscache_object,

					     cookie_link);

			if (object->state < FSCACHE_OBJECT_DYING)

				fscache_raise_event(

					object, FSCACHE_OBJECT_EV_INVALIDATE);

		}



		spin_unlock(&cookie->lock);

	}



	_leave("");

}

EXPORT_SYMBOL(__fscache_invalidate);



/*

 * Wait for object invalidation to complete.

 */

void __fscache_wait_on_invalidate(struct fscache_cookie *cookie)

{

	_enter("%p", cookie);



	wait_on_bit(&cookie->flags, FSCACHE_COOKIE_INVALIDATING,

		    fscache_wait_bit_interruptible,

		    TASK_UNINTERRUPTIBLE);



	_leave("");

}

EXPORT_SYMBOL(__fscache_wait_on_invalidate);



/*

 * update the index entries backing a cookie

 */

fs/fscache/internal.h

+10 −0
Original line number Diff line number Diff line
@@ -122,10 +122,16 @@ extern int fscache_submit_exclusive_op(struct fscache_object *, 
extern int fscache_submit_op(struct fscache_object *,

			     struct fscache_operation *);

extern int fscache_cancel_op(struct fscache_operation *);

extern void fscache_cancel_all_ops(struct fscache_object *);

extern void fscache_abort_object(struct fscache_object *);

extern void fscache_start_operations(struct fscache_object *);

extern void fscache_operation_gc(struct work_struct *);



/*

 * page.c

 */

extern void fscache_invalidate_writes(struct fscache_cookie *);



/*

 * proc.c

 */
@@ -205,6 +211,9 @@ extern atomic_t fscache_n_acquires_ok; 
extern atomic_t fscache_n_acquires_nobufs;

extern atomic_t fscache_n_acquires_oom;



extern atomic_t fscache_n_invalidates;

extern atomic_t fscache_n_invalidates_run;



extern atomic_t fscache_n_updates;

extern atomic_t fscache_n_updates_null;

extern atomic_t fscache_n_updates_run;
@@ -237,6 +246,7 @@ extern atomic_t fscache_n_cop_alloc_object; 
extern atomic_t fscache_n_cop_lookup_object;

extern atomic_t fscache_n_cop_lookup_complete;

extern atomic_t fscache_n_cop_grab_object;

extern atomic_t fscache_n_cop_invalidate_object;

extern atomic_t fscache_n_cop_update_object;

extern atomic_t fscache_n_cop_drop_object;

extern atomic_t fscache_n_cop_put_object;

CRA Git | Maintained and supported by SUSTech CRA and CCSE