nilfs2: add nilfs_end_folio_io()

Patch series "nilfs2: Folio conversions for file paths".

This series advances page->folio conversions for a wide range of nilfs2,
including its file operations, block routines, and the log writer's
writeback routines.  It doesn't cover large folios support, but it saves a
lot of hidden compound_head() calls while preserving the existing support
range behavior.

The original series in post [1] also covered directory-related page->folio
conversions, but that was put on hold because a regression was found in
testing, so this is an excerpt from the first half of the original post.

[1] https://lkml.kernel.org/r/20231106173903.1734114-1-willy@infradead.org

I tested this series in both 32-bit and 64-bit environments, switching
between normal and small block sizes.  I also reviewed all changes in all
patches to ensure they do not break existing behavior.  There were no
problems.

This patch (of 20):

This is the folio counterpart of the existing nilfs_end_page_io() which is
retained as a wrapper of nilfs_end_folio_io().  Replaces nine hidden calls
to compound_head() with one.

Link: https://lkml.kernel.org/r/20231114084436.2755-1-konishi.ryusuke@gmail.com
Link: https://lkml.kernel.org/r/20231114084436.2755-2-konishi.ryusuke@gmail.com
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Ryusuke Konishi <konishi.ryusuke@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 55e31cc903d1303b82274af69e5b0a3f686d7707..1df03d0895be42a9a5bfabb4acdd00e1babed643 100644 (file)
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -1739,17 +1739,18 @@ static int nilfs_segctor_write(struct nilfs_sc_info *sci,
        return ret;
 }
 
-static void nilfs_end_page_io(struct page *page, int err)
+static void nilfs_end_folio_io(struct folio *folio, int err)
 {
-       if (!page)
+       if (!folio)
                return;
 
-       if (buffer_nilfs_node(page_buffers(page)) && !PageWriteback(page)) {
+       if (buffer_nilfs_node(folio_buffers(folio)) &&
+                       !folio_test_writeback(folio)) {
                /*
                 * For b-tree node pages, this function may be called twice
                 * or more because they might be split in a segment.
                 */
-               if (PageDirty(page)) {
+               if (folio_test_dirty(folio)) {
                        /*
                         * For pages holding split b-tree node buffers, dirty
                         * flag on the buffers may be cleared discretely.
@@ -1757,24 +1758,31 @@ static void nilfs_end_page_io(struct page *page, int err)
                         * remaining buffers, and it must be cancelled if
                         * all the buffers get cleaned later.
                         */
-                       lock_page(page);
-                       if (nilfs_page_buffers_clean(page))
-                               __nilfs_clear_page_dirty(page);
-                       unlock_page(page);
+                       folio_lock(folio);
+                       if (nilfs_page_buffers_clean(&folio->page))
+                               __nilfs_clear_page_dirty(&folio->page);
+                       folio_unlock(folio);
                }
                return;
        }
 
        if (!err) {
-               if (!nilfs_page_buffers_clean(page))
-                       __set_page_dirty_nobuffers(page);
-               ClearPageError(page);
+               if (!nilfs_page_buffers_clean(&folio->page))
+                       filemap_dirty_folio(folio->mapping, folio);
+               folio_clear_error(folio);
        } else {
-               __set_page_dirty_nobuffers(page);
-               SetPageError(page);
+               filemap_dirty_folio(folio->mapping, folio);
+               folio_set_error(folio);
        }
 
-       end_page_writeback(page);
+       folio_end_writeback(folio);
+}
+
+static void nilfs_end_page_io(struct page *page, int err)
+{
+       if (!page)
+               return;
+       nilfs_end_folio_io(page_folio(page), err);
 }
 
 static void nilfs_abort_logs(struct list_head *logs, int err)