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 3276c3d..9332f66 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 1b219c2..6acabc2 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 90c6c1b..c004b9a 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 e660c63..419d2f3 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 3a5bbff..d7d9402 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 22811e9..89630ac 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 984b113..a6f25d9 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 f80a609..2c885b2 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 f5f116e..9763e7e 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 26c6ae0..dc502da 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 650746b..56c53ab 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 ab9a51d..aa3b941 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 d37e012..42f892c 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 6dbb4c9..a62739f 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;