netfs: Further cleanups after struct netfs_inode wrapper introduced

Change the signature of netfs helper functions to take a struct netfs_inode
pointer rather than a struct inode pointer where appropriate, thereby
relieving the need for the network filesystem to convert its internal inode
format down to the VFS inode only for netfslib to bounce it back up.  For
type safety, it's better not to do that (and it's less typing too).

Give netfs_write_begin() an extra argument to pass in a pointer to the
netfs_inode struct rather than deriving it internally from the file
pointer.  Note that the ->write_begin() and ->write_end() ops are intended
to be replaced in the future by netfslib code that manages this without the
need to call in twice for each page.

netfs_readpage() and similar are intended to be pointed at directly by the
address_space_operations table, so must stick to the signature dictated by
the function pointers there.

Changes
=======
- Updated the kerneldoc comments and documentation [DH].

Signed-off-by: David Howells <dhowells@redhat.com>
cc: linux-cachefs@redhat.com
Link: https://lore.kernel.org/r/CAHk-=wgkwKyNmNdKpQkqZ6DnmUL-x9hp0YBnUGjaPFEAdxDTbw@mail.gmail.com/

diff --git a/Documentation/filesystems/netfs_library.rst b/Documentation/filesystems/netfs_library.rst
index 3276c3d55142649e5c6bff95fb86133486b4abad..9332f66373eeebcca0aaf0d9aa11b8bd12289795 100644 (file)
--- a/Documentation/filesystems/netfs_library.rst
+++ b/Documentation/filesystems/netfs_library.rst
@@ -79,7 +79,7 @@ To help deal with the per-inode context, a number helper functions are
 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::
@@ -89,7 +89,7 @@ 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
@@ -136,8 +136,9 @@ Three read helpers are provided::
 
        void netfs_readahead(struct readahead_control *ractl);
        int netfs_read_folio(struct file *file,
-                          struct folio *folio);
-       int netfs_write_begin(struct file *file,
+                            struct folio *folio);
+       int netfs_write_begin(struct netfs_inode *ctx,
+                             struct file *file,
                              struct address_space *mapping,
                              loff_t pos,
                              unsigned int len,

diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index 1b219c21d15ebc80e087f59daeba2739b87490fe..6acabc2e7dc9dd513696dc3948a2fd90d058fd3d 100644 (file)
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -124,7 +124,7 @@ static inline struct v9fs_inode *V9FS_I(const struct inode *inode)
 static inline struct fscache_cookie *v9fs_inode_cookie(struct v9fs_inode *v9inode)
 {
 #ifdef CONFIG_9P_FSCACHE
-       return netfs_i_cookie(&v9inode->netfs.inode);
+       return netfs_i_cookie(&v9inode->netfs);
 #else
        return NULL;
 #endif

diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index 90c6c1ba03ab75888a87c4da0720137c2ad005cb..c004b9a73a924ec1e633c0b3a60393b54a03a916 100644 (file)
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -274,7 +274,7 @@ static int v9fs_write_begin(struct file *filp, struct address_space *mapping,
         * 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;
 

diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index e660c6348b9da21b6e0112c958e0dd36ce0968cd..419d2f3cf2c2633fa7caa46070a30a97078ca2f7 100644 (file)
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -252,7 +252,8 @@ void v9fs_free_inode(struct inode *inode)
  */
 static void v9fs_set_netfs_context(struct inode *inode)
 {
-       netfs_inode_init(inode, &v9fs_req_ops);
+       struct v9fs_inode *v9inode = V9FS_I(inode);
+       netfs_inode_init(&v9inode->netfs, &v9fs_req_ops);
 }
 
 int v9fs_init_inode(struct v9fs_session_info *v9ses,

diff --git a/fs/afs/dynroot.c b/fs/afs/dynroot.c
index 3a5bbffdf053461045a728ffbda1dc8e7fb06da7..d7d9402ff7182adfb702a4bc473ce0db3d3aa2ac 100644 (file)
--- a/fs/afs/dynroot.c
+++ b/fs/afs/dynroot.c
@@ -76,7 +76,7 @@ struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root)
        /* there shouldn't be an existing inode */
        BUG_ON(!(inode->i_state & I_NEW));
 
-       netfs_inode_init(inode, NULL);
+       netfs_inode_init(&vnode->netfs, NULL);
        inode->i_size           = 0;
        inode->i_mode           = S_IFDIR | S_IRUGO | S_IXUGO;
        if (root) {

diff --git a/fs/afs/inode.c b/fs/afs/inode.c
index 22811e9eacf58015b5fc1f123d3944c8ba88da1c..89630acbc2cc5410ae0d326c29e45b49f5041a98 100644 (file)
--- a/fs/afs/inode.c
+++ b/fs/afs/inode.c
@@ -58,7 +58,7 @@ static noinline void dump_vnode(struct afs_vnode *vnode, struct afs_vnode *paren
  */
 static void afs_set_netfs_context(struct afs_vnode *vnode)
 {
-       netfs_inode_init(&vnode->netfs.inode, &afs_req_ops);
+       netfs_inode_init(&vnode->netfs, &afs_req_ops);
 }
 
 /*

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 984b113a910755b8194dd7fbabf9d34e88a8652a..a6f25d9e75b52a5ab0c5a59b363e3108875d8f3c 100644 (file)
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -670,7 +670,7 @@ struct afs_vnode {
 static inline struct fscache_cookie *afs_vnode_cache(struct afs_vnode *vnode)
 {
 #ifdef CONFIG_AFS_FSCACHE
-       return netfs_i_cookie(&vnode->netfs.inode);
+       return netfs_i_cookie(&vnode->netfs);
 #else
        return NULL;
 #endif

diff --git a/fs/afs/write.c b/fs/afs/write.c
index f80a6096d91c705a6c4e8d6aec904a1eb79406f9..2c885b22de34feffc2d34a80151d58631b134a70 100644 (file)
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -60,7 +60,7 @@ int afs_write_begin(struct file *file, struct address_space *mapping,
         * 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.
         */
-       ret = netfs_write_begin(file, mapping, pos, len, &folio, fsdata);
+       ret = netfs_write_begin(&vnode->netfs, file, mapping, pos, len, &folio, fsdata);
        if (ret < 0)
                return ret;
 

diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index f5f116ed1b9e9a47301de6ded7a02c103ee97fd7..9763e7ea8148e3e96d0b167af5a78e7225cab647 100644 (file)
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -1322,10 +1322,11 @@ static int ceph_write_begin(struct file *file, struct address_space *mapping,
                            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) {

diff --git a/fs/ceph/cache.h b/fs/ceph/cache.h
index 26c6ae06e2f41dceb83ba523726dde14b6295703..dc502daac49ab580380deca8f969b3f648a4c299 100644 (file)
--- a/fs/ceph/cache.h
+++ b/fs/ceph/cache.h
@@ -28,7 +28,7 @@ void ceph_fscache_invalidate(struct inode *inode, bool dio_write);
 
 static inline struct fscache_cookie *ceph_fscache_cookie(struct ceph_inode_info *ci)
 {
-       return netfs_i_cookie(&ci->netfs.inode);
+       return netfs_i_cookie(&ci->netfs);
 }
 
 static inline void ceph_fscache_resize(struct inode *inode, loff_t to)

diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 650746b3ba999a219f7bf038e006baa5c7a1b4b4..56c53ab3618e8eb1b4aae7cf17027f9908de50d3 100644 (file)
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -460,7 +460,7 @@ struct inode *ceph_alloc_inode(struct super_block *sb)
        dout("alloc_inode %p\n", &ci->netfs.inode);
 
        /* Set parameters for the netfs library */
-       netfs_inode_init(&ci->netfs.inode, &ceph_netfs_ops);
+       netfs_inode_init(&ci->netfs, &ceph_netfs_ops);
 
        spin_lock_init(&ci->i_ceph_lock);
 

diff --git a/fs/cifs/fscache.h b/fs/cifs/fscache.h
index ab9a51d0125cd0884a1623b4da35d1f48d34c122..aa3b941a55557f257dbbc106e198a6ffbeba9c67 100644 (file)
--- a/fs/cifs/fscache.h
+++ b/fs/cifs/fscache.h
@@ -61,7 +61,7 @@ void cifs_fscache_fill_coherency(struct inode *inode,
 
 static inline struct fscache_cookie *cifs_inode_cookie(struct inode *inode)
 {
-       return netfs_i_cookie(inode);
+       return netfs_i_cookie(&CIFS_I(inode)->netfs);
 }
 
 static inline void cifs_invalidate_cache(struct inode *inode, unsigned int flags)

diff --git a/fs/netfs/buffered_read.c b/fs/netfs/buffered_read.c
index d37e012386f347a6d1f8bb1a782d918ee3f76d74..42f892c5712eae9daead74227a202ab8e5b4aa0e 100644 (file)
--- a/fs/netfs/buffered_read.c
+++ b/fs/netfs/buffered_read.c
@@ -297,6 +297,7 @@ zero_out:
 
 /**
  * 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
@@ -326,12 +327,12 @@ zero_out:
  *
  * 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;

diff --git a/include/linux/netfs.h b/include/linux/netfs.h
index 6dbb4c9ce50d77ed346e1dbd4cb37af8e965ceef..a62739f3726b3b48333be7cb5535a6de3be07fd1 100644 (file)
--- a/include/linux/netfs.h
+++ b/include/linux/netfs.h
@@ -277,7 +277,8 @@ struct netfs_cache_ops {
 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 **);
 
@@ -302,19 +303,17 @@ static inline struct netfs_inode *netfs_inode(struct inode *inode)
 
 /**
  * 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
@@ -322,28 +321,25 @@ static inline void netfs_inode_init(struct inode *inode,
 
 /**
  * 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;