mm/readahead: make page_cache_ra_unbounded take a readahead_control

Define it in the callers instead of in page_cache_ra_unbounded().

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Eric Biggers <ebiggers@google.com>
Link: https://lkml.kernel.org/r/20200903140844.14194-4-willy@infradead.org
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/fs/ext4/verity.c b/fs/ext4/verity.c
index bbd5e7e0632b4ab34883f3362148cee631cbdc37..5b7ba8f7115389cb8928279ac9943b06bf7b3658 100644 (file)
--- a/fs/ext4/verity.c
+++ b/fs/ext4/verity.c
@@ -349,6 +349,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);
        struct page *page;
 
        index += ext4_verity_metadata_pos(inode) >> PAGE_SHIFT;
@@ -358,8 +359,7 @@ static struct page *ext4_read_merkle_tree_page(struct inode *inode,
                if (page)
                        put_page(page);
                else if (num_ra_pages > 1)
-                       page_cache_readahead_unbounded(inode->i_mapping, NULL,
-                                       index, num_ra_pages, 0);
+                       page_cache_ra_unbounded(&ractl, num_ra_pages, 0);
                page = read_mapping_page(inode->i_mapping, index, NULL);
        }
        return page;

diff --git a/fs/f2fs/verity.c b/fs/f2fs/verity.c
index 9eb0dba851e8858ae6138ab7ce16cd898b416c3e..054ec852b5ea40ec4f3f1750c79e7480ac498e5a 100644 (file)
--- a/fs/f2fs/verity.c
+++ b/fs/f2fs/verity.c
@@ -228,6 +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);
        struct page *page;
 
        index += f2fs_verity_metadata_pos(inode) >> PAGE_SHIFT;
@@ -237,8 +238,7 @@ static struct page *f2fs_read_merkle_tree_page(struct inode *inode,
                if (page)
                        put_page(page);
                else if (num_ra_pages > 1)
-                       page_cache_readahead_unbounded(inode->i_mapping, NULL,
-                                       index, num_ra_pages, 0);
+                       page_cache_ra_unbounded(&ractl, num_ra_pages, 0);
                page = read_mapping_page(inode->i_mapping, index, NULL);
        }
        return page;

diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 63c81b512e8056f8c2d2799b13a639817ce33405..37f209ccef0f9f805cfcdaccff5346a03b652c27 100644 (file)
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -768,9 +768,8 @@ void page_cache_sync_readahead(struct address_space *, struct file_ra_state *,
 void page_cache_async_readahead(struct address_space *, struct file_ra_state *,
                struct file *, struct page *, pgoff_t index,
                unsigned long req_count);
-void page_cache_readahead_unbounded(struct address_space *, struct file *,
-               pgoff_t index, unsigned long nr_to_read,
-               unsigned long lookahead_count);
+void page_cache_ra_unbounded(struct readahead_control *,
+               unsigned long nr_to_read, unsigned long lookahead_count);
 
 /*
  * Like add_to_page_cache_locked, but used to add newly allocated pages:

diff --git a/mm/readahead.c b/mm/readahead.c
index 2126a2754e22c7069f87af274169bb8415c57994..a444943781bbf633aeb917b157d891bc552ff271 100644 (file)
--- a/mm/readahead.c
+++ b/mm/readahead.c
@@ -158,10 +158,8 @@ out:
 }
 
 /**
- * page_cache_readahead_unbounded - Start unchecked readahead.
- * @mapping: File address space.
- * @file: This instance of the open file; used for authentication.
- * @index: First page index to read.
+ * page_cache_ra_unbounded - Start unchecked readahead.
+ * @ractl: Readahead control.
  * @nr_to_read: The number of pages to read.
  * @lookahead_size: Where to start the next readahead.
  *
@@ -173,13 +171,13 @@ out:
  * Context: File is referenced by caller.  Mutexes may be held by caller.
  * May sleep, but will not reenter filesystem to reclaim memory.
  */
-void page_cache_readahead_unbounded(struct address_space *mapping,
-               struct file *file, pgoff_t index, unsigned long nr_to_read,
-               unsigned long lookahead_size)
+void page_cache_ra_unbounded(struct readahead_control *ractl,
+               unsigned long nr_to_read, unsigned long lookahead_size)
 {
+       struct address_space *mapping = ractl->mapping;
+       unsigned long index = readahead_index(ractl);
        LIST_HEAD(page_pool);
        gfp_t gfp_mask = readahead_gfp_mask(mapping);
-       DEFINE_READAHEAD(rac, file, mapping, index);
        unsigned long i;
 
        /*
@@ -200,7 +198,7 @@ void page_cache_readahead_unbounded(struct address_space *mapping,
        for (i = 0; i < nr_to_read; i++) {
                struct page *page = xa_load(&mapping->i_pages, index + i);
 
-               BUG_ON(index + i != rac._index + rac._nr_pages);
+               BUG_ON(index + i != ractl->_index + ractl->_nr_pages);
 
                if (page && !xa_is_value(page)) {
                        /*
@@ -211,7 +209,7 @@ void page_cache_readahead_unbounded(struct address_space *mapping,
                         * have a stable reference to this page, and it's
                         * not worth getting one just for that.
                         */
-                       read_pages(&rac, &page_pool, true);
+                       read_pages(ractl, &page_pool, true);
                        continue;
                }
 
@@ -224,12 +222,12 @@ void page_cache_readahead_unbounded(struct address_space *mapping,
                } else if (add_to_page_cache_lru(page, mapping, index + i,
                                        gfp_mask) < 0) {
                        put_page(page);
-                       read_pages(&rac, &page_pool, true);
+                       read_pages(ractl, &page_pool, true);
                        continue;
                }
                if (i == nr_to_read - lookahead_size)
                        SetPageReadahead(page);
-               rac._nr_pages++;
+               ractl->_nr_pages++;
        }
 
        /*
@@ -237,10 +235,10 @@ void page_cache_readahead_unbounded(struct address_space *mapping,
         * uptodate then the caller will launch readpage again, and
         * will then handle the error.
         */
-       read_pages(&rac, &page_pool, false);
+       read_pages(ractl, &page_pool, false);
        memalloc_nofs_restore(nofs);
 }
-EXPORT_SYMBOL_GPL(page_cache_readahead_unbounded);
+EXPORT_SYMBOL_GPL(page_cache_ra_unbounded);
 
 /*
  * __do_page_cache_readahead() actually reads a chunk of disk.  It allocates
@@ -252,6 +250,7 @@ void __do_page_cache_readahead(struct address_space *mapping,
                struct file *file, pgoff_t index, unsigned long nr_to_read,
                unsigned long lookahead_size)
 {
+       DEFINE_READAHEAD(ractl, file, mapping, index);
        struct inode *inode = mapping->host;
        loff_t isize = i_size_read(inode);
        pgoff_t end_index;      /* The last page we want to read */
@@ -266,8 +265,7 @@ void __do_page_cache_readahead(struct address_space *mapping,
        if (nr_to_read > end_index - index)
                nr_to_read = end_index - index + 1;
 
-       page_cache_readahead_unbounded(mapping, file, index, nr_to_read,
-                       lookahead_size);
+       page_cache_ra_unbounded(&ractl, nr_to_read, lookahead_size);
 }
 
 /*