btrfs: convert __process_pages_contig() to use filemap_get_folios_contig()

Convert to use folios throughout.  This is in preparation for the removal
of find_get_pages_contig().  Now also supports large folios.

Since we may receive more than nr_pages pages, nr_pages may underflow.
Since nr_pages > 0 is equivalent to index <= end_index, we replaced it
with this check instead.

Link: https://lkml.kernel.org/r/20220824004023.77310-3-vishal.moola@gmail.com
Signed-off-by: Vishal Moola (Oracle) <vishal.moola@gmail.com>
Acked-by: David Sterba <dsterba@suse.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Chris Mason <clm@fb.com>
Cc: David Sterba <dsterb@suse.com>
Cc: Josef Bacik <josef@toxicpanda.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Ryusuke Konishi <konishi.ryusuke@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index cf4f19e..013d634 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -1900,9 +1900,8 @@ static int __process_pages_contig(struct address_space *mapping,
        pgoff_t start_index = start >> PAGE_SHIFT;
        pgoff_t end_index = end >> PAGE_SHIFT;
        pgoff_t index = start_index;
-       unsigned long nr_pages = end_index - start_index + 1;
        unsigned long pages_processed = 0;
-       struct page *pages[16];
+       struct folio_batch fbatch;
        int err = 0;
        int i;
 
@@ -1911,16 +1910,17 @@ static int __process_pages_contig(struct address_space *mapping,
                ASSERT(processed_end && *processed_end == start);
        }
 
-       if ((page_ops & PAGE_SET_ERROR) && nr_pages > 0)
+       if ((page_ops & PAGE_SET_ERROR) && start_index <= end_index)
                mapping_set_error(mapping, -EIO);
 
-       while (nr_pages > 0) {
-               int found_pages;
+       folio_batch_init(&fbatch);
+       while (index <= end_index) {
+               int found_folios;
+
+               found_folios = filemap_get_folios_contig(mapping, &index,
+                               end_index, &fbatch);
 
-               found_pages = find_get_pages_contig(mapping, index,
-                                    min_t(unsigned long,
-                                    nr_pages, ARRAY_SIZE(pages)), pages);
-               if (found_pages == 0) {
+               if (found_folios == 0) {
                        /*
                         * Only if we're going to lock these pages, we can find
                         * nothing at @index.
@@ -1930,23 +1930,20 @@ static int __process_pages_contig(struct address_space *mapping,
                        goto out;
                }
 
-               for (i = 0; i < found_pages; i++) {
+               for (i = 0; i < found_folios; i++) {
                        int process_ret;
-
+                       struct folio *folio = fbatch.folios[i];
                        process_ret = process_one_page(fs_info, mapping,
-                                       pages[i], locked_page, page_ops,
+                                       &folio->page, locked_page, page_ops,
                                        start, end);
                        if (process_ret < 0) {
-                               for (; i < found_pages; i++)
-                                       put_page(pages[i]);
                                err = -EAGAIN;
+                               folio_batch_release(&fbatch);
                                goto out;
                        }
-                       put_page(pages[i]);
-                       pages_processed++;
+                       pages_processed += folio_nr_pages(folio);
                }
-               nr_pages -= found_pages;
-               index += found_pages;
+               folio_batch_release(&fbatch);
                cond_resched();
        }
 out: