buffer: Convert __block_write_begin() to take a folio

Almost all callers have a folio now, so change __block_write_begin()
to take a folio and remove a call to compound_head().

Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/buffer.c b/fs/buffer.c
index d52a740f7fcac01f9947e676e98e79a54c180684..45eb06cb1a4ee247f1cb8544dd1affd4d746d6b3 100644 (file)
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2168,11 +2168,10 @@ int __block_write_begin_int(struct folio *folio, loff_t pos, unsigned len,
        return err;
 }
 
-int __block_write_begin(struct page *page, loff_t pos, unsigned len,
+int __block_write_begin(struct folio *folio, loff_t pos, unsigned len,
                get_block_t *get_block)
 {
-       return __block_write_begin_int(page_folio(page), pos, len, get_block,
-                                      NULL);
+       return __block_write_begin_int(folio, pos, len, get_block, NULL);
 }
 EXPORT_SYMBOL(__block_write_begin);
 

diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 60605fbdd0eb41d40cbbf96ccba9776cde3c9f6c..2f3042d0174cf57a475c6a68515f121651b32bd9 100644 (file)
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -434,7 +434,7 @@ int ext2_inode_by_name(struct inode *dir, const struct qstr *child, ino_t *ino)
 
 static int ext2_prepare_chunk(struct folio *folio, loff_t pos, unsigned len)
 {
-       return __block_write_begin(&folio->page, pos, len, ext2_get_block);
+       return __block_write_begin(folio, pos, len, ext2_get_block);
 }
 
 static int ext2_handle_dirsync(struct inode *dir)

diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
index b7ea9cb4c39876cd938652388e1a9fbbe0715609..d5c2f3b75084824236c288145c91db68d93a91aa 100644 (file)
--- a/fs/ext4/inline.c
+++ b/fs/ext4/inline.c
@@ -601,10 +601,10 @@ retry:
                goto out;
 
        if (ext4_should_dioread_nolock(inode)) {
-               ret = __block_write_begin(&folio->page, from, to,
+               ret = __block_write_begin(folio, from, to,
                                          ext4_get_block_unwritten);
        } else
-               ret = __block_write_begin(&folio->page, from, to, ext4_get_block);
+               ret = __block_write_begin(folio, from, to, ext4_get_block);
 
        if (!ret && ext4_should_journal_data(inode)) {
                ret = ext4_walk_page_buffers(handle, inode,
@@ -856,7 +856,7 @@ static int ext4_da_convert_inline_data_to_extent(struct address_space *mapping,
                        goto out;
        }
 
-       ret = __block_write_begin(&folio->page, 0, inline_size,
+       ret = __block_write_begin(folio, 0, inline_size,
                                  ext4_da_get_block_prep);
        if (ret) {
                up_read(&EXT4_I(inode)->xattr_sem);

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 90ef8ec5c59bdee7feb98a4479c9216840951a42..03374dc215d1944a704da9cfb3ef8fe59df1b245 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1224,10 +1224,10 @@ retry_journal:
                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,
+               ret = __block_write_begin(folio, pos, len,
                                          ext4_get_block_unwritten);
        else
-               ret = __block_write_begin(&folio->page, pos, len, ext4_get_block);
+               ret = __block_write_begin(folio, pos, len, ext4_get_block);
 #endif
        if (!ret && ext4_should_journal_data(inode)) {
                ret = ext4_walk_page_buffers(handle, inode,
@@ -2962,7 +2962,7 @@ retry:
 #ifdef CONFIG_FS_ENCRYPTION
        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);
+       ret = __block_write_begin(folio, pos, len, ext4_da_get_block_prep);
 #endif
        if (ret < 0) {
                folio_unlock(folio);
@@ -6216,7 +6216,7 @@ retry_alloc:
                if (folio_pos(folio) + len > size)
                        len = size - folio_pos(folio);
 
-               err = __block_write_begin(&folio->page, 0, len, ext4_get_block);
+               err = __block_write_begin(folio, 0, len, ext4_get_block);
                if (!err) {
                        ret = VM_FAULT_SIGBUS;
                        if (ext4_journal_folio_buffers(handle, folio, len))

diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index abb190c46c04b8ab128f2b3a8a557899ae861590..f007e389d5d29b8f8416e5a31566f53eeaa4eec9 100644 (file)
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -429,7 +429,7 @@ static int minix_read_folio(struct file *file, struct folio *folio)
 
 int minix_prepare_chunk(struct folio *folio, loff_t pos, unsigned len)
 {
-       return __block_write_begin(&folio->page, pos, len, minix_get_block);
+       return __block_write_begin(folio, pos, len, minix_get_block);
 }
 
 static void minix_write_failed(struct address_space *mapping, loff_t to)

diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index 66af42f88ca7921714c602b5ab68918ce4354675..4b3e19d749256cf6b076918572366cd8b74bed42 100644 (file)
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -83,7 +83,7 @@ static int nilfs_prepare_chunk(struct folio *folio, unsigned int from,
 {
        loff_t pos = folio_pos(folio) + from;
 
-       return __block_write_begin(&folio->page, pos, to - from, nilfs_get_block);
+       return __block_write_begin(folio, pos, to - from, nilfs_get_block);
 }
 
 static void nilfs_commit_chunk(struct folio *folio,

diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index cfec1782ac2ae1b729382ee9b7b15d625d483a66..d058eb30cfc209dd031d46a1209f9beac4c0dfbe 100644 (file)
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -804,7 +804,7 @@ static int ocfs2_write_zero_page(struct inode *inode, u64 abs_from,
                 * __block_write_begin and block_commit_write to zero the
                 * whole block.
                 */
-               ret = __block_write_begin(&folio->page, block_start + 1, 0,
+               ret = __block_write_begin(folio, block_start + 1, 0,
                                          ocfs2_get_block);
                if (ret < 0) {
                        mlog_errno(ret);

diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index ea23872ba24fccf3e2db103c22ced367ee28f5cf..72c53129c952de64bb6daab1767e60144b2c9264 100644 (file)
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -2198,7 +2198,7 @@ static int grab_tail_page(struct inode *inode,
        /* start within the page of the last block in the file */
        start = (offset / blocksize) * blocksize;
 
-       error = __block_write_begin(&folio->page, start, offset - start,
+       error = __block_write_begin(folio, start, offset - start,
                                    reiserfs_get_block_create_0);
        if (error)
                goto unlock;
@@ -2762,7 +2762,7 @@ static int reiserfs_write_begin(struct file *file,
                old_ref = th->t_refcount;
                th->t_refcount++;
        }
-       ret = __block_write_begin(&folio->page, pos, len, reiserfs_get_block);
+       ret = __block_write_begin(folio, pos, len, reiserfs_get_block);
        if (ret && reiserfs_transaction_running(inode->i_sb)) {
                struct reiserfs_transaction_handle *th = current->journal_info;
                /*
@@ -2822,7 +2822,7 @@ int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len)
                th->t_refcount++;
        }
 
-       ret = __block_write_begin(page, from, len, reiserfs_get_block);
+       ret = __block_write_begin(page_folio(page), from, len, reiserfs_get_block);
        if (ret && reiserfs_transaction_running(inode->i_sb)) {
                struct reiserfs_transaction_handle *th = current->journal_info;
                /*

diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index 8864438817a6372488c550f09750b72c78bb4933..451e95f474faa59e6ed0edc233b3eb55ed78cfd7 100644 (file)
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -468,7 +468,7 @@ static int sysv_read_folio(struct file *file, struct folio *folio)
 
 int sysv_prepare_chunk(struct folio *folio, loff_t pos, unsigned len)
 {
-       return __block_write_begin(&folio->page, pos, len, get_block);
+       return __block_write_begin(folio, pos, len, get_block);
 }
 
 static void sysv_write_failed(struct address_space *mapping, loff_t to)

diff --git a/fs/udf/file.c b/fs/udf/file.c
index 3a4179de316b4b6dbf11b17e3f2347cc7335b9b8..412fe7c4d348b9ac4ba8adb85b0a6cd147c11152 100644 (file)
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -62,7 +62,7 @@ static vm_fault_t udf_page_mkwrite(struct vm_fault *vmf)
                end = size & ~PAGE_MASK;
        else
                end = PAGE_SIZE;
-       err = __block_write_begin(&folio->page, 0, end, udf_get_block);
+       err = __block_write_begin(folio, 0, end, udf_get_block);
        if (err) {
                folio_unlock(folio);
                ret = vmf_fs_error(err);

diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index f43461652d9f2c34186bd2501dc2b86b96d2d9af..5331ae7ebf3e2aef643b632192be223b73b647ec 100644 (file)
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -481,7 +481,7 @@ static int ufs_read_folio(struct file *file, struct folio *folio)
 
 int ufs_prepare_chunk(struct folio *folio, loff_t pos, unsigned len)
 {
-       return __block_write_begin(&folio->page, pos, len, ufs_getfrag_block);
+       return __block_write_begin(folio, pos, len, ufs_getfrag_block);
 }
 
 static void ufs_truncate_blocks(struct inode *);

diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 254563a2a9deee77ceb35cf3bd2a828e852068ea..c85e65fd4cdc99c4b4998342d3e704ad10ab236e 100644 (file)
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -259,7 +259,7 @@ int block_read_full_folio(struct folio *, get_block_t *);
 bool block_is_partially_uptodate(struct folio *, size_t from, size_t count);
 int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
                struct folio **foliop, get_block_t *get_block);
-int __block_write_begin(struct page *page, loff_t pos, unsigned len,
+int __block_write_begin(struct folio *folio, loff_t pos, unsigned len,
                get_block_t *get_block);
 int block_write_end(struct file *, struct address_space *,
                                loff_t, unsigned len, unsigned copied,