Merge tag 'for-5.18-rc2-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave...

[linux-2.6-microblaze.git] / fs / btrfs / disk-io.c

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index cebd7a7..126f244 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1013,41 +1013,40 @@ static int btree_releasepage(struct page *page, gfp_t gfp_flags)
        return try_release_extent_buffer(page);
 }
 
-static void btree_invalidatepage(struct page *page, unsigned int offset,
-                                unsigned int length)
+static void btree_invalidate_folio(struct folio *folio, size_t offset,
+                                size_t length)
 {
        struct extent_io_tree *tree;
-       tree = &BTRFS_I(page->mapping->host)->io_tree;
-       extent_invalidatepage(tree, page, offset);
-       btree_releasepage(page, GFP_NOFS);
-       if (PagePrivate(page)) {
-               btrfs_warn(BTRFS_I(page->mapping->host)->root->fs_info,
-                          "page private not zero on page %llu",
-                          (unsigned long long)page_offset(page));
-               detach_page_private(page);
+       tree = &BTRFS_I(folio->mapping->host)->io_tree;
+       extent_invalidate_folio(tree, folio, offset);
+       btree_releasepage(&folio->page, GFP_NOFS);
+       if (folio_get_private(folio)) {
+               btrfs_warn(BTRFS_I(folio->mapping->host)->root->fs_info,
+                          "folio private not zero on folio %llu",
+                          (unsigned long long)folio_pos(folio));
+               folio_detach_private(folio);
        }
 }
 
-static int btree_set_page_dirty(struct page *page)
-{
 #ifdef DEBUG
-       struct btrfs_fs_info *fs_info = btrfs_sb(page->mapping->host->i_sb);
+static bool btree_dirty_folio(struct address_space *mapping,
+               struct folio *folio)
+{
+       struct btrfs_fs_info *fs_info = btrfs_sb(mapping->host->i_sb);
        struct btrfs_subpage *subpage;
        struct extent_buffer *eb;
        int cur_bit = 0;
-       u64 page_start = page_offset(page);
+       u64 page_start = folio_pos(folio);
 
        if (fs_info->sectorsize == PAGE_SIZE) {
-               BUG_ON(!PagePrivate(page));
-               eb = (struct extent_buffer *)page->private;
+               eb = folio_get_private(folio);
                BUG_ON(!eb);
                BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
                BUG_ON(!atomic_read(&eb->refs));
                btrfs_assert_tree_write_locked(eb);
-               return __set_page_dirty_nobuffers(page);
+               return filemap_dirty_folio(mapping, folio);
        }
-       ASSERT(PagePrivate(page) && page->private);
-       subpage = (struct btrfs_subpage *)page->private;
+       subpage = folio_get_private(folio);
 
        ASSERT(subpage->dirty_bitmap);
        while (cur_bit < BTRFS_SUBPAGE_BITMAP_SIZE) {
@@ -1073,18 +1072,20 @@ static int btree_set_page_dirty(struct page *page)
 
                cur_bit += (fs_info->nodesize >> fs_info->sectorsize_bits);
        }
-#endif
-       return __set_page_dirty_nobuffers(page);
+       return filemap_dirty_folio(mapping, folio);
 }
+#else
+#define btree_dirty_folio filemap_dirty_folio
+#endif
 
 static const struct address_space_operations btree_aops = {
        .writepages     = btree_writepages,
        .releasepage    = btree_releasepage,
-       .invalidatepage = btree_invalidatepage,
+       .invalidate_folio = btree_invalidate_folio,
 #ifdef CONFIG_MIGRATION
        .migratepage    = btree_migratepage,
 #endif
-       .set_page_dirty = btree_set_page_dirty,
+       .dirty_folio = btree_dirty_folio,
 };
 
 struct extent_buffer *btrfs_find_create_tree_block(
@@ -4127,8 +4128,9 @@ static int write_dev_supers(struct btrfs_device *device,
                 * to do I/O, so we don't lose the ability to do integrity
                 * checking.
                 */
-               bio = bio_alloc(GFP_NOFS, 1);
-               bio_set_dev(bio, device->bdev);
+               bio = bio_alloc(device->bdev, 1,
+                               REQ_OP_WRITE | REQ_SYNC | REQ_META | REQ_PRIO,
+                               GFP_NOFS);
                bio->bi_iter.bi_sector = bytenr >> SECTOR_SHIFT;
                bio->bi_private = device;
                bio->bi_end_io = btrfs_end_super_write;
@@ -4140,7 +4142,6 @@ static int write_dev_supers(struct btrfs_device *device,
                 * go down lazy and there's a short window where the on-disk
                 * copies might still contain the older version.
                 */
-               bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_META | REQ_PRIO;
                if (i == 0 && !btrfs_test_opt(device->fs_info, NOBARRIER))
                        bio->bi_opf |= REQ_FUA;
 
@@ -4252,10 +4253,8 @@ static void write_dev_flush(struct btrfs_device *device)
                return;
 #endif
 
-       bio_reset(bio);
+       bio_reset(bio, device->bdev, REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH);
        bio->bi_end_io = btrfs_end_empty_barrier;
-       bio_set_dev(bio, device->bdev);
-       bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH;
        init_completion(&device->flush_wait);
        bio->bi_private = &device->flush_wait;