mm/filemap: Pass the file_ra_state in the ractl

For readahead_expand(), we need to modify the file ra_state, so pass it
down by adding it to the ractl.  We have to do this because it's not always
the same as f_ra in the struct file that is already being passed.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: David Howells <dhowells@redhat.com>
Tested-by: Jeff Layton <jlayton@kernel.org>
Tested-by: Dave Wysochanski <dwysocha@redhat.com>
Tested-By: Marc Dionne <marc.dionne@auristor.com>
Link: https://lore.kernel.org/r/20210407201857.3582797-2-willy@infradead.org/
Link: https://lore.kernel.org/r/161789067431.6155.8063840447229665720.stgit@warthog.procyon.org.uk/

diff --git a/fs/ext4/verity.c b/fs/ext4/verity.c
index 00e3cbde472e45135f95c12d6615e4356caf67c3..07438f46b5582d19eb7fd4f5a7699c1616e3ae44 100644 (file)
--- a/fs/ext4/verity.c
+++ b/fs/ext4/verity.c
@@ -370,7 +370,7 @@ static struct page *ext4_read_merkle_tree_page(struct inode *inode,
                                               pgoff_t index,
                                               unsigned long num_ra_pages)
 {
-       DEFINE_READAHEAD(ractl, NULL, inode->i_mapping, index);
+       DEFINE_READAHEAD(ractl, NULL, NULL, inode->i_mapping, index);
        struct page *page;
 
        index += ext4_verity_metadata_pos(inode) >> PAGE_SHIFT;

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index d26ff2ae3f5ebbbaada71b040666d5710b7872e8..c1e6f669a0c49a333359229ee2bddcfaadf0e58d 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -4051,7 +4051,7 @@ out:
 
 static int redirty_blocks(struct inode *inode, pgoff_t page_idx, int len)
 {
-       DEFINE_READAHEAD(ractl, NULL, inode->i_mapping, page_idx);
+       DEFINE_READAHEAD(ractl, NULL, NULL, inode->i_mapping, page_idx);
        struct address_space *mapping = inode->i_mapping;
        struct page *page;
        pgoff_t redirty_idx = page_idx;

diff --git a/fs/f2fs/verity.c b/fs/f2fs/verity.c
index 054ec852b5ea40ec4f3f1750c79e7480ac498e5a..a7beff28a3c598d3086f9be2e321417bc7d0c3c4 100644 (file)
--- a/fs/f2fs/verity.c
+++ b/fs/f2fs/verity.c
@@ -228,7 +228,7 @@ static struct page *f2fs_read_merkle_tree_page(struct inode *inode,
                                               pgoff_t index,
                                               unsigned long num_ra_pages)
 {
-       DEFINE_READAHEAD(ractl, NULL, inode->i_mapping, index);
+       DEFINE_READAHEAD(ractl, NULL, NULL, inode->i_mapping, index);
        struct page *page;
 
        index += f2fs_verity_metadata_pos(inode) >> PAGE_SHIFT;

diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index bb4433c98d0230aa237a8881cc2e2a766e792d57..4220ded38f4b708c69565d3b2ac464c2311c1ce1 100644 (file)
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -812,20 +812,23 @@ static inline int add_to_page_cache(struct page *page,
  * @file: The file, used primarily by network filesystems for authentication.
  *       May be NULL if invoked internally by the filesystem.
  * @mapping: Readahead this filesystem object.
+ * @ra: File readahead state.  May be NULL.
  */
 struct readahead_control {
        struct file *file;
        struct address_space *mapping;
+       struct file_ra_state *ra;
 /* private: use the readahead_* accessors instead */
        pgoff_t _index;
        unsigned int _nr_pages;
        unsigned int _batch_count;
 };
 
-#define DEFINE_READAHEAD(rac, f, m, i)                                 \
-       struct readahead_control rac = {                                \
+#define DEFINE_READAHEAD(ractl, f, r, m, i)                            \
+       struct readahead_control ractl = {                              \
                .file = f,                                              \
                .mapping = m,                                           \
+               .ra = r,                                                \
                ._index = i,                                            \
        }
 
@@ -833,10 +836,9 @@ struct readahead_control {
 
 void page_cache_ra_unbounded(struct readahead_control *,
                unsigned long nr_to_read, unsigned long lookahead_count);
-void page_cache_sync_ra(struct readahead_control *, struct file_ra_state *,
+void page_cache_sync_ra(struct readahead_control *, unsigned long req_count);
+void page_cache_async_ra(struct readahead_control *, struct page *,
                unsigned long req_count);
-void page_cache_async_ra(struct readahead_control *, struct file_ra_state *,
-               struct page *, unsigned long req_count);
 
 /**
  * page_cache_sync_readahead - generic file readahead
@@ -856,8 +858,8 @@ void page_cache_sync_readahead(struct address_space *mapping,
                struct file_ra_state *ra, struct file *file, pgoff_t index,
                unsigned long req_count)
 {
-       DEFINE_READAHEAD(ractl, file, mapping, index);
-       page_cache_sync_ra(&ractl, ra, req_count);
+       DEFINE_READAHEAD(ractl, file, ra, mapping, index);
+       page_cache_sync_ra(&ractl, req_count);
 }
 
 /**
@@ -879,8 +881,8 @@ void page_cache_async_readahead(struct address_space *mapping,
                struct file_ra_state *ra, struct file *file,
                struct page *page, pgoff_t index, unsigned long req_count)
 {
-       DEFINE_READAHEAD(ractl, file, mapping, index);
-       page_cache_async_ra(&ractl, ra, page, req_count);
+       DEFINE_READAHEAD(ractl, file, ra, mapping, index);
+       page_cache_async_ra(&ractl, page, req_count);
 }
 
 /**

diff --git a/mm/filemap.c b/mm/filemap.c
index afe22f09960ea47a25689106d24580afb831c1c2..46e0321ba87a6d717b007486249a6a0912ac83f2 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2832,7 +2832,7 @@ static struct file *do_sync_mmap_readahead(struct vm_fault *vmf)
        struct file *file = vmf->vma->vm_file;
        struct file_ra_state *ra = &file->f_ra;
        struct address_space *mapping = file->f_mapping;
-       DEFINE_READAHEAD(ractl, file, mapping, vmf->pgoff);
+       DEFINE_READAHEAD(ractl, file, ra, mapping, vmf->pgoff);
        struct file *fpin = NULL;
        unsigned int mmap_miss;
 
@@ -2844,7 +2844,7 @@ static struct file *do_sync_mmap_readahead(struct vm_fault *vmf)
 
        if (vmf->vma->vm_flags & VM_SEQ_READ) {
                fpin = maybe_unlock_mmap_for_io(vmf, fpin);
-               page_cache_sync_ra(&ractl, ra, ra->ra_pages);
+               page_cache_sync_ra(&ractl, ra->ra_pages);
                return fpin;
        }
 

diff --git a/mm/internal.h b/mm/internal.h
index 1432feec62df09038a04f7b4348041f5c169ae42..83a07b2a7b1f701677b1ea9dca56da8bbaaa96dd 100644 (file)
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -51,13 +51,12 @@ void unmap_page_range(struct mmu_gather *tlb,
 
 void do_page_cache_ra(struct readahead_control *, unsigned long nr_to_read,
                unsigned long lookahead_size);
-void force_page_cache_ra(struct readahead_control *, struct file_ra_state *,
-               unsigned long nr);
+void force_page_cache_ra(struct readahead_control *, unsigned long nr);
 static inline void force_page_cache_readahead(struct address_space *mapping,
                struct file *file, pgoff_t index, unsigned long nr_to_read)
 {
-       DEFINE_READAHEAD(ractl, file, mapping, index);
-       force_page_cache_ra(&ractl, &file->f_ra, nr_to_read);
+       DEFINE_READAHEAD(ractl, file, &file->f_ra, mapping, index);
+       force_page_cache_ra(&ractl, nr_to_read);
 }
 
 unsigned find_lock_entries(struct address_space *mapping, pgoff_t start,

diff --git a/mm/readahead.c b/mm/readahead.c
index c5b0457415bef29257619eefe99bcd53881fed53..2088569a947e59c023f73ba94c8abecdbc080bd9 100644 (file)
--- a/mm/readahead.c
+++ b/mm/readahead.c
@@ -272,9 +272,10 @@ void do_page_cache_ra(struct readahead_control *ractl,
  * memory at once.
  */
 void force_page_cache_ra(struct readahead_control *ractl,
-               struct file_ra_state *ra, unsigned long nr_to_read)
+               unsigned long nr_to_read)
 {
        struct address_space *mapping = ractl->mapping;
+       struct file_ra_state *ra = ractl->ra;
        struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
        unsigned long max_pages, index;
 
@@ -433,10 +434,10 @@ static int try_context_readahead(struct address_space *mapping,
  * A minimal readahead algorithm for trivial sequential/random reads.
  */
 static void ondemand_readahead(struct readahead_control *ractl,
-               struct file_ra_state *ra, bool hit_readahead_marker,
-               unsigned long req_size)
+               bool hit_readahead_marker, unsigned long req_size)
 {
        struct backing_dev_info *bdi = inode_to_bdi(ractl->mapping->host);
+       struct file_ra_state *ra = ractl->ra;
        unsigned long max_pages = ra->ra_pages;
        unsigned long add_pages;
        unsigned long index = readahead_index(ractl);
@@ -550,7 +551,7 @@ readit:
 }
 
 void page_cache_sync_ra(struct readahead_control *ractl,
-               struct file_ra_state *ra, unsigned long req_count)
+               unsigned long req_count)
 {
        bool do_forced_ra = ractl->file && (ractl->file->f_mode & FMODE_RANDOM);
 
@@ -560,7 +561,7 @@ void page_cache_sync_ra(struct readahead_control *ractl,
         * read-ahead will do the right thing and limit the read to just the
         * requested range, which we'll set to 1 page for this case.
         */
-       if (!ra->ra_pages || blk_cgroup_congested()) {
+       if (!ractl->ra->ra_pages || blk_cgroup_congested()) {
                if (!ractl->file)
                        return;
                req_count = 1;
@@ -569,21 +570,20 @@ void page_cache_sync_ra(struct readahead_control *ractl,
 
        /* be dumb */
        if (do_forced_ra) {
-               force_page_cache_ra(ractl, ra, req_count);
+               force_page_cache_ra(ractl, req_count);
                return;
        }
 
        /* do read-ahead */
-       ondemand_readahead(ractl, ra, false, req_count);
+       ondemand_readahead(ractl, false, req_count);
 }
 EXPORT_SYMBOL_GPL(page_cache_sync_ra);
 
 void page_cache_async_ra(struct readahead_control *ractl,
-               struct file_ra_state *ra, struct page *page,
-               unsigned long req_count)
+               struct page *page, unsigned long req_count)
 {
        /* no read-ahead */
-       if (!ra->ra_pages)
+       if (!ractl->ra->ra_pages)
                return;
 
        /*
@@ -604,7 +604,7 @@ void page_cache_async_ra(struct readahead_control *ractl,
                return;
 
        /* do read-ahead */
-       ondemand_readahead(ractl, ra, true, req_count);
+       ondemand_readahead(ractl, true, req_count);
 }
 EXPORT_SYMBOL_GPL(page_cache_async_ra);