btrfs: uninline some static inline helpers from backref.h

There are many helpers doing simple things but not simple enough to
justify the static inline. None of them seems to be on a hot path so
move them to .c.

Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 1b57c8289de65cbbbcb98de1828353cf5bb52143..6514cb1d404a78d23f623aaa86d4052a9f862643 100644 (file)
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -2856,6 +2856,16 @@ struct btrfs_backref_iter *btrfs_backref_iter_alloc(struct btrfs_fs_info *fs_inf
        return ret;
 }
 
+static void btrfs_backref_iter_release(struct btrfs_backref_iter *iter)
+{
+       iter->bytenr = 0;
+       iter->item_ptr = 0;
+       iter->cur_ptr = 0;
+       iter->end_ptr = 0;
+       btrfs_release_path(iter->path);
+       memset(&iter->cur_key, 0, sizeof(iter->cur_key));
+}
+
 int btrfs_backref_iter_start(struct btrfs_backref_iter *iter, u64 bytenr)
 {
        struct btrfs_fs_info *fs_info = iter->fs_info;
@@ -2948,6 +2958,14 @@ release:
        return ret;
 }
 
+static 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;
+}
+
 /*
  * Go to the next backref item of current bytenr, can be either inlined or
  * keyed.
@@ -3048,6 +3066,19 @@ struct btrfs_backref_node *btrfs_backref_alloc_node(
        return node;
 }
 
+void btrfs_backref_free_node(struct btrfs_backref_cache *cache,
+                            struct btrfs_backref_node *node)
+{
+       if (node) {
+               ASSERT(list_empty(&node->list));
+               ASSERT(list_empty(&node->lower));
+               ASSERT(node->eb == NULL);
+               cache->nr_nodes--;
+               btrfs_put_root(node->root);
+               kfree(node);
+       }
+}
+
 struct btrfs_backref_edge *btrfs_backref_alloc_edge(
                struct btrfs_backref_cache *cache)
 {
@@ -3059,6 +3090,52 @@ struct btrfs_backref_edge *btrfs_backref_alloc_edge(
        return edge;
 }
 
+void btrfs_backref_free_edge(struct btrfs_backref_cache *cache,
+                            struct btrfs_backref_edge *edge)
+{
+       if (edge) {
+               cache->nr_edges--;
+               kfree(edge);
+       }
+}
+
+void btrfs_backref_unlock_node_buffer(struct btrfs_backref_node *node)
+{
+       if (node->locked) {
+               btrfs_tree_unlock(node->eb);
+               node->locked = 0;
+       }
+}
+
+void btrfs_backref_drop_node_buffer(struct btrfs_backref_node *node)
+{
+       if (node->eb) {
+               btrfs_backref_unlock_node_buffer(node);
+               free_extent_buffer(node->eb);
+               node->eb = NULL;
+       }
+}
+
+/*
+ * Drop the backref node from cache without cleaning up its children
+ * edges.
+ *
+ * This can only be called on node without parent edges.
+ * The children edges are still kept as is.
+ */
+void btrfs_backref_drop_node(struct btrfs_backref_cache *tree,
+                            struct btrfs_backref_node *node)
+{
+       ASSERT(list_empty(&node->upper));
+
+       btrfs_backref_drop_node_buffer(node);
+       list_del_init(&node->list);
+       list_del_init(&node->lower);
+       if (!RB_EMPTY_NODE(&node->rb_node))
+               rb_erase(&node->rb_node, &tree->rb_root);
+       btrfs_backref_free_node(tree, node);
+}
+
 /*
  * Drop the backref node from cache, also cleaning up all its
  * upper edges and any uncached nodes in the path.
@@ -3130,6 +3207,19 @@ void btrfs_backref_release_cache(struct btrfs_backref_cache *cache)
        ASSERT(!cache->nr_edges);
 }
 
+void btrfs_backref_link_edge(struct btrfs_backref_edge *edge,
+                            struct btrfs_backref_node *lower,
+                            struct btrfs_backref_node *upper,
+                            int link_which)
+{
+       ASSERT(upper && lower && upper->level == lower->level + 1);
+       edge->node[LOWER] = lower;
+       edge->node[UPPER] = upper;
+       if (link_which & LINK_LOWER)
+               list_add_tail(&edge->list[LOWER], &lower->upper);
+       if (link_which & LINK_UPPER)
+               list_add_tail(&edge->list[UPPER], &upper->lower);
+}
 /*
  * Handle direct tree backref
  *

diff --git a/fs/btrfs/backref.h b/fs/btrfs/backref.h
index 04b82c512bf180c20dd4da8ab420d2376f4b96bf..e8c22cccb5c13286fc8b41190c689b0abc7e0cf7 100644 (file)
--- a/fs/btrfs/backref.h
+++ b/fs/btrfs/backref.h
@@ -302,25 +302,6 @@ 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;
-       iter->item_ptr = 0;
-       iter->cur_ptr = 0;
-       iter->end_ptr = 0;
-       btrfs_release_path(iter->path);
-       memset(&iter->cur_key, 0, sizeof(iter->cur_key));
-}
-
 /*
  * Backref cache related structures
  *
@@ -448,83 +429,22 @@ struct btrfs_backref_edge *btrfs_backref_alloc_edge(
 
 #define                LINK_LOWER      (1 << 0)
 #define                LINK_UPPER      (1 << 1)
-static inline void btrfs_backref_link_edge(struct btrfs_backref_edge *edge,
-                                          struct btrfs_backref_node *lower,
-                                          struct btrfs_backref_node *upper,
-                                          int link_which)
-{
-       ASSERT(upper && lower && upper->level == lower->level + 1);
-       edge->node[LOWER] = lower;
-       edge->node[UPPER] = upper;
-       if (link_which & LINK_LOWER)
-               list_add_tail(&edge->list[LOWER], &lower->upper);
-       if (link_which & LINK_UPPER)
-               list_add_tail(&edge->list[UPPER], &upper->lower);
-}
-
-static inline void btrfs_backref_free_node(struct btrfs_backref_cache *cache,
-                                          struct btrfs_backref_node *node)
-{
-       if (node) {
-               ASSERT(list_empty(&node->list));
-               ASSERT(list_empty(&node->lower));
-               ASSERT(node->eb == NULL);
-               cache->nr_nodes--;
-               btrfs_put_root(node->root);
-               kfree(node);
-       }
-}
 
-static inline void btrfs_backref_free_edge(struct btrfs_backref_cache *cache,
-                                          struct btrfs_backref_edge *edge)
-{
-       if (edge) {
-               cache->nr_edges--;
-               kfree(edge);
-       }
-}
-
-static inline void btrfs_backref_unlock_node_buffer(
-               struct btrfs_backref_node *node)
-{
-       if (node->locked) {
-               btrfs_tree_unlock(node->eb);
-               node->locked = 0;
-       }
-}
-
-static inline void btrfs_backref_drop_node_buffer(
-               struct btrfs_backref_node *node)
-{
-       if (node->eb) {
-               btrfs_backref_unlock_node_buffer(node);
-               free_extent_buffer(node->eb);
-               node->eb = NULL;
-       }
-}
-
-/*
- * Drop the backref node from cache without cleaning up its children
- * edges.
- *
- * This can only be called on node without parent edges.
- * The children edges are still kept as is.
- */
-static inline void btrfs_backref_drop_node(struct btrfs_backref_cache *tree,
-                                          struct btrfs_backref_node *node)
-{
-       ASSERT(list_empty(&node->upper));
-
-       btrfs_backref_drop_node_buffer(node);
-       list_del_init(&node->list);
-       list_del_init(&node->lower);
-       if (!RB_EMPTY_NODE(&node->rb_node))
-               rb_erase(&node->rb_node, &tree->rb_root);
-       btrfs_backref_free_node(tree, node);
-}
+void btrfs_backref_link_edge(struct btrfs_backref_edge *edge,
+                            struct btrfs_backref_node *lower,
+                            struct btrfs_backref_node *upper,
+                            int link_which);
+void btrfs_backref_free_node(struct btrfs_backref_cache *cache,
+                            struct btrfs_backref_node *node);
+void btrfs_backref_free_edge(struct btrfs_backref_cache *cache,
+                            struct btrfs_backref_edge *edge);
+void btrfs_backref_unlock_node_buffer(struct btrfs_backref_node *node);
+void btrfs_backref_drop_node_buffer(struct btrfs_backref_node *node);
 
 void btrfs_backref_cleanup_node(struct btrfs_backref_cache *cache,
                                struct btrfs_backref_node *node);
+void btrfs_backref_drop_node(struct btrfs_backref_cache *tree,
+                            struct btrfs_backref_node *node);
 
 void btrfs_backref_release_cache(struct btrfs_backref_cache *cache);