netfs: Optimise away reads above the point at which there can be no data

Track the file position above which the server is not expected to have any
data (the "zero point") and preemptively assume that we can satisfy
requests by filling them with zeroes locally rather than attempting to
download them if they're over that line - even if we've written data back
to the server.  Assume that any data that was written back above that
position is held in the local cache.  Note that we have to split requests
that straddle the line.

Make use of this to optimise away some reads from the server.  We need to
set the zero point in the following circumstances:

 (1) When we see an extant remote inode and have no cache for it, we set
     the zero_point to i_size.

 (2) On local inode creation, we set zero_point to 0.

 (3) On local truncation down, we reduce zero_point to the new i_size if
     the new i_size is lower.

 (4) On local truncation up, we don't change zero_point.

 (5) On local modification, we don't change zero_point.

 (6) On remote invalidation, we set zero_point to the new i_size.

 (7) If stored data is discarded from the pagecache or culled from fscache,
     we must set zero_point above that if the data also got written to the
     server.

 (8) If dirty data is written back to the server, but not fscache, we must
     set zero_point above that.

 (9) If a direct I/O write is made, set zero_point above that.

Assuming the above, any read from the server at or above the zero_point
position will return all zeroes.

The zero_point value can be stored in the cache, provided the above rules
are applied to it by any code that culls part of the local cache.

Signed-off-by: David Howells <dhowells@redhat.com>
cc: Jeff Layton <jlayton@kernel.org>
cc: linux-cachefs@redhat.com
cc: linux-fsdevel@vger.kernel.org
cc: linux-mm@kvack.org

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

diff --git a/fs/afs/dynroot.c b/fs/afs/dynroot.c
index 1f656005018ea07db18ed3944548ed0424dbab67..9c517269ff9543268d668d1cafb5063801d2913c 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(&vnode->netfs, NULL);
+       netfs_inode_init(&vnode->netfs, NULL, false);
        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 37485ae3147144967f31c7cf65f0aad543ad988b..381521e9e1183a7e313e0f6888738aa7c1a5b947 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, &afs_req_ops);
+       netfs_inode_init(&vnode->netfs, &afs_req_ops, true);
 }
 
 /*
@@ -168,6 +168,7 @@ static void afs_apply_status(struct afs_operation *op,
        struct inode *inode = &vnode->netfs.inode;
        struct timespec64 t;
        umode_t mode;
+       bool unexpected_jump = false;
        bool data_changed = false;
        bool change_size = vp->set_size;
 
@@ -231,6 +232,7 @@ static void afs_apply_status(struct afs_operation *op,
                }
                change_size = true;
                data_changed = true;
+               unexpected_jump = true;
        } else if (vnode->status.type == AFS_FTYPE_DIR) {
                /* Expected directory change is handled elsewhere so
                 * that we can locally edit the directory and save on a
@@ -252,6 +254,8 @@ static void afs_apply_status(struct afs_operation *op,
                vnode->netfs.remote_i_size = status->size;
                if (change_size || status->size > i_size_read(inode)) {
                        afs_set_i_size(vnode, status->size);
+                       if (unexpected_jump)
+                               vnode->netfs.zero_point = status->size;
                        inode_set_ctime_to_ts(inode, t);
                        inode_set_atime_to_ts(inode, t);
                }
@@ -865,17 +869,17 @@ static void afs_setattr_success(struct afs_operation *op)
 static void afs_setattr_edit_file(struct afs_operation *op)
 {
        struct afs_vnode_param *vp = &op->file[0];
-       struct inode *inode = &vp->vnode->netfs.inode;
+       struct afs_vnode *vnode = vp->vnode;
 
        if (op->setattr.attr->ia_valid & ATTR_SIZE) {
                loff_t size = op->setattr.attr->ia_size;
                loff_t i_size = op->setattr.old_i_size;
 
-               if (size < i_size)
-                       truncate_pagecache(inode, size);
-               if (size != i_size)
-                       fscache_resize_cookie(afs_vnode_cache(vp->vnode),
-                                             vp->scb.status.size);
+               if (size != i_size) {
+                       truncate_setsize(&vnode->netfs.inode, size);
+                       netfs_resize_file(&vnode->netfs, size, true);
+                       fscache_resize_cookie(afs_vnode_cache(vnode), size);
+               }
        }
 }
 
@@ -943,11 +947,11 @@ int afs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
                 */
                if (!(attr->ia_valid & (supported & ~ATTR_SIZE & ~ATTR_MTIME)) &&
                    attr->ia_size < i_size &&
-                   attr->ia_size > vnode->status.size) {
-                       truncate_pagecache(inode, attr->ia_size);
+                   attr->ia_size > vnode->netfs.remote_i_size) {
+                       truncate_setsize(inode, attr->ia_size);
+                       netfs_resize_file(&vnode->netfs, size, false);
                        fscache_resize_cookie(afs_vnode_cache(vnode),
                                              attr->ia_size);
-                       i_size_write(inode, attr->ia_size);
                        ret = 0;
                        goto out_unlock;
                }

diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 3149d79a9dbe5244c1ba407bddd006a0fd687ab2..0c25d326afc41d9d4d8ba98d3c6c5976647bb3fe 100644 (file)
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -574,7 +574,7 @@ struct inode *ceph_alloc_inode(struct super_block *sb)
        doutc(fsc->client, "%p\n", &ci->netfs.inode);
 
        /* Set parameters for the netfs library */
-       netfs_inode_init(&ci->netfs, &ceph_netfs_ops);
+       netfs_inode_init(&ci->netfs, &ceph_netfs_ops, false);
 
        spin_lock_init(&ci->i_ceph_lock);
 

diff --git a/fs/netfs/buffered_write.c b/fs/netfs/buffered_write.c
index 6ca6c4bde5eb2bf49371a81197446acaf9a513d0..08f28800232c3cfb2da229e1abd0095dea00a030 100644 (file)
--- a/fs/netfs/buffered_write.c
+++ b/fs/netfs/buffered_write.c
@@ -73,7 +73,7 @@ static enum netfs_how_to_modify netfs_how_to_modify(struct netfs_inode *ctx,
        if (folio_test_uptodate(folio))
                return NETFS_FOLIO_IS_UPTODATE;
 
-       if (pos >= ctx->remote_i_size)
+       if (pos >= ctx->zero_point)
                return NETFS_MODIFY_AND_CLEAR;
 
        if (!maybe_trouble && offset == 0 && len >= flen)

diff --git a/fs/netfs/direct_write.c b/fs/netfs/direct_write.c
index bb0c2718f57bdb12651f428c5e838553235be18b..aad05f2349a48277b2d332f06c8e53cb38307b00 100644 (file)
--- a/fs/netfs/direct_write.c
+++ b/fs/netfs/direct_write.c
@@ -134,6 +134,7 @@ ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from)
        struct file *file = iocb->ki_filp;
        struct inode *inode = file->f_mapping->host;
        struct netfs_inode *ictx = netfs_inode(inode);
+       unsigned long long end;
        ssize_t ret;
 
        _enter("%llx,%zx,%llx", iocb->ki_pos, iov_iter_count(from), i_size_read(inode));
@@ -155,6 +156,9 @@ ssize_t netfs_unbuffered_write_iter(struct kiocb *iocb, struct iov_iter *from)
        ret = kiocb_invalidate_pages(iocb, iov_iter_count(from));
        if (ret < 0)
                goto out;
+       end = iocb->ki_pos + iov_iter_count(from);
+       if (end > ictx->zero_point)
+               ictx->zero_point = end;
 
        fscache_invalidate(netfs_i_cookie(ictx), NULL, i_size_read(inode),
                           FSCACHE_INVAL_DIO_WRITE);

diff --git a/fs/netfs/io.c b/fs/netfs/io.c
index 14c18be5aca009c32d8c6ab537d8f994f05be434..5b5af96cd4b95bc445132613a6c6249b6000c223 100644 (file)
--- a/fs/netfs/io.c
+++ b/fs/netfs/io.c
@@ -569,6 +569,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,
                        struct iov_iter *io_iter)
 {
        enum netfs_io_source source = NETFS_DOWNLOAD_FROM_SERVER;
+       struct netfs_inode *ictx = netfs_inode(rreq->inode);
        size_t lsize;
 
        _enter("%llx-%llx,%llx", subreq->start, subreq->start + subreq->len, rreq->i_size);
@@ -586,6 +587,14 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,
                 * to make serial calls, it can indicate a short read and then
                 * we will call it again.
                 */
+               if (rreq->origin != NETFS_DIO_READ) {
+                       if (subreq->start >= ictx->zero_point) {
+                               source = NETFS_FILL_WITH_ZEROES;
+                               goto set;
+                       }
+                       if (subreq->len > ictx->zero_point - subreq->start)
+                               subreq->len = ictx->zero_point - subreq->start;
+               }
                if (subreq->len > rreq->i_size - subreq->start)
                        subreq->len = rreq->i_size - subreq->start;
                if (rreq->rsize && subreq->len > rreq->rsize)
@@ -607,6 +616,7 @@ netfs_rreq_prepare_read(struct netfs_io_request *rreq,
                }
        }
 
+set:
        if (subreq->len > rreq->len)
                pr_warn("R=%08x[%u] SREQ>RREQ %zx > %zx\n",
                        rreq->debug_id, subreq->debug_index,

diff --git a/fs/netfs/misc.c b/fs/netfs/misc.c
index eeb44abe59c5232f618619ae152ad7c5b366e24d..0e3af37fc9243f7a0d351840904aa0ce5d91ee59 100644 (file)
--- a/fs/netfs/misc.c
+++ b/fs/netfs/misc.c
@@ -240,6 +240,11 @@ EXPORT_SYMBOL(netfs_invalidate_folio);
 bool netfs_release_folio(struct folio *folio, gfp_t gfp)
 {
        struct netfs_inode *ctx = netfs_inode(folio_inode(folio));
+       unsigned long long end;
+
+       end = folio_pos(folio) + folio_size(folio);
+       if (end > ctx->zero_point)
+               ctx->zero_point = end;
 
        if (folio_test_private(folio))
                return false;

diff --git a/fs/nfs/fscache.h b/fs/nfs/fscache.h
index 5407ab8c8783574da8c83e0e752f8d3640bfb8d7..e3cb4923316b2cc044fd87ef6399c867ba19663c 100644 (file)
--- a/fs/nfs/fscache.h
+++ b/fs/nfs/fscache.h
@@ -80,7 +80,7 @@ static inline void nfs_netfs_put(struct nfs_netfs_io_data *netfs)
 }
 static inline void nfs_netfs_inode_init(struct nfs_inode *nfsi)
 {
-       netfs_inode_init(&nfsi->netfs, &nfs_netfs_ops);
+       netfs_inode_init(&nfsi->netfs, &nfs_netfs_ops, false);
 }
 extern void nfs_netfs_initiate_read(struct nfs_pgio_header *hdr);
 extern void nfs_netfs_read_completion(struct nfs_pgio_header *hdr);

diff --git a/fs/smb/client/cifsfs.c b/fs/smb/client/cifsfs.c
index 96a65cf9b5ec91011c139993b7fcae249e328c48..07cd88897c3319dfc9d0cbbaffdd296eedfa8fee 100644 (file)
--- a/fs/smb/client/cifsfs.c
+++ b/fs/smb/client/cifsfs.c
@@ -1220,7 +1220,7 @@ static int cifs_precopy_set_eof(struct inode *src_inode, struct cifsInodeInfo *s
        if (rc < 0)
                goto set_failed;
 
-       netfs_resize_file(&src_cifsi->netfs, src_end);
+       netfs_resize_file(&src_cifsi->netfs, src_end, true);
        fscache_resize_cookie(cifs_inode_cookie(src_inode), src_end);
        return 0;
 
@@ -1351,7 +1351,7 @@ static loff_t cifs_remap_file_range(struct file *src_file, loff_t off,
                        smb_file_src, smb_file_target, off, len, destoff);
                if (rc == 0 && new_size > i_size_read(target_inode)) {
                        truncate_setsize(target_inode, new_size);
-                       netfs_resize_file(&target_cifsi->netfs, new_size);
+                       netfs_resize_file(&target_cifsi->netfs, new_size, true);
                        fscache_resize_cookie(cifs_inode_cookie(target_inode),
                                              new_size);
                }

diff --git a/include/linux/netfs.h b/include/linux/netfs.h
index 8a2dd882a78141e9f384fb8a6d959f8425d6eba8..852956aa3c4bb4952db03fdc0f99bafe98fec358 100644 (file)
--- a/include/linux/netfs.h
+++ b/include/linux/netfs.h
@@ -136,6 +136,8 @@ struct netfs_inode {
        struct fscache_cookie   *cache;
 #endif
        loff_t                  remote_i_size;  /* Size of the remote file */
+       loff_t                  zero_point;     /* Size after which we assume there's no data
+                                                * on the server */
        unsigned long           flags;
 #define NETFS_ICTX_ODIRECT     0               /* The file has DIO in progress */
 #define NETFS_ICTX_UNBUFFERED  1               /* I/O should not use the pagecache */
@@ -453,31 +455,44 @@ static inline struct netfs_inode *netfs_inode(struct inode *inode)
  * netfs_inode_init - Initialise a netfslib inode context
  * @ctx: The netfs inode to initialise
  * @ops: The netfs's operations list
+ * @use_zero_point: True to use the zero_point read optimisation
  *
  * 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 netfs_inode *ctx,
-                                   const struct netfs_request_ops *ops)
+                                   const struct netfs_request_ops *ops,
+                                   bool use_zero_point)
 {
        ctx->ops = ops;
        ctx->remote_i_size = i_size_read(&ctx->inode);
+       ctx->zero_point = LLONG_MAX;
        ctx->flags = 0;
 #if IS_ENABLED(CONFIG_FSCACHE)
        ctx->cache = NULL;
 #endif
+       /* ->releasepage() drives zero_point */
+       if (use_zero_point) {
+               ctx->zero_point = ctx->remote_i_size;
+               mapping_set_release_always(ctx->inode.i_mapping);
+       }
 }
 
 /**
  * netfs_resize_file - Note that a file got resized
  * @ctx: The netfs inode being resized
  * @new_i_size: The new file size
+ * @changed_on_server: The change was applied to the server
  *
  * Inform the netfs lib that a file got resized so that it can adjust its state.
  */
-static inline void netfs_resize_file(struct netfs_inode *ctx, loff_t new_i_size)
+static inline void netfs_resize_file(struct netfs_inode *ctx, loff_t new_i_size,
+                                    bool changed_on_server)
 {
-       ctx->remote_i_size = new_i_size;
+       if (changed_on_server)
+               ctx->remote_i_size = new_i_size;
+       if (new_i_size < ctx->zero_point)
+               ctx->zero_point = new_i_size;
 }
 
 /**