3 files changed, 55 insertions, 3 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 85140913c0f5..0f4838e00fbc 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1210,6 +1210,8 @@ enum {
          * Set for the subvolume tree owning the reloc tree.
          */
         BTRFS_ROOT_DEAD_RELOC_TREE,
+        /* Mark dead root stored on device whose cleanup needs to be resumed */
+        BTRFS_ROOT_DEAD_TREE,
 };
 
 /*
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 994f0cc41799..36af54bec111 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -8771,6 +8771,7 @@ struct walk_control {
         int keep_locks;
         int reada_slot;
         int reada_count;
+        int restarted;
 };
 
 #define DROP_REFERENCE  1
@@ -8934,6 +8935,33 @@ static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
 }
 
 /*
+ * This is used to verify a ref exists for this root to deal with a bug where we
+ * would have a drop_progress key that hadn't been updated properly.
+ */
+static int check_ref_exists(struct btrfs_trans_handle *trans,
+                            struct btrfs_root *root, u64 bytenr, u64 parent,
+                            int level)
+{
+        struct btrfs_path *path;
+        struct btrfs_extent_inline_ref *iref;
+        int ret;
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        ret = lookup_extent_backref(trans, path, &iref, bytenr,
+                                    root->fs_info->nodesize, parent,
+                                    root->root_key.objectid, level, 0);
+        btrfs_free_path(path);
+        if (ret == -ENOENT)
+                return 0;
+        if (ret < 0)
+                return ret;
+        return 1;
+}
+
+/*
  * helper to process tree block pointer.
  *
  * when wc->stage == DROP_REFERENCE, this function checks
@@ -9088,6 +9116,23 @@ skip:
                 }
 
                 /*
+                 * If we had a drop_progress we need to verify the refs are set
+                 * as expected.  If we find our ref then we know that from here
+                 * on out everything should be correct, and we can clear the
+                 * ->restarted flag.
+                 */
+                if (wc->restarted) {
+                        ret = check_ref_exists(trans, root, bytenr, parent,
+                                               level - 1);
+                        if (ret < 0)
+                                goto out_unlock;
+                        if (ret == 0)
+                                goto no_delete;
+                        ret = 0;
+                        wc->restarted = 0;
+                }
+
+                /*
                  * Reloc tree doesn't contribute to qgroup numbers, and we have
                  * already accounted them at merge time (replace_path),
                  * thus we could skip expensive subtree trace here.
@@ -9108,7 +9153,7 @@ skip:
                 if (ret)
                         goto out_unlock;
         }
-
+no_delete:
         *lookup_info = 1;
         ret = 1;
 
@@ -9425,6 +9470,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root,
                 }
         }
 
+        wc->restarted = test_bit(BTRFS_ROOT_DEAD_TREE, &root->state);
         wc->level = level;
         wc->shared_level = -1;
         wc->stage = DROP_REFERENCE;
diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 0d2b957ca3a3..893d12fbfda0 100644
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -263,8 +263,10 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
                 if (root) {
                         WARN_ON(!test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
                                           &root->state));
-                        if (btrfs_root_refs(&root->root_item) == 0)
+                        if (btrfs_root_refs(&root->root_item) == 0) {
+                                set_bit(BTRFS_ROOT_DEAD_TREE, &root->state);
                                 btrfs_add_dead_root(root);
+                        }
                         continue;
                 }
 
@@ -310,8 +312,10 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
                         break;
                 }
 
-                if (btrfs_root_refs(&root->root_item) == 0)
+                if (btrfs_root_refs(&root->root_item) == 0) {
+                        set_bit(BTRFS_ROOT_DEAD_TREE, &root->state);
                         btrfs_add_dead_root(root);
+                }
         }
 
         btrfs_free_path(path);