btrfs: unexport setup_items_for_insert()

Since setup_items_for_insert() is not used anymore outside of ctree.c,
make it static and remove its prototype from ctree.h. This also requires
to move the definition of setup_item_for_insert() from ctree.h to ctree.c
and move down btrfs_duplicate_item() so that it's defined after
setup_items_for_insert().

Further, since setup_item_for_insert() is used outside ctree.c, rename it
to btrfs_setup_item_for_insert().

This patch is part of a small patchset that is comprised of the following
patches:

  btrfs: loop only once over data sizes array when inserting an item batch
  btrfs: unexport setup_items_for_insert()
  btrfs: use single bulk copy operations when logging directories

This is patch 2/3 and performance results, and the specific tests, are
included in the changelog of patch 3/3.

Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 49e2bbda2d7ec6ecb2144fa9419644ef752b2062..74c8e18f3720da8573937e3dce51f18a61e0a156 100644 (file)
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -3580,40 +3580,6 @@ int btrfs_split_item(struct btrfs_trans_handle *trans,
        return ret;
 }
 
-/*
- * This function duplicate a item, giving 'new_key' to the new item.
- * It guarantees both items live in the same tree leaf and the new item
- * is contiguous with the original item.
- *
- * This allows us to split file extent in place, keeping a lock on the
- * leaf the entire time.
- */
-int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root,
-                        struct btrfs_path *path,
-                        const struct btrfs_key *new_key)
-{
-       struct extent_buffer *leaf;
-       int ret;
-       u32 item_size;
-
-       leaf = path->nodes[0];
-       item_size = btrfs_item_size_nr(leaf, path->slots[0]);
-       ret = setup_leaf_for_split(trans, root, path,
-                                  item_size + sizeof(struct btrfs_item));
-       if (ret)
-               return ret;
-
-       path->slots[0]++;
-       setup_item_for_insert(root, path, new_key, item_size);
-       leaf = path->nodes[0];
-       memcpy_extent_buffer(leaf,
-                            btrfs_item_ptr_offset(leaf, path->slots[0]),
-                            btrfs_item_ptr_offset(leaf, path->slots[0] - 1),
-                            item_size);
-       return 0;
-}
-
 /*
  * make the item pointed to by the path smaller.  new_size indicates
  * how small to make it, and from_end tells us if we just chop bytes
@@ -3787,8 +3753,8 @@ void btrfs_extend_item(struct btrfs_path *path, u32 data_size)
  * @path:      points to the leaf/slot where we are going to insert new items
  * @batch:      information about the batch of items to insert
  */
-void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
-                           const struct btrfs_item_batch *batch)
+static void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
+                                  const struct btrfs_item_batch *batch)
 {
        struct btrfs_fs_info *fs_info = root->fs_info;
        struct btrfs_item *item;
@@ -3881,6 +3847,29 @@ void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
        }
 }
 
+/*
+ * Insert a new item into a leaf.
+ *
+ * @root:      The root of the btree.
+ * @path:      A path pointing to the target leaf and slot.
+ * @key:       The key of the new item.
+ * @data_size: The size of the data associated with the new key.
+ */
+void btrfs_setup_item_for_insert(struct btrfs_root *root,
+                                struct btrfs_path *path,
+                                const struct btrfs_key *key,
+                                u32 data_size)
+{
+       struct btrfs_item_batch batch;
+
+       batch.keys = key;
+       batch.data_sizes = &data_size;
+       batch.total_data_size = data_size;
+       batch.nr = 1;
+
+       setup_items_for_insert(root, path, &batch);
+}
+
 /*
  * Given a key and some data, insert items into the tree.
  * This does all the path init required, making room in the tree if needed.
@@ -3935,6 +3924,40 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
        return ret;
 }
 
+/*
+ * This function duplicates an item, giving 'new_key' to the new item.
+ * It guarantees both items live in the same tree leaf and the new item is
+ * contiguous with the original item.
+ *
+ * This allows us to split a file extent in place, keeping a lock on the leaf
+ * the entire time.
+ */
+int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
+                        struct btrfs_root *root,
+                        struct btrfs_path *path,
+                        const struct btrfs_key *new_key)
+{
+       struct extent_buffer *leaf;
+       int ret;
+       u32 item_size;
+
+       leaf = path->nodes[0];
+       item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+       ret = setup_leaf_for_split(trans, root, path,
+                                  item_size + sizeof(struct btrfs_item));
+       if (ret)
+               return ret;
+
+       path->slots[0]++;
+       btrfs_setup_item_for_insert(root, path, new_key, item_size);
+       leaf = path->nodes[0];
+       memcpy_extent_buffer(leaf,
+                            btrfs_item_ptr_offset(leaf, path->slots[0]),
+                            btrfs_item_ptr_offset(leaf, path->slots[0] - 1),
+                            item_size);
+       return 0;
+}
+
 /*
  * delete the pointer from a given node.
  *

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 140fe98f5e385a714c85600974f80483fb5cb123..ad674f092b4e6217590a2ed66286d9d65226302b 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2899,7 +2899,7 @@ static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
 
 /*
  * Describes a batch of items to insert in a btree. This is used by
- * btrfs_insert_empty_items() and setup_items_for_insert().
+ * btrfs_insert_empty_items().
  */
 struct btrfs_item_batch {
        /*
@@ -2923,24 +2923,10 @@ struct btrfs_item_batch {
        int nr;
 };
 
-void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
-                           const struct btrfs_item_batch *batch);
-
-static inline void setup_item_for_insert(struct btrfs_root *root,
-                                        struct btrfs_path *path,
-                                        const struct btrfs_key *key,
-                                        u32 data_size)
-{
-       struct btrfs_item_batch batch;
-
-       batch.keys = key;
-       batch.data_sizes = &data_size;
-       batch.total_data_size = data_size;
-       batch.nr = 1;
-
-       setup_items_for_insert(root, path, &batch);
-}
-
+void btrfs_setup_item_for_insert(struct btrfs_root *root,
+                                struct btrfs_path *path,
+                                const struct btrfs_key *key,
+                                u32 data_size);
 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                      const struct btrfs_key *key, void *data, u32 data_size);
 int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index eee512743d52da7cac7208ea8aef666acf091664..6c50561f932fefd16f55199583f25b0f9ea53239 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1020,7 +1020,7 @@ delete_extent_item:
                        if (btrfs_comp_cpu_keys(&key, &slot_key) > 0)
                                path->slots[0]++;
                }
-               setup_item_for_insert(root, path, &key, args->extent_item_size);
+               btrfs_setup_item_for_insert(root, path, &key, args->extent_item_size);
                args->extent_inserted = true;
        }
 

diff --git a/fs/btrfs/tests/extent-buffer-tests.c b/fs/btrfs/tests/extent-buffer-tests.c
index c9ab65e3d8e8fc00789fb9bb762091d74aed0933..2a95f7224e1859caa58cf14404e287f56f2d0575 100644 (file)
--- a/fs/btrfs/tests/extent-buffer-tests.c
+++ b/fs/btrfs/tests/extent-buffer-tests.c
@@ -60,7 +60,7 @@ static int test_btrfs_split_item(u32 sectorsize, u32 nodesize)
        key.type = BTRFS_EXTENT_CSUM_KEY;
        key.offset = 0;
 
-       setup_item_for_insert(root, path, &key, value_len);
+       btrfs_setup_item_for_insert(root, path, &key, value_len);
        item = btrfs_item_nr(0);
        write_extent_buffer(eb, value, btrfs_item_ptr_offset(eb, 0),
                            value_len);

diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c
index af62d05435b96b7f6570ad2c180d20afbd6d0764..cac89c38813119221b08b1106357c8d1341eaba7 100644 (file)
--- a/fs/btrfs/tests/inode-tests.c
+++ b/fs/btrfs/tests/inode-tests.c
@@ -33,7 +33,7 @@ static void insert_extent(struct btrfs_root *root, u64 start, u64 len,
        key.type = BTRFS_EXTENT_DATA_KEY;
        key.offset = start;
 
-       setup_item_for_insert(root, &path, &key, value_len);
+       btrfs_setup_item_for_insert(root, &path, &key, value_len);
        fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
        btrfs_set_file_extent_generation(leaf, fi, 1);
        btrfs_set_file_extent_type(leaf, fi, type);
@@ -63,7 +63,7 @@ static void insert_inode_item_key(struct btrfs_root *root)
        key.type = BTRFS_INODE_ITEM_KEY;
        key.offset = 0;
 
-       setup_item_for_insert(root, &path, &key, value_len);
+       btrfs_setup_item_for_insert(root, &path, &key, value_len);
 }
 
 /*