Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable: (42 commits)
  Btrfs: hash the btree inode during  fill_super
  Btrfs: relocate file extents in clusters
  Btrfs: don't rename file into dummy directory
  Btrfs: check size of inode backref before adding hardlink
  Btrfs: fix releasepage to avoid unlocking extents we haven't locked
  Btrfs: Fix test_range_bit for whole file extents
  Btrfs: fix errors handling cached state in set/clear_extent_bit
  Btrfs: fix early enospc during balancing
  Btrfs: deal with NULL space info
  Btrfs: account for space used by the super mirrors
  Btrfs: fix extent entry threshold calculation
  Btrfs: remove dead code
  Btrfs: fix bitmap size tracking
  Btrfs: don't keep retrying a block group if we fail to allocate a cluster
  Btrfs: make balance code choose more wisely when relocating
  Btrfs: fix arithmetic error in clone ioctl
  Btrfs: add snapshot/subvolume destroy ioctl
  Btrfs: change how subvolumes are organized
  Btrfs: do not reuse objectid of deleted snapshot/subvol
  Btrfs: speed up snapshot dropping
  ...

1 files changed, 115 insertions, 23 deletions

diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 0ddc6d61c55a..9351428f30e2 100644
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -94,17 +94,23 @@ int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
                 goto out;
 
         BUG_ON(ret == 0);
+        if (path->slots[0] == 0) {
+                ret = 1;
+                goto out;
+        }
         l = path->nodes[0];
-        BUG_ON(path->slots[0] == 0);
         slot = path->slots[0] - 1;
         btrfs_item_key_to_cpu(l, &found_key, slot);
-        if (found_key.objectid != objectid) {
+        if (found_key.objectid != objectid ||
+            found_key.type != BTRFS_ROOT_ITEM_KEY) {
                 ret = 1;
                 goto out;
         }
-        read_extent_buffer(l, item, btrfs_item_ptr_offset(l, slot),
-                           sizeof(*item));
-        memcpy(key, &found_key, sizeof(found_key));
+        if (item)
+                read_extent_buffer(l, item, btrfs_item_ptr_offset(l, slot),
+                                   sizeof(*item));
+        if (key)
+                memcpy(key, &found_key, sizeof(found_key));
         ret = 0;
 out:
         btrfs_free_path(path);
@@ -249,6 +255,59 @@ err:
         return ret;
 }
 
+int btrfs_find_orphan_roots(struct btrfs_root *tree_root)
+{
+        struct extent_buffer *leaf;
+        struct btrfs_path *path;
+        struct btrfs_key key;
+        int err = 0;
+        int ret;
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        key.objectid = BTRFS_ORPHAN_OBJECTID;
+        key.type = BTRFS_ORPHAN_ITEM_KEY;
+        key.offset = 0;
+
+        while (1) {
+                ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
+                if (ret < 0) {
+                        err = ret;
+                        break;
+                }
+
+                leaf = path->nodes[0];
+                if (path->slots[0] >= btrfs_header_nritems(leaf)) {
+                        ret = btrfs_next_leaf(tree_root, path);
+                        if (ret < 0)
+                                err = ret;
+                        if (ret != 0)
+                                break;
+                        leaf = path->nodes[0];
+                }
+
+                btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
+                btrfs_release_path(tree_root, path);
+
+                if (key.objectid != BTRFS_ORPHAN_OBJECTID ||
+                    key.type != BTRFS_ORPHAN_ITEM_KEY)
+                        break;
+
+                ret = btrfs_find_dead_roots(tree_root, key.offset);
+                if (ret) {
+                        err = ret;
+                        break;
+                }
+
+                key.offset++;
+        }
+
+        btrfs_free_path(path);
+        return err;
+}
+
 /* drop the root item for 'key' from 'root' */
 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                    struct btrfs_key *key)
@@ -278,31 +337,57 @@ out:
         return ret;
 }
 
-#if 0 /* this will get used when snapshot deletion is implemented */
 int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
                        struct btrfs_root *tree_root,
-                       u64 root_id, u8 type, u64 ref_id)
+                       u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
+                       const char *name, int name_len)
+
 {
+        struct btrfs_path *path;
+        struct btrfs_root_ref *ref;
+        struct extent_buffer *leaf;
         struct btrfs_key key;
+        unsigned long ptr;
+        int err = 0;
         int ret;
-        struct btrfs_path *path;
 
         path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
 
         key.objectid = root_id;
-        key.type = type;
+        key.type = BTRFS_ROOT_BACKREF_KEY;
         key.offset = ref_id;
-
+again:
         ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
-        BUG_ON(ret);
-
-        ret = btrfs_del_item(trans, tree_root, path);
-        BUG_ON(ret);
+        BUG_ON(ret < 0);
+        if (ret == 0) {
+                leaf = path->nodes[0];
+                ref = btrfs_item_ptr(leaf, path->slots[0],
+                                     struct btrfs_root_ref);
+
+                WARN_ON(btrfs_root_ref_dirid(leaf, ref) != dirid);
+                WARN_ON(btrfs_root_ref_name_len(leaf, ref) != name_len);
+                ptr = (unsigned long)(ref + 1);
+                WARN_ON(memcmp_extent_buffer(leaf, name, ptr, name_len));
+                *sequence = btrfs_root_ref_sequence(leaf, ref);
+
+                ret = btrfs_del_item(trans, tree_root, path);
+                BUG_ON(ret);
+        } else
+                err = -ENOENT;
+
+        if (key.type == BTRFS_ROOT_BACKREF_KEY) {
+                btrfs_release_path(tree_root, path);
+                key.objectid = ref_id;
+                key.type = BTRFS_ROOT_REF_KEY;
+                key.offset = root_id;
+                goto again;
+        }
 
         btrfs_free_path(path);
-        return ret;
+        return err;
 }
-#endif
 
 int btrfs_find_root_ref(struct btrfs_root *tree_root,
                    struct btrfs_path *path,
@@ -319,7 +404,6 @@ int btrfs_find_root_ref(struct btrfs_root *tree_root,
         return ret;
 }
 
-
 /*
  * add a btrfs_root_ref item.  type is either BTRFS_ROOT_REF_KEY
  * or BTRFS_ROOT_BACKREF_KEY.
@@ -335,8 +419,7 @@ int btrfs_find_root_ref(struct btrfs_root *tree_root,
  */
 int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
                        struct btrfs_root *tree_root,
-                       u64 root_id, u8 type, u64 ref_id,
-                       u64 dirid, u64 sequence,
+                       u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
                        const char *name, int name_len)
 {
         struct btrfs_key key;
@@ -346,13 +429,14 @@ int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
         struct extent_buffer *leaf;
         unsigned long ptr;
 
-
         path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
 
         key.objectid = root_id;
-        key.type = type;
+        key.type = BTRFS_ROOT_BACKREF_KEY;
         key.offset = ref_id;
-
+again:
         ret = btrfs_insert_empty_item(trans, tree_root, path, &key,
                                       sizeof(*ref) + name_len);
         BUG_ON(ret);
@@ -366,6 +450,14 @@ int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
         write_extent_buffer(leaf, name, ptr, name_len);
         btrfs_mark_buffer_dirty(leaf);
 
+        if (key.type == BTRFS_ROOT_BACKREF_KEY) {
+                btrfs_release_path(tree_root, path);
+                key.objectid = ref_id;
+                key.type = BTRFS_ROOT_REF_KEY;
+                key.offset = root_id;
+                goto again;
+        }
+
         btrfs_free_path(path);
-        return ret;
+        return 0;
 }