affs: convert data read and write to use folios

We still need to convert to/from folios in write_begin & write_end to fit
the API, but this removes a lot of calls to old page-based functions,
removing many hidden calls to compound_head().

Link: https://lkml.kernel.org/r/20230713035512.4139457-4-willy@infradead.org
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Pankaj Raghav <p.raghav@samsung.com>
Acked-by: David Sterba <dsterba@suse.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Christian Brauner <brauner@kernel.org>
Cc: Jan Kara <jack@suse.com>
Cc: Konstantin Komarov <almaz.alexandrovich@paragon-software.com>
Cc: Nathan Chancellor <nathan@kernel.org>
Cc: Nick Desaulniers <ndesaulniers@google.com>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Tom Rix <trix@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/affs/file.c b/fs/affs/file.c
index e43f2f007ac1a5440b6f6b67471de12d0640d892..705e227ff63d06618b7a81840638261a8e186b99 100644 (file)
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -520,21 +520,20 @@ affs_getemptyblk_ino(struct inode *inode, int block)
        return ERR_PTR(err);
 }
 
-static int
-affs_do_readpage_ofs(struct page *page, unsigned to, int create)
+static int affs_do_read_folio_ofs(struct folio *folio, size_t to, int create)
 {
-       struct inode *inode = page->mapping->host;
+       struct inode *inode = folio->mapping->host;
        struct super_block *sb = inode->i_sb;
        struct buffer_head *bh;
-       unsigned pos = 0;
-       u32 bidx, boff, bsize;
+       size_t pos = 0;
+       size_t bidx, boff, bsize;
        u32 tmp;
 
-       pr_debug("%s(%lu, %ld, 0, %d)\n", __func__, inode->i_ino,
-                page->index, to);
-       BUG_ON(to > PAGE_SIZE);
+       pr_debug("%s(%lu, %ld, 0, %zu)\n", __func__, inode->i_ino,
+                folio->index, to);
+       BUG_ON(to > folio_size(folio));
        bsize = AFFS_SB(sb)->s_data_blksize;
-       tmp = page->index << PAGE_SHIFT;
+       tmp = folio_pos(folio);
        bidx = tmp / bsize;
        boff = tmp % bsize;
 
@@ -544,7 +543,7 @@ affs_do_readpage_ofs(struct page *page, unsigned to, int create)
                        return PTR_ERR(bh);
                tmp = min(bsize - boff, to - pos);
                BUG_ON(pos + tmp > to || tmp > bsize);
-               memcpy_to_page(page, pos, AFFS_DATA(bh) + boff, tmp);
+               memcpy_to_folio(folio, pos, AFFS_DATA(bh) + boff, tmp);
                affs_brelse(bh);
                bidx++;
                pos += tmp;
@@ -624,25 +623,23 @@ out:
        return PTR_ERR(bh);
 }
 
-static int
-affs_read_folio_ofs(struct file *file, struct folio *folio)
+static int affs_read_folio_ofs(struct file *file, struct folio *folio)
 {
-       struct page *page = &folio->page;
-       struct inode *inode = page->mapping->host;
-       u32 to;
+       struct inode *inode = folio->mapping->host;
+       size_t to;
        int err;
 
-       pr_debug("%s(%lu, %ld)\n", __func__, inode->i_ino, page->index);
-       to = PAGE_SIZE;
-       if (((page->index + 1) << PAGE_SHIFT) > inode->i_size) {
-               to = inode->i_size & ~PAGE_MASK;
-               memset(page_address(page) + to, 0, PAGE_SIZE - to);
+       pr_debug("%s(%lu, %ld)\n", __func__, inode->i_ino, folio->index);
+       to = folio_size(folio);
+       if (folio_pos(folio) + to > inode->i_size) {
+               to = inode->i_size - folio_pos(folio);
+               folio_zero_segment(folio, to, folio_size(folio));
        }
 
-       err = affs_do_readpage_ofs(page, to, 0);
+       err = affs_do_read_folio_ofs(folio, to, 0);
        if (!err)
-               SetPageUptodate(page);
-       unlock_page(page);
+               folio_mark_uptodate(folio);
+       folio_unlock(folio);
        return err;
 }
 
@@ -651,7 +648,7 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping
                                struct page **pagep, void **fsdata)
 {
        struct inode *inode = mapping->host;
-       struct page *page;
+       struct folio *folio;
        pgoff_t index;
        int err = 0;
 
@@ -667,19 +664,20 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping
        }
 
        index = pos >> PAGE_SHIFT;
-       page = grab_cache_page_write_begin(mapping, index);
-       if (!page)
-               return -ENOMEM;
-       *pagep = page;
+       folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,
+                       mapping_gfp_mask(mapping));
+       if (IS_ERR(folio))
+               return PTR_ERR(folio);
+       *pagep = &folio->page;
 
-       if (PageUptodate(page))
+       if (folio_test_uptodate(folio))
                return 0;
 
        /* XXX: inefficient but safe in the face of short writes */
-       err = affs_do_readpage_ofs(page, PAGE_SIZE, 1);
+       err = affs_do_read_folio_ofs(folio, folio_size(folio), 1);
        if (err) {
-               unlock_page(page);
-               put_page(page);
+               folio_unlock(folio);
+               folio_put(folio);
        }
        return err;
 }
@@ -688,6 +686,7 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
                                loff_t pos, unsigned len, unsigned copied,
                                struct page *page, void *fsdata)
 {
+       struct folio *folio = page_folio(page);
        struct inode *inode = mapping->host;
        struct super_block *sb = inode->i_sb;
        struct buffer_head *bh, *prev_bh;
@@ -701,18 +700,18 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
        to = from + len;
        /*
         * XXX: not sure if this can handle short copies (len < copied), but
-        * we don't have to, because the page should always be uptodate here,
+        * we don't have to, because the folio should always be uptodate here,
         * due to write_begin.
         */
 
        pr_debug("%s(%lu, %llu, %llu)\n", __func__, inode->i_ino, pos,
                 pos + len);
        bsize = AFFS_SB(sb)->s_data_blksize;
-       data = page_address(page);
+       data = folio_address(folio);
 
        bh = NULL;
        written = 0;
-       tmp = (page->index << PAGE_SHIFT) + from;
+       tmp = (folio->index << PAGE_SHIFT) + from;
        bidx = tmp / bsize;
        boff = tmp % bsize;
        if (boff) {
@@ -804,11 +803,11 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
                from += tmp;
                bidx++;
        }
-       SetPageUptodate(page);
+       folio_mark_uptodate(folio);
 
 done:
        affs_brelse(bh);
-       tmp = (page->index << PAGE_SHIFT) + from;
+       tmp = (folio->index << PAGE_SHIFT) + from;
        if (tmp > inode->i_size)
                inode->i_size = AFFS_I(inode)->mmu_private = tmp;
 
@@ -819,8 +818,8 @@ done:
        }
 
 err_first_bh:
-       unlock_page(page);
-       put_page(page);
+       folio_unlock(folio);
+       folio_put(folio);
 
        return written;