btrfs: backref: implement btrfs_backref_iter_next()

This function will go to the next inline/keyed backref for
btrfs_backref_iter infrastructure.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index a1bac1b..27f9a59 100644 (file)
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -2405,3 +2405,63 @@ release:
        btrfs_backref_iter_release(iter);
        return ret;
 }
+
+/*
+ * Go to the next backref item of current bytenr, can be either inlined or
+ * keyed.
+ *
+ * Caller needs to check whether it's inline ref or not by iter->cur_key.
+ *
+ * Return 0 if we get next backref without problem.
+ * Return >0 if there is no extra backref for this bytenr.
+ * Return <0 if there is something wrong happened.
+ */
+int btrfs_backref_iter_next(struct btrfs_backref_iter *iter)
+{
+       struct extent_buffer *eb = btrfs_backref_get_eb(iter);
+       struct btrfs_path *path = iter->path;
+       struct btrfs_extent_inline_ref *iref;
+       int ret;
+       u32 size;
+
+       if (btrfs_backref_iter_is_inline_ref(iter)) {
+               /* We're still inside the inline refs */
+               ASSERT(iter->cur_ptr < iter->end_ptr);
+
+               if (btrfs_backref_has_tree_block_info(iter)) {
+                       /* First tree block info */
+                       size = sizeof(struct btrfs_tree_block_info);
+               } else {
+                       /* Use inline ref type to determine the size */
+                       int type;
+
+                       iref = (struct btrfs_extent_inline_ref *)
+                               ((unsigned long)iter->cur_ptr);
+                       type = btrfs_extent_inline_ref_type(eb, iref);
+
+                       size = btrfs_extent_inline_ref_size(type);
+               }
+               iter->cur_ptr += size;
+               if (iter->cur_ptr < iter->end_ptr)
+                       return 0;
+
+               /* All inline items iterated, fall through */
+       }
+
+       /* We're at keyed items, there is no inline item, go to the next one */
+       ret = btrfs_next_item(iter->fs_info->extent_root, iter->path);
+       if (ret)
+               return ret;
+
+       btrfs_item_key_to_cpu(path->nodes[0], &iter->cur_key, path->slots[0]);
+       if (iter->cur_key.objectid != iter->bytenr ||
+           (iter->cur_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
+            iter->cur_key.type != BTRFS_SHARED_BLOCK_REF_KEY))
+               return 1;
+       iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],
+                                       path->slots[0]);
+       iter->cur_ptr = iter->item_ptr;
+       iter->end_ptr = iter->item_ptr + (u32)btrfs_item_size_nr(path->nodes[0],
+                                               path->slots[0]);
+       return 0;
+}

diff --git a/fs/btrfs/backref.h b/fs/btrfs/backref.h
index 4ae37fa..46faf9b 100644 (file)
--- a/fs/btrfs/backref.h
+++ b/fs/btrfs/backref.h
@@ -104,8 +104,42 @@ static inline void btrfs_backref_iter_free(struct btrfs_backref_iter *iter)
        kfree(iter);
 }
 
+static inline struct extent_buffer *btrfs_backref_get_eb(
+               struct btrfs_backref_iter *iter)
+{
+       if (!iter)
+               return NULL;
+       return iter->path->nodes[0];
+}
+
+/*
+ * For metadata with EXTENT_ITEM key (non-skinny) case, the first inline data
+ * is btrfs_tree_block_info, without a btrfs_extent_inline_ref header.
+ *
+ * This helper determines if that's the case.
+ */
+static inline bool btrfs_backref_has_tree_block_info(
+               struct btrfs_backref_iter *iter)
+{
+       if (iter->cur_key.type == BTRFS_EXTENT_ITEM_KEY &&
+           iter->cur_ptr - iter->item_ptr == sizeof(struct btrfs_extent_item))
+               return true;
+       return false;
+}
+
 int btrfs_backref_iter_start(struct btrfs_backref_iter *iter, u64 bytenr);
 
+int btrfs_backref_iter_next(struct btrfs_backref_iter *iter);
+
+static inline bool btrfs_backref_iter_is_inline_ref(
+               struct btrfs_backref_iter *iter)
+{
+       if (iter->cur_key.type == BTRFS_EXTENT_ITEM_KEY ||
+           iter->cur_key.type == BTRFS_METADATA_ITEM_KEY)
+               return true;
+       return false;
+}
+
 static inline void btrfs_backref_iter_release(struct btrfs_backref_iter *iter)
 {
        iter->bytenr = 0;