btrfs: zoned: enable relocation on a zoned filesystem

Currently fallocate() is disabled on a zoned filesystem. Since current
relocation process relies on preallocation to move file data extents, it
must be handled differently.

On a zoned filesystem, we just truncate the inode to the size that we
wanted to pre-allocate. Then, we flush dirty pages on the file before
finishing the relocation process. run_delalloc_zoned() will handle all
the allocations and submit IOs to the underlying layers.

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/relocation.c b/fs/btrfs/relocation.c
index 473b788..232d5da 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -2553,6 +2553,31 @@ static noinline_for_stack int prealloc_file_extent_cluster(
        if (ret)
                return ret;
 
+       /*
+        * On a zoned filesystem, we cannot preallocate the file region.
+        * Instead, we dirty and fiemap_write the region.
+        */
+       if (btrfs_is_zoned(inode->root->fs_info)) {
+               struct btrfs_root *root = inode->root;
+               struct btrfs_trans_handle *trans;
+
+               end = cluster->end - offset + 1;
+               trans = btrfs_start_transaction(root, 1);
+               if (IS_ERR(trans))
+                       return PTR_ERR(trans);
+
+               inode->vfs_inode.i_ctime = current_time(&inode->vfs_inode);
+               i_size_write(&inode->vfs_inode, end);
+               ret = btrfs_update_inode(trans, root, inode);
+               if (ret) {
+                       btrfs_abort_transaction(trans, ret);
+                       btrfs_end_transaction(trans);
+                       return ret;
+               }
+
+               return btrfs_end_transaction(trans);
+       }
+
        inode_lock(&inode->vfs_inode);
        for (nr = 0; nr < cluster->nr; nr++) {
                start = cluster->boundary[nr] - offset;
@@ -2756,6 +2781,8 @@ static int relocate_file_extent_cluster(struct inode *inode,
                }
        }
        WARN_ON(nr != cluster->nr);
+       if (btrfs_is_zoned(fs_info) && !ret)
+               ret = btrfs_wait_ordered_range(inode, 0, (u64)-1);
 out:
        kfree(ra);
        return ret;
@@ -3434,8 +3461,12 @@ static int __insert_orphan_inode(struct btrfs_trans_handle *trans,
        struct btrfs_path *path;
        struct btrfs_inode_item *item;
        struct extent_buffer *leaf;
+       u64 flags = BTRFS_INODE_NOCOMPRESS | BTRFS_INODE_PREALLOC;
        int ret;
 
+       if (btrfs_is_zoned(trans->fs_info))
+               flags &= ~BTRFS_INODE_PREALLOC;
+
        path = btrfs_alloc_path();
        if (!path)
                return -ENOMEM;
@@ -3450,8 +3481,7 @@ static int __insert_orphan_inode(struct btrfs_trans_handle *trans,
        btrfs_set_inode_generation(leaf, item, 1);
        btrfs_set_inode_size(leaf, item, 0);
        btrfs_set_inode_mode(leaf, item, S_IFREG | 0600);
-       btrfs_set_inode_flags(leaf, item, BTRFS_INODE_NOCOMPRESS |
-                                         BTRFS_INODE_PREALLOC);
+       btrfs_set_inode_flags(leaf, item, flags);
        btrfs_mark_buffer_dirty(leaf);
 out:
        btrfs_free_path(path);