Commit c698dbf9 authored by Trond Myklebust's avatar Trond Myklebust
Browse files

Merge branch 'fscache' of... 

Merge branch 'fscache' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs into linux-next

Pull fs-cache fixes from David Howells:

Can you pull these commits to fix an issue with NFS whereby caching can be
enabled on a file that is open for writing by subsequently opening it for
reading.  This can be made to crash by opening it for writing again if you're
quick enough.

The gist of the patchset is that the cookie should be acquired at inode
creation only and subsequently enabled and disabled as appropriate (which
dispenses with the backing objects when they're not needed).

The extra synchronisation that NFS does can then be dispensed with as it is
thenceforth managed by FS-Cache.

Could you send these on to Linus?

This likely will need fixing also in CIFS and 9P also once the FS-Cache
changes are upstream.  AFS and Ceph are probably safe.

* 'fscache' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs:
  NFS: Use i_writecount to control whether to get an fscache cookie in nfs_open()
  FS-Cache: Provide the ability to enable/disable cookies
  FS-Cache: Add use/unuse/wake cookie wrappers
parents a3f432bf f1fe29b4

Documentation/filesystems/caching/netfs-api.txt

+60 −13
Original line number Diff line number Diff line
@@ -33,11 +33,12 @@ This document contains the following sections: 
	(10) Page alloc/read/write

	(11) Page uncaching

	(12) Index and data file consistency

	(13) Miscellaneous cookie operations

	(14) Cookie unregistration

	(15) Index invalidation

	(16) Data file invalidation

	(17) FS-Cache specific page flags.

	(13) Cookie enablement

	(14) Miscellaneous cookie operations

	(15) Cookie unregistration

	(16) Index invalidation

	(17) Data file invalidation

	(18) FS-Cache specific page flags.





=============================
@@ -334,7 +335,8 @@ the path to the file: 
	struct fscache_cookie *

	fscache_acquire_cookie(struct fscache_cookie *parent,

			       const struct fscache_object_def *def,

			       void *netfs_data);

			       void *netfs_data,

			       bool enable);



This function creates an index entry in the index represented by parent,

filling in the index entry by calling the operations pointed to by def.
@@ -350,6 +352,10 @@ object needs to be created somewhere down the hierarchy. Furthermore, an index 
may be created in several different caches independently at different times.

This is all handled transparently, and the netfs doesn't see any of it.



A cookie will be created in the disabled state if enabled is false.  A cookie

must be enabled to do anything with it.  A disabled cookie can be enabled by

calling fscache_enable_cookie() (see below).



For example, with AFS, a cell would be added to the primary index.  This index

entry would have a dependent inode containing a volume location index for the

volume mappings within this cell:
@@ -357,7 +363,7 @@ volume mappings within this cell: 
	cell->cache =

		fscache_acquire_cookie(afs_cache_netfs.primary_index,

				       &afs_cell_cache_index_def,

				       cell);

				       cell, true);



Then when a volume location was accessed, it would be entered into the cell's

index and an inode would be allocated that acts as a volume type and hash chain
@@ -366,7 +372,7 @@ combination: 
	vlocation->cache =

		fscache_acquire_cookie(cell->cache,

				       &afs_vlocation_cache_index_def,

				       vlocation);

				       vlocation, true);



And then a particular flavour of volume (R/O for example) could be added to

that index, creating another index for vnodes (AFS inode equivalents):
@@ -374,7 +380,7 @@ that index, creating another index for vnodes (AFS inode equivalents): 
	volume->cache =

		fscache_acquire_cookie(vlocation->cache,

				       &afs_volume_cache_index_def,

				       volume);

				       volume, true);





======================
@@ -388,7 +394,7 @@ the object definition should be something other than index type. 
	vnode->cache =

		fscache_acquire_cookie(volume->cache,

				       &afs_vnode_cache_object_def,

				       vnode);

				       vnode, true);





=================================
@@ -404,7 +410,7 @@ it would be some other type of object such as a data file. 
	xattr->cache =

		fscache_acquire_cookie(vnode->cache,

				       &afs_xattr_cache_object_def,

				       xattr);

				       xattr, true);



Miscellaneous objects might be used to store extended attributes or directory

entries for example.
@@ -733,6 +739,47 @@ Note that partial updates may happen automatically at other times, such as when 
data blocks are added to a data file object.





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

COOKIE ENABLEMENT

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



Cookies exist in one of two states: enabled and disabled.  If a cookie is

disabled, it ignores all attempts to acquire child cookies; check, update or

invalidate its state; allocate, read or write backing pages - though it is

still possible to uncache pages and relinquish the cookie.



The initial enablement state is set by fscache_acquire_cookie(), but the cookie

can be enabled or disabled later.  To disable a cookie, call:

    

	void fscache_disable_cookie(struct fscache_cookie *cookie,

    				    bool invalidate);

    

If the cookie is not already disabled, this locks the cookie against other

enable and disable ops, marks the cookie as being disabled, discards or

invalidates any backing objects and waits for cessation of activity on any

associated object before unlocking the cookie.



All possible failures are handled internally.  The caller should consider

calling fscache_uncache_all_inode_pages() afterwards to make sure all page

markings are cleared up.

    

Cookies can be enabled or reenabled with:

    

    	void fscache_enable_cookie(struct fscache_cookie *cookie,

    				   bool (*can_enable)(void *data),

    				   void *data)

    

If the cookie is not already enabled, this locks the cookie against other

enable and disable ops, invokes can_enable() and, if the cookie is not an index

cookie, will begin the procedure of acquiring backing objects.



The optional can_enable() function is passed the data argument and returns a

ruling as to whether or not enablement should actually be permitted to begin.



All possible failures are handled internally.  The cookie will only be marked

as enabled if provisional backing objects are allocated.





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

MISCELLANEOUS COOKIE OPERATIONS

===============================
@@ -778,7 +825,7 @@ COOKIE UNREGISTRATION 
To get rid of a cookie, this function should be called.



	void fscache_relinquish_cookie(struct fscache_cookie *cookie,

				       int retire);

				       bool retire);



If retire is non-zero, then the object will be marked for recycling, and all

copies of it will be removed from all active caches in which it is present.

fs/9p/cache.c

+3 −3
Original line number Diff line number Diff line
@@ -90,7 +90,7 @@ void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses) 


	v9ses->fscache = fscache_acquire_cookie(v9fs_cache_netfs.primary_index,

						&v9fs_cache_session_index_def,

						v9ses);

						v9ses, true);

	p9_debug(P9_DEBUG_FSC, "session %p get cookie %p\n",

		 v9ses, v9ses->fscache);

}
@@ -204,7 +204,7 @@ void v9fs_cache_inode_get_cookie(struct inode *inode) 
	v9ses = v9fs_inode2v9ses(inode);

	v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,

						  &v9fs_cache_inode_index_def,

						  v9inode);

						  v9inode, true);



	p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n",

		 inode, v9inode->fscache);
@@ -271,7 +271,7 @@ void v9fs_cache_inode_reset_cookie(struct inode *inode) 
	v9ses = v9fs_inode2v9ses(inode);

	v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,

						  &v9fs_cache_inode_index_def,

						  v9inode);

						  v9inode, true);

	p9_debug(P9_DEBUG_FSC, "inode %p revalidating cookie old %p new %p\n",

		 inode, old, v9inode->fscache);

fs/afs/cell.c

+1 −1
Original line number Diff line number Diff line
@@ -179,7 +179,7 @@ struct afs_cell *afs_cell_create(const char *name, unsigned namesz, 
	/* put it up for caching (this never returns an error) */

	cell->cache = fscache_acquire_cookie(afs_cache_netfs.primary_index,

					     &afs_cell_cache_index_def,

					     cell);

					     cell, true);

#endif



	/* add to the cell lists */

fs/afs/inode.c

+1 −1
Original line number Diff line number Diff line
@@ -259,7 +259,7 @@ struct inode *afs_iget(struct super_block *sb, struct key *key, 
#ifdef CONFIG_AFS_FSCACHE

	vnode->cache = fscache_acquire_cookie(vnode->volume->cache,

					      &afs_vnode_cache_index_def,

					      vnode);

					      vnode, true);

#endif



	ret = afs_inode_map_status(vnode, key);

fs/afs/vlocation.c

+2 −1
Original line number Diff line number Diff line
@@ -308,7 +308,8 @@ static int afs_vlocation_fill_in_record(struct afs_vlocation *vl, 
	/* see if we have an in-cache copy (will set vl->valid if there is) */

#ifdef CONFIG_AFS_FSCACHE

	vl->cache = fscache_acquire_cookie(vl->cell->cache,

					   &afs_vlocation_cache_index_def, vl);

					   &afs_vlocation_cache_index_def, vl,

					   true);

#endif



	if (vl->valid) {

CRA Git | Maintained and supported by SUSTech CRA and CCSE