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

Pull fscache cleanups from David Howells: - fix checker complaint in afs - two netfs cleanups: - netfs_inode calling convention cleanup plus the requisite documentation changes - replace the ->cleanup op with a ->free_request op. This is possible as the I/O request is now always available at the cleanup point as the stuff to be cleaned up is no longer passed into the API functions, but rather obtained by ->init_request. * 'fscache-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs: netfs: Rename the netfs_io_request cleanup op and give it an op pointer netfs: Further cleanups after struct netfs_inode wrapper introduced afs: Fix some checker issues

Linus Torvalds committed 4 years ago

Commit 045fb9c2 parents b098915 40a811017 files · +60 −62Browse files

Unified · Split

17 files

Documentation/filesystems/netfs_library.rst +17 −16
fs/9p/v9fs.h +1 −1
fs/9p/vfs_addr.c +6 −7
fs/9p/vfs_inode.c +2 −1
fs/afs/dynroot.c +1 −1
fs/afs/file.c +3 −3
fs/afs/inode.c +1 −1
fs/afs/internal.h +1 −1
fs/afs/volume.c +1 −2
fs/afs/write.c +1 −1
fs/ceph/addr.c +6 −6
fs/ceph/cache.h +1 −1
fs/ceph/inode.c +1 −1
fs/cifs/fscache.h +1 −1
fs/netfs/buffered_read.c +3 −2
fs/netfs/objects.c +3 −3
include/linux/netfs.h +11 −14

Documentation/filesystems/netfs_library.rst+17−16

 provided.  Firstly, a function to perform basic initialisation on a context and
 set the operations table pointer::
-	void netfs_inode_init(struct inode *inode,
+	void netfs_inode_init(struct netfs_inode *ctx,
 			      const struct netfs_request_ops *ops);
 then a function to cast from the VFS inode structure to the netfs context::
 and finally, a function to get the cache cookie pointer from the context
 attached to an inode (or NULL if fscache is disabled)::
-	struct fscache_cookie *netfs_i_cookie(struct inode *inode);
+	struct fscache_cookie *netfs_i_cookie(struct netfs_inode *ctx);
 Buffered Read Helpers
 	void netfs_readahead(struct readahead_control *ractl);
 	int netfs_read_folio(struct file *file,
-			   struct folio *folio);
+			     struct folio *folio);
-	int netfs_write_begin(struct file *file,
+	int netfs_write_begin(struct netfs_inode *ctx,
+			      struct file *file,
 			      struct address_space *mapping,
 			      loff_t pos,
 			      unsigned int len,
 through the suppplied table of operations.  Waits will be performed as
 necessary before returning for helpers that are meant to be synchronous.
-If an error occurs and netfs_priv is non-NULL, ops->cleanup() will be called to
+If an error occurs, the ->free_request() will be called to clean up the
-deal with it.  If some parts of the request are in progress when an error
+netfs_io_request struct allocated.  If some parts of the request are in
-occurs, the request will get partially completed if sufficient data is read.
+progress when an error occurs, the request will get partially completed if
+sufficient data is read.
 Additionally, there is::
  * ``netfs_priv``
    The network filesystem's private data.  The value for this can be passed in
-   to the helper functions or set during the request.  The ->cleanup() op will
+   to the helper functions or set during the request.
-   be called if this is non-NULL at the end.
  * ``start``
  * ``len``
 	struct netfs_request_ops {
 		void (*init_request)(struct netfs_io_request *rreq, struct file *file);
+		void (*free_request)(struct netfs_io_request *rreq);
 		int (*begin_cache_operation)(struct netfs_io_request *rreq);
 		void (*expand_readahead)(struct netfs_io_request *rreq);
 		bool (*clamp_length)(struct netfs_io_subrequest *subreq);
 		int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
 					 struct folio *folio, void **_fsdata);
 		void (*done)(struct netfs_io_request *rreq);
-		void (*cleanup)(struct address_space *mapping, void *netfs_priv);
 	};
 The operations are as follows:
  * ``init_request()``
    [Optional] This is called to initialise the request structure.  It is given
-   the file for reference and can modify the ->netfs_priv value.
+   the file for reference.
+ * ``free_request()``
+   [Optional] This is called as the request is being deallocated so that the
+   filesystem can clean up any state it has attached there.
  * ``begin_cache_operation()``
    [Optional] This is called after the folios in the request have all been
    unlocked (and marked uptodate if applicable).
- * ``cleanup``
-   [Optional] This is called as the request is being deallocated so that the
-   filesystem can clean up ->netfs_priv.
 Read Helper Procedure

fs/9p/v9fs.h+1−1

@@ -124,7 +124,7 @@ static inline struct v9fs_inode V9FS_I(const struct inode inode) · 123 unmodified lines
124	static inline struct fscache_cookie v9fs_inode_cookie(struct v9fs_inode v9inode)	124	static inline struct fscache_cookie v9fs_inode_cookie(struct v9fs_inode v9inode)
125	{	125	{
126	#ifdef CONFIG_9P_FSCACHE	126	#ifdef CONFIG_9P_FSCACHE
127	return netfs_i_cookie(&v9inode->netfs.inode);	127	return netfs_i_cookie(&v9inode->netfs);
128	#else	128	#else
129	return NULL;	129	return NULL;
130	#endif	130	#endif

fs/9p/vfs_addr.c+6−7

 }
 /**
- * v9fs_req_cleanup - Cleanup request initialized by v9fs_init_request
+ * v9fs_free_request - Cleanup request initialized by v9fs_init_rreq
- * @mapping: unused mapping of request to cleanup
+ * @rreq: The I/O request to clean up
- * @priv: private data to cleanup, a fid, guaranted non-null.
  */
-static void v9fs_req_cleanup(struct address_space *mapping, void *priv)
+static void v9fs_free_request(struct netfs_io_request *rreq)
 {
-	struct p9_fid *fid = priv;
+	struct p9_fid *fid = rreq->netfs_priv;
 	p9_client_clunk(fid);
 }
 const struct netfs_request_ops v9fs_req_ops = {
 	.init_request		= v9fs_init_request,
+	.free_request		= v9fs_free_request,
 	.begin_cache_operation	= v9fs_begin_cache_operation,
 	.issue_read		= v9fs_issue_read,
-	.cleanup		= v9fs_req_cleanup,
 };
 /**
 	 * file.  We need to do this before we get a lock on the page in case
 	 * there's more than one writer competing for the same cache block.
 	 */
-	retval = netfs_write_begin(filp, mapping, pos, len, &folio, fsdata);
+	retval = netfs_write_begin(&v9inode->netfs, filp, mapping, pos, len, &folio, fsdata);
 	if (retval < 0)
 		return retval;

fs/9p/vfs_inode.c+2−1

@@ -252,7 +252,8 @@ void v9fs_free_inode(struct inode *inode) · 251 unmodified lines
252	*/	252	*/
253	static void v9fs_set_netfs_context(struct inode *inode)	253	static void v9fs_set_netfs_context(struct inode *inode)
254	{	254	{
255	netfs_inode_init(inode, &v9fs_req_ops);	255	struct v9fs_inode *v9inode = V9FS_I(inode);
		256	netfs_inode_init(&v9inode->netfs, &v9fs_req_ops);
256	}	257	}
257		258
258	int v9fs_init_inode(struct v9fs_session_info *v9ses,	259	int v9fs_init_inode(struct v9fs_session_info *v9ses,

fs/afs/dynroot.c+1−1

@@ -76,7 +76,7 @@ struct inode afs_iget_pseudo_dir(struct super_block sb, bool root) · 75 unmodified lines
76	/* there shouldn't be an existing inode */	76	/* there shouldn't be an existing inode */
77	BUG_ON(!(inode->i_state & I_NEW));	77	BUG_ON(!(inode->i_state & I_NEW));
78		78
79	netfs_inode_init(inode, NULL);	79	netfs_inode_init(&vnode->netfs, NULL);
80	inode->i_size = 0;	80	inode->i_size = 0;
81	inode->i_mode = S_IFDIR \| S_IRUGO \| S_IXUGO;	81	inode->i_mode = S_IFDIR \| S_IRUGO \| S_IXUGO;
82	if (root) {	82	if (root) {

fs/afs/file.c+3−3

 	return test_bit(AFS_VNODE_DELETED, &vnode->flags) ? -ESTALE : 0;
 }
-static void afs_priv_cleanup(struct address_space *mapping, void *netfs_priv)
+static void afs_free_request(struct netfs_io_request *rreq)
 {
-	key_put(netfs_priv);
+	key_put(rreq->netfs_priv);
 }
 const struct netfs_request_ops afs_req_ops = {
 	.init_request		= afs_init_request,
+	.free_request		= afs_free_request,
 	.begin_cache_operation	= afs_begin_cache_operation,
 	.check_write_begin	= afs_check_write_begin,
 	.issue_read		= afs_issue_read,
-	.cleanup		= afs_priv_cleanup,
 };
 int afs_write_inode(struct inode *inode, struct writeback_control *wbc)

fs/afs/inode.c+1−1

@@ -58,7 +58,7 @@ static noinline void dump_vnode(struct afs_vnode vnode, struct afs_vnode paren · 57 unmodified lines
58	*/	58	*/
59	static void afs_set_netfs_context(struct afs_vnode *vnode)	59	static void afs_set_netfs_context(struct afs_vnode *vnode)
60	{	60	{
61	netfs_inode_init(&vnode->netfs.inode, &afs_req_ops);	61	netfs_inode_init(&vnode->netfs, &afs_req_ops);
62	}	62	}
63		63
64	/*	64	/*

fs/afs/internal.h+1−1

@@ -670,7 +670,7 @@ struct afs_vnode { · 669 unmodified lines
670	static inline struct fscache_cookie afs_vnode_cache(struct afs_vnode vnode)	670	static inline struct fscache_cookie afs_vnode_cache(struct afs_vnode vnode)
671	{	671	{
672	#ifdef CONFIG_AFS_FSCACHE	672	#ifdef CONFIG_AFS_FSCACHE
673	return netfs_i_cookie(&vnode->netfs.inode);	673	return netfs_i_cookie(&vnode->netfs);
674	#else	674	#else
675	return NULL;	675	return NULL;
676	#endif	676	#endif

fs/afs/volume.c+1−2

@@ -9,8 +9,7 @@ · 8 unmodified lines
9	#include <linux/slab.h>	9	#include <linux/slab.h>
10	#include "internal.h"	10	#include "internal.h"
11		11
12	unsigned __read_mostly afs_volume_gc_delay = 10;	12	static unsigned __read_mostly afs_volume_record_life = 60 * 60;
13	unsigned __read_mostly afs_volume_record_life = 60 * 60;
14		13
15	/*	14	/*
16	* Insert a volume into a cell. If there's an existing volume record, that is	15	* Insert a volume into a cell. If there's an existing volume record, that is

fs/afs/write.c+1−1

@@ -60,7 +60,7 @@ int afs_write_begin(struct file file, struct address_space mapping, · 59 unmodified lines
60	* file. We need to do this before we get a lock on the page in case	60	* file. We need to do this before we get a lock on the page in case
61	* there's more than one writer competing for the same cache block.	61	* there's more than one writer competing for the same cache block.
62	*/	62	*/
63	ret = netfs_write_begin(file, mapping, pos, len, &folio, fsdata);	63	ret = netfs_write_begin(&vnode->netfs, file, mapping, pos, len, &folio, fsdata);
64	if (ret < 0)	64	if (ret < 0)
65	return ret;	65	return ret;
66		66

fs/ceph/addr.c+6−6

 	return 0;
 }
-static void ceph_readahead_cleanup(struct address_space *mapping, void *priv)
+static void ceph_netfs_free_request(struct netfs_io_request *rreq)
 {
-	struct inode *inode = mapping->host;
+	struct ceph_inode_info *ci = ceph_inode(rreq->inode);
-	struct ceph_inode_info *ci = ceph_inode(inode);
+	int got = (uintptr_t)rreq->netfs_priv;
-	int got = (uintptr_t)priv;
 	if (got)
 		ceph_put_cap_refs(ci, got);
 const struct netfs_request_ops ceph_netfs_ops = {
 	.init_request		= ceph_init_request,
+	.free_request		= ceph_netfs_free_request,
 	.begin_cache_operation	= ceph_begin_cache_operation,
 	.issue_read		= ceph_netfs_issue_read,
 	.expand_readahead	= ceph_netfs_expand_readahead,
 	.clamp_length		= ceph_netfs_clamp_length,
 	.check_write_begin	= ceph_netfs_check_write_begin,
-	.cleanup		= ceph_readahead_cleanup,
 };
 #ifdef CONFIG_CEPH_FSCACHE
 			    struct page **pagep, void **fsdata)
 {
 	struct inode *inode = file_inode(file);
+	struct ceph_inode_info *ci = ceph_inode(inode);
 	struct folio *folio = NULL;
 	int r;
-	r = netfs_write_begin(file, inode->i_mapping, pos, len, &folio, NULL);
+	r = netfs_write_begin(&ci->netfs, file, inode->i_mapping, pos, len, &folio, NULL);
 	if (r == 0)
 		folio_wait_fscache(folio);
 	if (r < 0) {

fs/ceph/cache.h+1−1

@@ -28,7 +28,7 @@ void ceph_fscache_invalidate(struct inode *inode, bool dio_write); · 27 unmodified lines
28		28
29	static inline struct fscache_cookie ceph_fscache_cookie(struct ceph_inode_info ci)	29	static inline struct fscache_cookie ceph_fscache_cookie(struct ceph_inode_info ci)
30	{	30	{
31	return netfs_i_cookie(&ci->netfs.inode);	31	return netfs_i_cookie(&ci->netfs);
32	}	32	}
33		33
34	static inline void ceph_fscache_resize(struct inode *inode, loff_t to)	34	static inline void ceph_fscache_resize(struct inode *inode, loff_t to)

fs/ceph/inode.c+1−1

@@ -460,7 +460,7 @@ struct inode ceph_alloc_inode(struct super_block sb) · 459 unmodified lines
460	dout("alloc_inode %p\n", &ci->netfs.inode);	460	dout("alloc_inode %p\n", &ci->netfs.inode);
461		461
462	/* Set parameters for the netfs library */	462	/* Set parameters for the netfs library */
463	netfs_inode_init(&ci->netfs.inode, &ceph_netfs_ops);	463	netfs_inode_init(&ci->netfs, &ceph_netfs_ops);
464		464
465	spin_lock_init(&ci->i_ceph_lock);	465	spin_lock_init(&ci->i_ceph_lock);
466		466

fs/cifs/fscache.h+1−1

@@ -61,7 +61,7 @@ void cifs_fscache_fill_coherency(struct inode *inode, · 60 unmodified lines
61		61
62	static inline struct fscache_cookie cifs_inode_cookie(struct inode inode)	62	static inline struct fscache_cookie cifs_inode_cookie(struct inode inode)
63	{	63	{
64	return netfs_i_cookie(inode);	64	return netfs_i_cookie(&CIFS_I(inode)->netfs);
65	}	65	}
66		66
67	static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags)	67	static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags)

fs/netfs/buffered_read.c+3−2

 /**
  * netfs_write_begin - Helper to prepare for writing
+ * @ctx: The netfs context
  * @file: The file to read from
  * @mapping: The mapping to read from
  * @pos: File position at which the write will begin
  *
  * This is usable whether or not caching is enabled.
  */
-int netfs_write_begin(struct file *file, struct address_space *mapping,
+int netfs_write_begin(struct netfs_inode *ctx,
+		      struct file *file, struct address_space *mapping,
 		      loff_t pos, unsigned int len, struct folio **_folio,
 		      void **_fsdata)
 {
 	struct netfs_io_request *rreq;
-	struct netfs_inode *ctx = netfs_inode(file_inode(file ));
 	struct folio *folio;
 	unsigned int fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE;
 	pgoff_t index = pos >> PAGE_SHIFT;

fs/netfs/objects.c+3−3

 	struct netfs_io_request *rreq =
 		container_of(work, struct netfs_io_request, work);
-	netfs_clear_subrequests(rreq, false);
-	if (rreq->netfs_priv)
-		rreq->netfs_ops->cleanup(rreq->mapping, rreq->netfs_priv);
 	trace_netfs_rreq(rreq, netfs_rreq_trace_free);
+	netfs_clear_subrequests(rreq, false);
+	if (rreq->netfs_ops->free_request)
+		rreq->netfs_ops->free_request(rreq);
 	if (rreq->cache_resources.ops)
 		rreq->cache_resources.ops->end_operation(&rreq->cache_resources);
 	kfree(rreq);

include/linux/netfs.h+11−14

  */
 struct netfs_request_ops {
 	int (*init_request)(struct netfs_io_request *rreq, struct file *file);
+	void (*free_request)(struct netfs_io_request *rreq);
 	int (*begin_cache_operation)(struct netfs_io_request *rreq);
 	void (*expand_readahead)(struct netfs_io_request *rreq);
 	bool (*clamp_length)(struct netfs_io_subrequest *subreq);
 	void (*issue_read)(struct netfs_io_subrequest *subreq);
 	int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
 				 struct folio *folio, void **_fsdata);
 	void (*done)(struct netfs_io_request *rreq);
-	void (*cleanup)(struct address_space *mapping, void *netfs_priv);
 };
 /*
 struct readahead_control;
 extern void netfs_readahead(struct readahead_control *);
 int netfs_read_folio(struct file *, struct folio *);
-extern int netfs_write_begin(struct file *, struct address_space *,
+extern int netfs_write_begin(struct netfs_inode *,
+			     struct file *, struct address_space *,
 			     loff_t, unsigned int, struct folio **,
 			     void **);
 /**
  * netfs_inode_init - Initialise a netfslib inode context
- * @inode: The inode with which the context is associated
+ * @inode: The netfs inode to initialise
  * @ops: The netfs's operations list
  *
  * Initialise the netfs library context struct.  This is expected to follow on
  * directly from the VFS inode struct.
  */
-static inline void netfs_inode_init(struct inode *inode,
+static inline void netfs_inode_init(struct netfs_inode *ctx,
 				    const struct netfs_request_ops *ops)
 {
-	struct netfs_inode *ctx = netfs_inode(inode);
 	ctx->ops = ops;
-	ctx->remote_i_size = i_size_read(inode);
+	ctx->remote_i_size = i_size_read(&ctx->inode);
 #if IS_ENABLED(CONFIG_FSCACHE)
 	ctx->cache = NULL;
 #endif
 /**
  * netfs_resize_file - Note that a file got resized
- * @inode: The inode being resized
+ * @ctx: The netfs inode being resized
  * @new_i_size: The new file size
  *
  * Inform the netfs lib that a file got resized so that it can adjust its state.
  */
-static inline void netfs_resize_file(struct inode *inode, loff_t new_i_size)
+static inline void netfs_resize_file(struct netfs_inode *ctx, loff_t new_i_size)
 {
-	struct netfs_inode *ctx = netfs_inode(inode);
 	ctx->remote_i_size = new_i_size;
 }
 /**
  * netfs_i_cookie - Get the cache cookie from the inode
- * @inode: The inode to query
+ * @ctx: The netfs inode to query
  *
  * Get the caching cookie (if enabled) from the network filesystem's inode.
  */
-static inline struct fscache_cookie *netfs_i_cookie(struct inode *inode)
+static inline struct fscache_cookie *netfs_i_cookie(struct netfs_inode *ctx)
 {
 #if IS_ENABLED(CONFIG_FSCACHE)
-	struct netfs_inode *ctx = netfs_inode(inode);
 	return ctx->cache;
 #else
 	return NULL;

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code