ext4: Convert ext4_block_write_begin() to take a folio

All the callers now have a folio, so pass that in and operate on folios.
Removes four calls to compound_head().

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com>
Link: https://lore.kernel.org/r/20230324180129.1220691-25-willy@infradead.org
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 17a6607bcaf26e104876fbdf11421e178a88d1dd..b6e556c710632ce19c9fac439c16aa51577bb6a2 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1030,12 +1030,12 @@ int do_journal_get_write_access(handle_t *handle, struct inode *inode,
 }
 
 #ifdef CONFIG_FS_ENCRYPTION
-static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
+static int ext4_block_write_begin(struct folio *folio, loff_t pos, unsigned len,
                                  get_block_t *get_block)
 {
        unsigned from = pos & (PAGE_SIZE - 1);
        unsigned to = from + len;
-       struct inode *inode = page->mapping->host;
+       struct inode *inode = folio->mapping->host;
        unsigned block_start, block_end;
        sector_t block;
        int err = 0;
@@ -1045,22 +1045,24 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
        int nr_wait = 0;
        int i;
 
-       BUG_ON(!PageLocked(page));
+       BUG_ON(!folio_test_locked(folio));
        BUG_ON(from > PAGE_SIZE);
        BUG_ON(to > PAGE_SIZE);
        BUG_ON(from > to);
 
-       if (!page_has_buffers(page))
-               create_empty_buffers(page, blocksize, 0);
-       head = page_buffers(page);
+       head = folio_buffers(folio);
+       if (!head) {
+               create_empty_buffers(&folio->page, blocksize, 0);
+               head = folio_buffers(folio);
+       }
        bbits = ilog2(blocksize);
-       block = (sector_t)page->index << (PAGE_SHIFT - bbits);
+       block = (sector_t)folio->index << (PAGE_SHIFT - bbits);
 
        for (bh = head, block_start = 0; bh != head || !block_start;
            block++, block_start = block_end, bh = bh->b_this_page) {
                block_end = block_start + blocksize;
                if (block_end <= from || block_start >= to) {
-                       if (PageUptodate(page)) {
+                       if (folio_test_uptodate(folio)) {
                                set_buffer_uptodate(bh);
                        }
                        continue;
@@ -1073,19 +1075,20 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
                        if (err)
                                break;
                        if (buffer_new(bh)) {
-                               if (PageUptodate(page)) {
+                               if (folio_test_uptodate(folio)) {
                                        clear_buffer_new(bh);
                                        set_buffer_uptodate(bh);
                                        mark_buffer_dirty(bh);
                                        continue;
                                }
                                if (block_end > to || block_start < from)
-                                       zero_user_segments(page, to, block_end,
-                                                          block_start, from);
+                                       folio_zero_segments(folio, to,
+                                                           block_end,
+                                                           block_start, from);
                                continue;
                        }
                }
-               if (PageUptodate(page)) {
+               if (folio_test_uptodate(folio)) {
                        set_buffer_uptodate(bh);
                        continue;
                }
@@ -1105,14 +1108,13 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
                        err = -EIO;
        }
        if (unlikely(err)) {
-               page_zero_new_buffers(page, from, to);
+               page_zero_new_buffers(&folio->page, from, to);
        } else if (fscrypt_inode_uses_fs_layer_crypto(inode)) {
                for (i = 0; i < nr_wait; i++) {
                        int err2;
 
-                       err2 = fscrypt_decrypt_pagecache_blocks(page_folio(page),
-                                                               blocksize,
-                                                               bh_offset(wait[i]));
+                       err2 = fscrypt_decrypt_pagecache_blocks(folio,
+                                               blocksize, bh_offset(wait[i]));
                        if (err2) {
                                clear_buffer_uptodate(wait[i]);
                                err = err2;
@@ -1206,11 +1208,10 @@ retry_journal:
 
 #ifdef CONFIG_FS_ENCRYPTION
        if (ext4_should_dioread_nolock(inode))
-               ret = ext4_block_write_begin(&folio->page, pos, len,
+               ret = ext4_block_write_begin(folio, pos, len,
                                             ext4_get_block_unwritten);
        else
-               ret = ext4_block_write_begin(&folio->page, pos, len,
-                                            ext4_get_block);
+               ret = ext4_block_write_begin(folio, pos, len, ext4_get_block);
 #else
        if (ext4_should_dioread_nolock(inode))
                ret = __block_write_begin(&folio->page, pos, len,
@@ -2938,8 +2939,7 @@ retry:
        folio_wait_stable(folio);
 
 #ifdef CONFIG_FS_ENCRYPTION
-       ret = ext4_block_write_begin(&folio->page, pos, len,
-                                    ext4_da_get_block_prep);
+       ret = ext4_block_write_begin(folio, pos, len, ext4_da_get_block_prep);
 #else
        ret = __block_write_begin(&folio->page, pos, len, ext4_da_get_block_prep);
 #endif