squashfs; convert squashfs_copy_cache() to take a folio

Remove accesses to page->index and page->mapping.  Also use folio
APIs where available.  This code still assumes order 0 folios.

[dan.carpenter@linaro.org: fix a NULL vs IS_ERR() bug]
Link: https://lkml.kernel.org/r/7b7f44d6-9153-4d7c-b65b-2d78febe6c7a@stanley.mountain
Link: https://lkml.kernel.org/r/20241220224634.723899-4-willy@infradead.org
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Dan Carpenter <dan.carpenter@linaro.org>
Cc: Phillip Lougher <phillip@squashfs.org.uk>
Cc: Dan Carpenter <dan.carpenter@linaro.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/squashfs/file.c b/fs/squashfs/file.c
index 5b81e26b122623d2a4e8b8e11c836e23a6fedfca..74076c4823c36ceac3d6a9b268349513b19c848b 100644 (file)
--- a/fs/squashfs/file.c
+++ b/fs/squashfs/file.c
@@ -378,13 +378,15 @@ void squashfs_fill_page(struct page *page, struct squashfs_cache_entry *buffer,
 }
 
 /* Copy data into page cache  */
-void squashfs_copy_cache(struct page *page, struct squashfs_cache_entry *buffer,
-       int bytes, int offset)
+void squashfs_copy_cache(struct folio *folio,
+               struct squashfs_cache_entry *buffer, size_t bytes,
+               size_t offset)
 {
-       struct inode *inode = page->mapping->host;
+       struct address_space *mapping = folio->mapping;
+       struct inode *inode = mapping->host;
        struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
        int i, mask = (1 << (msblk->block_log - PAGE_SHIFT)) - 1;
-       int start_index = page->index & ~mask, end_index = start_index | mask;
+       int start_index = folio->index & ~mask, end_index = start_index | mask;
 
        /*
         * Loop copying datablock into pages.  As the datablock likely covers
@@ -394,25 +396,27 @@ void squashfs_copy_cache(struct page *page, struct squashfs_cache_entry *buffer,
         */
        for (i = start_index; i <= end_index && bytes > 0; i++,
                        bytes -= PAGE_SIZE, offset += PAGE_SIZE) {
-               struct page *push_page;
-               int avail = buffer ? min_t(int, bytes, PAGE_SIZE) : 0;
+               struct folio *push_folio;
+               size_t avail = buffer ? min(bytes, PAGE_SIZE) : 0;
 
-               TRACE("bytes %d, i %d, available_bytes %d\n", bytes, i, avail);
+               TRACE("bytes %zu, i %d, available_bytes %zu\n", bytes, i, avail);
 
-               push_page = (i == page->index) ? page :
-                       grab_cache_page_nowait(page->mapping, i);
+               push_folio = (i == folio->index) ? folio :
+                       __filemap_get_folio(mapping, i,
+                                       FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
+                                       mapping_gfp_mask(mapping));
 
-               if (!push_page)
+               if (IS_ERR(push_folio))
                        continue;
 
-               if (PageUptodate(push_page))
-                       goto skip_page;
+               if (folio_test_uptodate(push_folio))
+                       goto skip_folio;
 
-               squashfs_fill_page(push_page, buffer, offset, avail);
-skip_page:
-               unlock_page(push_page);
-               if (i != page->index)
-                       put_page(push_page);
+               squashfs_fill_page(&push_folio->page, buffer, offset, avail);
+skip_folio:
+               folio_unlock(push_folio);
+               if (i != folio->index)
+                       folio_put(push_folio);
        }
 }
 
@@ -430,16 +434,16 @@ static int squashfs_readpage_fragment(struct folio *folio, int expected)
                        squashfs_i(inode)->fragment_block,
                        squashfs_i(inode)->fragment_size);
        else
-               squashfs_copy_cache(&folio->page, buffer, expected,
+               squashfs_copy_cache(folio, buffer, expected,
                        squashfs_i(inode)->fragment_offset);
 
        squashfs_cache_put(buffer);
        return res;
 }
 
-static int squashfs_readpage_sparse(struct page *page, int expected)
+static int squashfs_readpage_sparse(struct folio *folio, int expected)
 {
-       squashfs_copy_cache(page, NULL, expected, 0);
+       squashfs_copy_cache(folio, NULL, expected, 0);
        return 0;
 }
 
@@ -470,7 +474,7 @@ static int squashfs_read_folio(struct file *file, struct folio *folio)
                        goto out;
 
                if (res == 0)
-                       res = squashfs_readpage_sparse(&folio->page, expected);
+                       res = squashfs_readpage_sparse(folio, expected);
                else
                        res = squashfs_readpage_block(folio, block, res, expected);
        } else

diff --git a/fs/squashfs/file_cache.c b/fs/squashfs/file_cache.c
index 0360d22a77d4ac2e1be03c2cfeb5bbfb99d48368..40e59a43d098f448c3129ddfcd101fd556acb4b4 100644 (file)
--- a/fs/squashfs/file_cache.c
+++ b/fs/squashfs/file_cache.c
@@ -29,7 +29,7 @@ int squashfs_readpage_block(struct folio *folio, u64 block, int bsize, int expec
                ERROR("Unable to read page, block %llx, size %x\n", block,
                        bsize);
        else
-               squashfs_copy_cache(&folio->page, buffer, expected, 0);
+               squashfs_copy_cache(folio, buffer, expected, 0);
 
        squashfs_cache_put(buffer);
        return res;

diff --git a/fs/squashfs/squashfs.h b/fs/squashfs/squashfs.h
index 9922a9460ce66c0a0220e7f583006851e7409b77..8c6fbef022f4945f4c598205ada24bb38722e88d 100644 (file)
--- a/fs/squashfs/squashfs.h
+++ b/fs/squashfs/squashfs.h
@@ -74,8 +74,8 @@ extern __le64 *squashfs_read_fragment_index_table(struct super_block *,
 
 /* file.c */
 void squashfs_fill_page(struct page *, struct squashfs_cache_entry *, int, int);
-void squashfs_copy_cache(struct page *, struct squashfs_cache_entry *, int,
-                               int);
+void squashfs_copy_cache(struct folio *, struct squashfs_cache_entry *,
+               size_t bytes, size_t offset);
 
 /* file_xxx.c */
 int squashfs_readpage_block(struct folio *, u64 block, int bsize, int expected);