btrfs: make BTRFS_RESERVE_FLUSH_EVICT use the global rsv stealing code

I forgot to convert this over when I introduced the global reserve
stealing code to the space flushing code.  Evict was simply trying to
make its reservation and then if it failed it would steal from the
global rsv, which is racey because it's outside of the normal ticketing
code.

Fix this by setting ticket->steal if we are BTRFS_RESERVE_FLUSH_EVICT,
and then make the priority flushing path do the steal for us.

Reviewed-by: Nikolay Borisov <nborisov@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index e87c6cc..0b89704 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -5523,7 +5523,6 @@ static struct btrfs_trans_handle *evict_refill_and_join(struct btrfs_root *root,
                                                        struct btrfs_block_rsv *rsv)
 {
        struct btrfs_fs_info *fs_info = root->fs_info;
-       struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
        struct btrfs_trans_handle *trans;
        u64 delayed_refs_extra = btrfs_calc_insert_metadata_size(fs_info, 1);
        int ret;
@@ -5538,18 +5537,16 @@ static struct btrfs_trans_handle *evict_refill_and_join(struct btrfs_root *root,
         * above.  We reserve our extra bit here because we generate a ton of
         * delayed refs activity by truncating.
         *
-        * If we cannot make our reservation we'll attempt to steal from the
-        * global reserve, because we really want to be able to free up space.
+        * BTRFS_RESERVE_FLUSH_EVICT will steal from the global_rsv if it can,
+        * if we fail to make this reservation we can re-try without the
+        * delayed_refs_extra so we can make some forward progress.
         */
        ret = btrfs_block_rsv_refill(root, rsv, rsv->size + delayed_refs_extra,
                                     BTRFS_RESERVE_FLUSH_EVICT);
        if (ret) {
-               /*
-                * Try to steal from the global reserve if there is space for
-                * it.
-                */
-               if (btrfs_check_space_for_delayed_refs(fs_info) ||
-                   btrfs_block_rsv_migrate(global_rsv, rsv, rsv->size, 0)) {
+               ret = btrfs_block_rsv_refill(root, rsv, rsv->size,
+                                            BTRFS_RESERVE_FLUSH_EVICT);
+               if (ret) {
                        btrfs_warn(fs_info,
                                   "could not allocate space for delete; will truncate on mount");
                        return ERR_PTR(-ENOSPC);

diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index 20f6c08..a546cd4 100644 (file)
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -1289,13 +1289,17 @@ static void priority_reclaim_metadata_space(struct btrfs_fs_info *fs_info,
                }
        }
 
+       /* Attempt to steal from the global rsv if we can. */
+       if (!steal_from_global_rsv(fs_info, space_info, ticket)) {
+               ticket->error = -ENOSPC;
+               remove_ticket(space_info, ticket);
+       }
+
        /*
         * We must run try_granting_tickets here because we could be a large
         * ticket in front of a smaller ticket that can now be satisfied with
         * the available space.
         */
-       ticket->error = -ENOSPC;
-       remove_ticket(space_info, ticket);
        btrfs_try_granting_tickets(fs_info, space_info);
        spin_unlock(&space_info->lock);
 }
@@ -1449,6 +1453,12 @@ static inline void maybe_clamp_preempt(struct btrfs_fs_info *fs_info,
                space_info->clamp = min(space_info->clamp + 1, 8);
 }
 
+static inline bool can_steal(enum btrfs_reserve_flush_enum flush)
+{
+       return (flush == BTRFS_RESERVE_FLUSH_ALL_STEAL ||
+               flush == BTRFS_RESERVE_FLUSH_EVICT);
+}
+
 /**
  * Try to reserve bytes from the block_rsv's space
  *
@@ -1522,7 +1532,7 @@ static int __reserve_bytes(struct btrfs_fs_info *fs_info,
                ticket.error = 0;
                space_info->reclaim_size += ticket.bytes;
                init_waitqueue_head(&ticket.wait);
-               ticket.steal = (flush == BTRFS_RESERVE_FLUSH_ALL_STEAL);
+               ticket.steal = can_steal(flush);
                if (trace_btrfs_reserve_ticket_enabled())
                        start_ns = ktime_get_ns();