btrfs: zoned: serialize metadata IO

We cannot use zone append for writing metadata, because the B-tree nodes
have references to each other using logical address. Without knowing
the address in advance, we cannot construct the tree in the first place.
So we need to serialize write IOs for metadata.

We cannot add a mutex around allocation and submission because metadata
blocks are allocated in an earlier stage to build up B-trees.

Add a zoned_meta_io_lock and hold it during metadata IO submission in
btree_write_cache_pages() to serialize IOs.

Furthermore, this adds a per-block group metadata IO submission pointer
"meta_write_pointer" to ensure sequential writing, which can break when
attempting to write back blocks in an unfinished transaction. If the
writing out failed because of a hole and the write out is for data
integrity (WB_SYNC_ALL), it returns EAGAIN.

A caller like fsync() code should handle this properly e.g. by falling
back to a full transaction commit.

Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Naohiro Aota <naohiro.aota@wdc.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/block-group.h b/fs/btrfs/block-group.h
index 31c7c5872b925df01b50bfae4a32b26974dbc2c7..a07108d65c44112c4187f3c0e321fab514e56137 100644 (file)
--- a/fs/btrfs/block-group.h
+++ b/fs/btrfs/block-group.h
@@ -193,6 +193,7 @@ struct btrfs_block_group {
         */
        u64 alloc_offset;
        u64 zone_unusable;
+       u64 meta_write_pointer;
 };
 
 static inline u64 btrfs_block_group_end(struct btrfs_block_group *block_group)

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 10da47ab093a2456213c24788f3176ca71fe2a0c..1bb4f767966ae11611f265a950480fd66cd27643 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -975,6 +975,7 @@ struct btrfs_fs_info {
 
        /* Max size to emit ZONE_APPEND write command */
        u64 max_zone_append_size;
+       struct mutex zoned_meta_io_lock;
 
 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
        spinlock_t ref_verify_lock;

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 70621184a731b64cef79b3dc5b40409696d7a68b..458bb27e032730fca54ea623a604b4f4f994146b 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -2769,6 +2769,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)
        mutex_init(&fs_info->delete_unused_bgs_mutex);
        mutex_init(&fs_info->reloc_mutex);
        mutex_init(&fs_info->delalloc_root_mutex);
+       mutex_init(&fs_info->zoned_meta_io_lock);
        seqlock_init(&fs_info->profiles_lock);
 
        INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 14a68f3589cc84cff13b3316aea3c62cbd059725..dfa6c6106b945715fac9b83e1886cc34835856b1 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -26,6 +26,7 @@
 #include "disk-io.h"
 #include "subpage.h"
 #include "zoned.h"
+#include "block-group.h"
 
 static struct kmem_cache *extent_state_cache;
 static struct kmem_cache *extent_buffer_cache;
@@ -4161,6 +4162,7 @@ static int submit_eb_page(struct page *page, struct writeback_control *wbc,
                          struct extent_buffer **eb_context)
 {
        struct address_space *mapping = page->mapping;
+       struct btrfs_block_group *cache = NULL;
        struct extent_buffer *eb;
        int ret;
 
@@ -4193,13 +4195,31 @@ static int submit_eb_page(struct page *page, struct writeback_control *wbc,
        if (!ret)
                return 0;
 
+       if (!btrfs_check_meta_write_pointer(eb->fs_info, eb, &cache)) {
+               /*
+                * If for_sync, this hole will be filled with
+                * trasnsaction commit.
+                */
+               if (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync)
+                       ret = -EAGAIN;
+               else
+                       ret = 0;
+               free_extent_buffer(eb);
+               return ret;
+       }
+
        *eb_context = eb;
 
        ret = lock_extent_buffer_for_io(eb, epd);
        if (ret <= 0) {
+               btrfs_revert_meta_write_pointer(cache, eb);
+               if (cache)
+                       btrfs_put_block_group(cache);
                free_extent_buffer(eb);
                return ret;
        }
+       if (cache)
+               btrfs_put_block_group(cache);
        ret = write_one_eb(eb, wbc, epd);
        free_extent_buffer(eb);
        if (ret < 0)
@@ -4245,6 +4265,7 @@ int btree_write_cache_pages(struct address_space *mapping,
                tag = PAGECACHE_TAG_TOWRITE;
        else
                tag = PAGECACHE_TAG_DIRTY;
+       btrfs_zoned_meta_io_lock(fs_info);
 retry:
        if (wbc->sync_mode == WB_SYNC_ALL)
                tag_pages_for_writeback(mapping, index, end);
@@ -4285,7 +4306,7 @@ retry:
        }
        if (ret < 0) {
                end_write_bio(&epd, ret);
-               return ret;
+               goto out;
        }
        /*
         * If something went wrong, don't allow any metadata write bio to be
@@ -4320,6 +4341,8 @@ retry:
                ret = -EROFS;
                end_write_bio(&epd, ret);
        }
+out:
+       btrfs_zoned_meta_io_unlock(fs_info);
        return ret;
 }
 

diff --git a/fs/btrfs/zoned.c b/fs/btrfs/zoned.c
index f4e226bda9b06a235b952ef9b8c89634b10cd6b3..b2a6553b2db00f672fe87b57390bcba5ba838005 100644 (file)
--- a/fs/btrfs/zoned.c
+++ b/fs/btrfs/zoned.c
@@ -1159,6 +1159,9 @@ out:
                ret = -EIO;
        }
 
+       if (!ret)
+               cache->meta_write_pointer = cache->alloc_offset + cache->start;
+
        kfree(alloc_offsets);
        free_extent_map(em);
 
@@ -1317,3 +1320,50 @@ out:
        kfree(logical);
        bdput(bdev);
 }
+
+bool btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,
+                                   struct extent_buffer *eb,
+                                   struct btrfs_block_group **cache_ret)
+{
+       struct btrfs_block_group *cache;
+       bool ret = true;
+
+       if (!btrfs_is_zoned(fs_info))
+               return true;
+
+       cache = *cache_ret;
+
+       if (cache && (eb->start < cache->start ||
+                     cache->start + cache->length <= eb->start)) {
+               btrfs_put_block_group(cache);
+               cache = NULL;
+               *cache_ret = NULL;
+       }
+
+       if (!cache)
+               cache = btrfs_lookup_block_group(fs_info, eb->start);
+
+       if (cache) {
+               if (cache->meta_write_pointer != eb->start) {
+                       btrfs_put_block_group(cache);
+                       cache = NULL;
+                       ret = false;
+               } else {
+                       cache->meta_write_pointer = eb->start + eb->len;
+               }
+
+               *cache_ret = cache;
+       }
+
+       return ret;
+}
+
+void btrfs_revert_meta_write_pointer(struct btrfs_block_group *cache,
+                                    struct extent_buffer *eb)
+{
+       if (!btrfs_is_zoned(eb->fs_info) || !cache)
+               return;
+
+       ASSERT(cache->meta_write_pointer == eb->start + eb->len);
+       cache->meta_write_pointer = eb->start;
+}

diff --git a/fs/btrfs/zoned.h b/fs/btrfs/zoned.h
index 04f7b21652b6c2f9d2db54a47a6d8dd8c81ee95e..0755a25d0f4c7604dd1d077461069a6f915690ac 100644 (file)
--- a/fs/btrfs/zoned.h
+++ b/fs/btrfs/zoned.h
@@ -50,6 +50,11 @@ bool btrfs_use_zone_append(struct btrfs_inode *inode, struct extent_map *em);
 void btrfs_record_physical_zoned(struct inode *inode, u64 file_offset,
                                 struct bio *bio);
 void btrfs_rewrite_logical_zoned(struct btrfs_ordered_extent *ordered);
+bool btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,
+                                   struct extent_buffer *eb,
+                                   struct btrfs_block_group **cache_ret);
+void btrfs_revert_meta_write_pointer(struct btrfs_block_group *cache,
+                                    struct extent_buffer *eb);
 #else /* CONFIG_BLK_DEV_ZONED */
 static inline int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos,
                                     struct blk_zone *zone)
@@ -151,6 +156,19 @@ static inline void btrfs_record_physical_zoned(struct inode *inode,
 static inline void btrfs_rewrite_logical_zoned(
                                struct btrfs_ordered_extent *ordered) { }
 
+static inline bool btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,
+                              struct extent_buffer *eb,
+                              struct btrfs_block_group **cache_ret)
+{
+       return true;
+}
+
+static inline void btrfs_revert_meta_write_pointer(
+                                               struct btrfs_block_group *cache,
+                                               struct extent_buffer *eb)
+{
+}
+
 #endif
 
 static inline bool btrfs_dev_is_sequential(struct btrfs_device *device, u64 pos)
@@ -242,4 +260,18 @@ static inline bool btrfs_can_zone_reset(struct btrfs_device *device,
        return true;
 }
 
+static inline void btrfs_zoned_meta_io_lock(struct btrfs_fs_info *fs_info)
+{
+       if (!btrfs_is_zoned(fs_info))
+               return;
+       mutex_lock(&fs_info->zoned_meta_io_lock);
+}
+
+static inline void btrfs_zoned_meta_io_unlock(struct btrfs_fs_info *fs_info)
+{
+       if (!btrfs_is_zoned(fs_info))
+               return;
+       mutex_unlock(&fs_info->zoned_meta_io_lock);
+}
+
 #endif