btrfs: zoned: implement copying for zoned device-replace

This is 3/4 patch to implement device-replace on zoned filesystems.

This commit implements copying. To do this, it tracks the write pointer
during the device replace process. As device-replace's copy process is
smart enough to only copy used extents on the source device, we have to
fill the gap to honor the sequential write requirement in the target
device.

The device-replace process on zoned filesystems must copy or clone all
the extents in the source device exactly once. So, we need to ensure
allocations started just before the dev-replace process to have their
corresponding extent information in the B-trees.
finish_extent_writes_for_zoned() implements that functionality, which
basically is the removed code in the commit 042528f8d840 ("Btrfs: fix
block group remaining RO forever after error during device replace").

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/scrub.c b/fs/btrfs/scrub.c
index da4f9c2..9290490 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -166,6 +166,7 @@ struct scrub_ctx {
        int                     pages_per_rd_bio;
 
        int                     is_dev_replace;
+       u64                     write_pointer;
 
        struct scrub_bio        *wr_curr_bio;
        struct mutex            wr_lock;
@@ -1619,6 +1620,25 @@ static int scrub_write_page_to_dev_replace(struct scrub_block *sblock,
        return scrub_add_page_to_wr_bio(sblock->sctx, spage);
 }
 
+static int fill_writer_pointer_gap(struct scrub_ctx *sctx, u64 physical)
+{
+       int ret = 0;
+       u64 length;
+
+       if (!btrfs_is_zoned(sctx->fs_info))
+               return 0;
+
+       if (sctx->write_pointer < physical) {
+               length = physical - sctx->write_pointer;
+
+               ret = btrfs_zoned_issue_zeroout(sctx->wr_tgtdev,
+                                               sctx->write_pointer, length);
+               if (!ret)
+                       sctx->write_pointer = physical;
+       }
+       return ret;
+}
+
 static int scrub_add_page_to_wr_bio(struct scrub_ctx *sctx,
                                    struct scrub_page *spage)
 {
@@ -1641,6 +1661,13 @@ again:
        if (sbio->page_count == 0) {
                struct bio *bio;
 
+               ret = fill_writer_pointer_gap(sctx,
+                                             spage->physical_for_dev_replace);
+               if (ret) {
+                       mutex_unlock(&sctx->wr_lock);
+                       return ret;
+               }
+
                sbio->physical = spage->physical_for_dev_replace;
                sbio->logical = spage->logical;
                sbio->dev = sctx->wr_tgtdev;
@@ -1702,6 +1729,9 @@ static void scrub_wr_submit(struct scrub_ctx *sctx)
         * doubled the write performance on spinning disks when measured
         * with Linux 3.5 */
        btrfsic_submit_bio(sbio->bio);
+
+       if (btrfs_is_zoned(sctx->fs_info))
+               sctx->write_pointer = sbio->physical + sbio->page_count * PAGE_SIZE;
 }
 
 static void scrub_wr_bio_end_io(struct bio *bio)
@@ -3025,6 +3055,20 @@ out:
        return ret < 0 ? ret : 0;
 }
 
+static void sync_replace_for_zoned(struct scrub_ctx *sctx)
+{
+       if (!btrfs_is_zoned(sctx->fs_info))
+               return;
+
+       sctx->flush_all_writes = true;
+       scrub_submit(sctx);
+       mutex_lock(&sctx->wr_lock);
+       scrub_wr_submit(sctx);
+       mutex_unlock(&sctx->wr_lock);
+
+       wait_event(sctx->list_wait, atomic_read(&sctx->bios_in_flight) == 0);
+}
+
 static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx,
                                           struct map_lookup *map,
                                           struct btrfs_device *scrub_dev,
@@ -3165,6 +3209,14 @@ static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx,
         */
        blk_start_plug(&plug);
 
+       if (sctx->is_dev_replace &&
+           btrfs_dev_is_sequential(sctx->wr_tgtdev, physical)) {
+               mutex_lock(&sctx->wr_lock);
+               sctx->write_pointer = physical;
+               mutex_unlock(&sctx->wr_lock);
+               sctx->flush_all_writes = true;
+       }
+
        /*
         * now find all extents for each stripe and scrub them
         */
@@ -3353,6 +3405,9 @@ again:
                        if (ret)
                                goto out;
 
+                       if (sctx->is_dev_replace)
+                               sync_replace_for_zoned(sctx);
+
                        if (extent_logical + extent_len <
                            key.objectid + bytes) {
                                if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
@@ -3475,6 +3530,25 @@ out:
        return ret;
 }
 
+static int finish_extent_writes_for_zoned(struct btrfs_root *root,
+                                         struct btrfs_block_group *cache)
+{
+       struct btrfs_fs_info *fs_info = cache->fs_info;
+       struct btrfs_trans_handle *trans;
+
+       if (!btrfs_is_zoned(fs_info))
+               return 0;
+
+       btrfs_wait_block_group_reservations(cache);
+       btrfs_wait_nocow_writers(cache);
+       btrfs_wait_ordered_roots(fs_info, U64_MAX, cache->start, cache->length);
+
+       trans = btrfs_join_transaction(root);
+       if (IS_ERR(trans))
+               return PTR_ERR(trans);
+       return btrfs_commit_transaction(trans);
+}
+
 static noinline_for_stack
 int scrub_enumerate_chunks(struct scrub_ctx *sctx,
                           struct btrfs_device *scrub_dev, u64 start, u64 end)
@@ -3629,6 +3703,16 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,
                 * group is not RO.
                 */
                ret = btrfs_inc_block_group_ro(cache, sctx->is_dev_replace);
+               if (!ret && sctx->is_dev_replace) {
+                       ret = finish_extent_writes_for_zoned(root, cache);
+                       if (ret) {
+                               btrfs_dec_block_group_ro(cache);
+                               scrub_pause_off(fs_info);
+                               btrfs_put_block_group(cache);
+                               break;
+                       }
+               }
+
                if (ret == 0) {
                        ro_set = 1;
                } else if (ret == -ENOSPC && !sctx->is_dev_replace) {

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 52ec672..1312b17 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -5978,7 +5978,7 @@ static bool is_block_group_to_copy(struct btrfs_fs_info *fs_info, u64 logical)
        struct btrfs_block_group *cache;
        bool ret;
 
-       /* Non-ZONED mode does not use "to_copy" flag */
+       /* Non zoned filesystem does not use "to_copy" flag */
        if (!btrfs_is_zoned(fs_info))
                return false;
 

diff --git a/fs/btrfs/zoned.c b/fs/btrfs/zoned.c
index 15288f7..a4707ba 100644 (file)
--- a/fs/btrfs/zoned.c
+++ b/fs/btrfs/zoned.c
@@ -1376,3 +1376,12 @@ void btrfs_revert_meta_write_pointer(struct btrfs_block_group *cache,
        ASSERT(cache->meta_write_pointer == eb->start + eb->len);
        cache->meta_write_pointer = eb->start;
 }
+
+int btrfs_zoned_issue_zeroout(struct btrfs_device *device, u64 physical, u64 length)
+{
+       if (!btrfs_dev_is_sequential(device, physical))
+               return -EOPNOTSUPP;
+
+       return blkdev_issue_zeroout(device->bdev, physical >> SECTOR_SHIFT,
+                                   length >> SECTOR_SHIFT, GFP_NOFS, 0);
+}

diff --git a/fs/btrfs/zoned.h b/fs/btrfs/zoned.h
index 0755a25..5ed1ea2 100644 (file)
--- a/fs/btrfs/zoned.h
+++ b/fs/btrfs/zoned.h
@@ -55,6 +55,7 @@ bool btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,
                                    struct btrfs_block_group **cache_ret);
 void btrfs_revert_meta_write_pointer(struct btrfs_block_group *cache,
                                     struct extent_buffer *eb);
+int btrfs_zoned_issue_zeroout(struct btrfs_device *device, u64 physical, u64 length);
 #else /* CONFIG_BLK_DEV_ZONED */
 static inline int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos,
                                     struct blk_zone *zone)
@@ -169,6 +170,12 @@ static inline void btrfs_revert_meta_write_pointer(
 {
 }
 
+static inline int btrfs_zoned_issue_zeroout(struct btrfs_device *device,
+                                           u64 physical, u64 length)
+{
+       return -EOPNOTSUPP;
+}
+
 #endif
 
 static inline bool btrfs_dev_is_sequential(struct btrfs_device *device, u64 pos)