xfs: teach xfile to pass back direct-map pages to caller

Certain xfile array operations (such as sorting) can be sped up quite a
bit by allowing xfile users to grab a page to bulk-read the records
contained within it.  Create helper methods to facilitate this.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Kent Overstreet <kent.overstreet@linux.dev>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

diff --git a/fs/xfs/scrub/trace.h b/fs/xfs/scrub/trace.h
index e95c167..c2e611e 100644 (file)
--- a/fs/xfs/scrub/trace.h
+++ b/fs/xfs/scrub/trace.h
@@ -821,6 +821,8 @@ DEFINE_EVENT(xfile_class, name, \
 DEFINE_XFILE_EVENT(xfile_pread);
 DEFINE_XFILE_EVENT(xfile_pwrite);
 DEFINE_XFILE_EVENT(xfile_seek_data);
+DEFINE_XFILE_EVENT(xfile_get_page);
+DEFINE_XFILE_EVENT(xfile_put_page);
 
 TRACE_EVENT(xfarray_create,
        TP_PROTO(struct xfarray *xfa, unsigned long long required_capacity),

diff --git a/fs/xfs/scrub/xfile.c b/fs/xfs/scrub/xfile.c
index 19d5128..d98e8e7 100644 (file)
--- a/fs/xfs/scrub/xfile.c
+++ b/fs/xfs/scrub/xfile.c
@@ -310,3 +310,111 @@ xfile_stat(
        statbuf->bytes = ks.blocks << SECTOR_SHIFT;
        return 0;
 }
+
+/*
+ * Grab the (locked) page for a memory object.  The object cannot span a page
+ * boundary.  Returns 0 (and a locked page) if successful, -ENOTBLK if we
+ * cannot grab the page, or the usual negative errno.
+ */
+int
+xfile_get_page(
+       struct xfile            *xf,
+       loff_t                  pos,
+       unsigned int            len,
+       struct xfile_page       *xfpage)
+{
+       struct inode            *inode = file_inode(xf->file);
+       struct address_space    *mapping = inode->i_mapping;
+       const struct address_space_operations *aops = mapping->a_ops;
+       struct page             *page = NULL;
+       void                    *fsdata = NULL;
+       loff_t                  key = round_down(pos, PAGE_SIZE);
+       unsigned int            pflags;
+       int                     error;
+
+       if (inode->i_sb->s_maxbytes - pos < len)
+               return -ENOMEM;
+       if (len > PAGE_SIZE - offset_in_page(pos))
+               return -ENOTBLK;
+
+       trace_xfile_get_page(xf, pos, len);
+
+       pflags = memalloc_nofs_save();
+
+       /*
+        * We call write_begin directly here to avoid all the freezer
+        * protection lock-taking that happens in the normal path.  shmem
+        * doesn't support fs freeze, but lockdep doesn't know that and will
+        * trip over that.
+        */
+       error = aops->write_begin(NULL, mapping, key, PAGE_SIZE, &page,
+                       &fsdata);
+       if (error)
+               goto out_pflags;
+
+       /* We got the page, so make sure we push out EOF. */
+       if (i_size_read(inode) < pos + len)
+               i_size_write(inode, pos + len);
+
+       /*
+        * If the page isn't up to date, fill it with zeroes before we hand it
+        * to the caller and make sure the backing store will hold on to them.
+        */
+       if (!PageUptodate(page)) {
+               void    *kaddr;
+
+               kaddr = kmap_local_page(page);
+               memset(kaddr, 0, PAGE_SIZE);
+               kunmap_local(kaddr);
+               SetPageUptodate(page);
+       }
+
+       /*
+        * Mark each page dirty so that the contents are written to some
+        * backing store when we drop this buffer, and take an extra reference
+        * to prevent the xfile page from being swapped or removed from the
+        * page cache by reclaim if the caller unlocks the page.
+        */
+       set_page_dirty(page);
+       get_page(page);
+
+       xfpage->page = page;
+       xfpage->fsdata = fsdata;
+       xfpage->pos = key;
+out_pflags:
+       memalloc_nofs_restore(pflags);
+       return error;
+}
+
+/*
+ * Release the (locked) page for a memory object.  Returns 0 or a negative
+ * errno.
+ */
+int
+xfile_put_page(
+       struct xfile            *xf,
+       struct xfile_page       *xfpage)
+{
+       struct inode            *inode = file_inode(xf->file);
+       struct address_space    *mapping = inode->i_mapping;
+       const struct address_space_operations *aops = mapping->a_ops;
+       unsigned int            pflags;
+       int                     ret;
+
+       trace_xfile_put_page(xf, xfpage->pos, PAGE_SIZE);
+
+       /* Give back the reference that we took in xfile_get_page. */
+       put_page(xfpage->page);
+
+       pflags = memalloc_nofs_save();
+       ret = aops->write_end(NULL, mapping, xfpage->pos, PAGE_SIZE, PAGE_SIZE,
+                       xfpage->page, xfpage->fsdata);
+       memalloc_nofs_restore(pflags);
+       memset(xfpage, 0, sizeof(struct xfile_page));
+
+       if (ret < 0)
+               return ret;
+       if (ret != PAGE_SIZE)
+               return -EIO;
+       return 0;
+}

diff --git a/fs/xfs/scrub/xfile.h b/fs/xfs/scrub/xfile.h
index 9328a37..7065abd 100644 (file)
--- a/fs/xfs/scrub/xfile.h
+++ b/fs/xfs/scrub/xfile.h
@@ -6,6 +6,12 @@
 #ifndef __XFS_SCRUB_XFILE_H__
 #define __XFS_SCRUB_XFILE_H__
 
+struct xfile_page {
+       struct page             *page;
+       void                    *fsdata;
+       loff_t                  pos;
+};
+
 struct xfile {
        struct file             *file;
 };
@@ -54,4 +60,8 @@ struct xfile_stat {
 
 int xfile_stat(struct xfile *xf, struct xfile_stat *statbuf);
 
+int xfile_get_page(struct xfile *xf, loff_t offset, unsigned int len,
+               struct xfile_page *xbuf);
+int xfile_put_page(struct xfile *xf, struct xfile_page *xbuf);
+
 #endif /* __XFS_SCRUB_XFILE_H__ */