Btrfs: don't wait for unrelated IO to finish before relocation

Before the relocation process of a block group starts, it sets the block
group to readonly mode, then flushes all delalloc writes and then finally
it waits for all ordered extents to complete. This last step includes
waiting for ordered extents destinated at extents allocated in other block
groups, making us waste unecessary time.

So improve this by waiting only for ordered extents that fall into the
block group's range.

Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Josef Bacik <jbacik@fb.com>
Reviewed-by: Liu Bo <bo.li.liu@oracle.com>

1 files changed, 19 insertions, 7 deletions

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 0de7da5a610d..559170464d7c 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -661,14 +661,15 @@ static void btrfs_run_ordered_extent_work(struct btrfs_work *work)
  * wait for all the ordered extents in a root.  This is done when balancing
  * space between drives.
  */
-int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr)
+int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr,
+                               const u64 range_start, const u64 range_len)
 {
-        struct list_head splice, works;
+        LIST_HEAD(splice);
+        LIST_HEAD(skipped);
+        LIST_HEAD(works);
         struct btrfs_ordered_extent *ordered, *next;
         int count = 0;
-
-        INIT_LIST_HEAD(&splice);
-        INIT_LIST_HEAD(&works);
+        const u64 range_end = range_start + range_len;
 
         mutex_lock(&root->ordered_extent_mutex);
         spin_lock(&root->ordered_extent_lock);
@@ -676,6 +677,14 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr)
         while (!list_empty(&splice) && nr) {
                 ordered = list_first_entry(&splice, struct btrfs_ordered_extent,
                                            root_extent_list);
+
+                if (range_end <= ordered->start ||
+                    ordered->start + ordered->disk_len <= range_start) {
+                        list_move_tail(&ordered->root_extent_list, &skipped);
+                        cond_resched_lock(&root->ordered_extent_lock);
+                        continue;
+                }
+
                 list_move_tail(&ordered->root_extent_list,
                                &root->ordered_extents);
                 atomic_inc(&ordered->refs);
@@ -694,6 +703,7 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr)
                         nr--;
                 count++;
         }
+        list_splice_tail(&skipped, &root->ordered_extents);
         list_splice_tail(&splice, &root->ordered_extents);
         spin_unlock(&root->ordered_extent_lock);
 
@@ -708,7 +718,8 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr)
         return count;
 }
 
-void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr)
+void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr,
+                              const u64 range_start, const u64 range_len)
 {
         struct btrfs_root *root;
         struct list_head splice;
@@ -728,7 +739,8 @@ void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr)
                                &fs_info->ordered_roots);
                 spin_unlock(&fs_info->ordered_root_lock);
 
-                done = btrfs_wait_ordered_extents(root, nr);
+                done = btrfs_wait_ordered_extents(root, nr,
+                                                  range_start, range_len);
                 btrfs_put_fs_root(root);
 
                 spin_lock(&fs_info->ordered_root_lock);