btrfs: move split_extent_map to extent_map.c

split_extent_map doesn't have anything to do with the other code in
inode.c, so move it to extent_map.c.

This also allows marking replace_extent_mapping static.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 4d86d47..e512446 100644 (file)
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -504,10 +504,10 @@ void remove_extent_mapping(struct extent_map_tree *tree, struct extent_map *em)
        RB_CLEAR_NODE(&em->rb_node);
 }
 
-void replace_extent_mapping(struct extent_map_tree *tree,
-                           struct extent_map *cur,
-                           struct extent_map *new,
-                           int modified)
+static void replace_extent_mapping(struct extent_map_tree *tree,
+                                  struct extent_map *cur,
+                                  struct extent_map *new,
+                                  int modified)
 {
        lockdep_assert_held_write(&tree->lock);
 
@@ -961,3 +961,93 @@ int btrfs_replace_extent_map_range(struct btrfs_inode *inode,
 
        return ret;
 }
+
+/*
+ * Split off the first pre bytes from the extent_map at [start, start + len]
+ *
+ * This function is used when an ordered_extent needs to be split.
+ */
+int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre)
+{
+       struct extent_map_tree *em_tree = &inode->extent_tree;
+       struct extent_map *em;
+       struct extent_map *split_pre = NULL;
+       struct extent_map *split_mid = NULL;
+       int ret = 0;
+       unsigned long flags;
+
+       ASSERT(pre != 0);
+       ASSERT(pre < len);
+
+       split_pre = alloc_extent_map();
+       if (!split_pre)
+               return -ENOMEM;
+       split_mid = alloc_extent_map();
+       if (!split_mid) {
+               ret = -ENOMEM;
+               goto out_free_pre;
+       }
+
+       lock_extent(&inode->io_tree, start, start + len - 1, NULL);
+       write_lock(&em_tree->lock);
+       em = lookup_extent_mapping(em_tree, start, len);
+       if (!em) {
+               ret = -EIO;
+               goto out_unlock;
+       }
+
+       ASSERT(em->len == len);
+       ASSERT(!test_bit(EXTENT_FLAG_COMPRESSED, &em->flags));
+       ASSERT(em->block_start < EXTENT_MAP_LAST_BYTE);
+       ASSERT(test_bit(EXTENT_FLAG_PINNED, &em->flags));
+       ASSERT(!test_bit(EXTENT_FLAG_LOGGING, &em->flags));
+       ASSERT(!list_empty(&em->list));
+
+       flags = em->flags;
+       clear_bit(EXTENT_FLAG_PINNED, &em->flags);
+
+       /* First, replace the em with a new extent_map starting from * em->start */
+       split_pre->start = em->start;
+       split_pre->len = pre;
+       split_pre->orig_start = split_pre->start;
+       split_pre->block_start = em->block_start;
+       split_pre->block_len = split_pre->len;
+       split_pre->orig_block_len = split_pre->block_len;
+       split_pre->ram_bytes = split_pre->len;
+       split_pre->flags = flags;
+       split_pre->compress_type = em->compress_type;
+       split_pre->generation = em->generation;
+
+       replace_extent_mapping(em_tree, em, split_pre, 1);
+
+       /*
+        * Now we only have an extent_map at:
+        *     [em->start, em->start + pre]
+        */
+
+       /* Insert the middle extent_map. */
+       split_mid->start = em->start + pre;
+       split_mid->len = em->len - pre;
+       split_mid->orig_start = split_mid->start;
+       split_mid->block_start = em->block_start + pre;
+       split_mid->block_len = split_mid->len;
+       split_mid->orig_block_len = split_mid->block_len;
+       split_mid->ram_bytes = split_mid->len;
+       split_mid->flags = flags;
+       split_mid->compress_type = em->compress_type;
+       split_mid->generation = em->generation;
+       add_extent_mapping(em_tree, split_mid, 1);
+
+       /* Once for us */
+       free_extent_map(em);
+       /* Once for the tree */
+       free_extent_map(em);
+
+out_unlock:
+       write_unlock(&em_tree->lock);
+       unlock_extent(&inode->io_tree, start, start + len - 1, NULL);
+       free_extent_map(split_mid);
+out_free_pre:
+       free_extent_map(split_pre);
+       return ret;
+}

diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index ad31186..7df3911 100644 (file)
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -90,10 +90,7 @@ struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
 int add_extent_mapping(struct extent_map_tree *tree,
                       struct extent_map *em, int modified);
 void remove_extent_mapping(struct extent_map_tree *tree, struct extent_map *em);
-void replace_extent_mapping(struct extent_map_tree *tree,
-                           struct extent_map *cur,
-                           struct extent_map *new,
-                           int modified);
+int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre);
 
 struct extent_map *alloc_extent_map(void);
 void free_extent_map(struct extent_map *em);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 31c5b7c..aba6dba 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2714,96 +2714,6 @@ void btrfs_clear_delalloc_extent(struct btrfs_inode *inode,
        }
 }
 
-/*
- * Split off the first pre bytes from the extent_map at [start, start + len]
- *
- * This function is intended to be used only for extract_ordered_extent().
- */
-static int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre)
-{
-       struct extent_map_tree *em_tree = &inode->extent_tree;
-       struct extent_map *em;
-       struct extent_map *split_pre = NULL;
-       struct extent_map *split_mid = NULL;
-       int ret = 0;
-       unsigned long flags;
-
-       ASSERT(pre != 0);
-       ASSERT(pre < len);
-
-       split_pre = alloc_extent_map();
-       if (!split_pre)
-               return -ENOMEM;
-       split_mid = alloc_extent_map();
-       if (!split_mid) {
-               ret = -ENOMEM;
-               goto out_free_pre;
-       }
-
-       lock_extent(&inode->io_tree, start, start + len - 1, NULL);
-       write_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, start, len);
-       if (!em) {
-               ret = -EIO;
-               goto out_unlock;
-       }
-
-       ASSERT(em->len == len);
-       ASSERT(!test_bit(EXTENT_FLAG_COMPRESSED, &em->flags));
-       ASSERT(em->block_start < EXTENT_MAP_LAST_BYTE);
-       ASSERT(test_bit(EXTENT_FLAG_PINNED, &em->flags));
-       ASSERT(!test_bit(EXTENT_FLAG_LOGGING, &em->flags));
-       ASSERT(!list_empty(&em->list));
-
-       flags = em->flags;
-       clear_bit(EXTENT_FLAG_PINNED, &em->flags);
-
-       /* First, replace the em with a new extent_map starting from * em->start */
-       split_pre->start = em->start;
-       split_pre->len = pre;
-       split_pre->orig_start = split_pre->start;
-       split_pre->block_start = em->block_start;
-       split_pre->block_len = split_pre->len;
-       split_pre->orig_block_len = split_pre->block_len;
-       split_pre->ram_bytes = split_pre->len;
-       split_pre->flags = flags;
-       split_pre->compress_type = em->compress_type;
-       split_pre->generation = em->generation;
-
-       replace_extent_mapping(em_tree, em, split_pre, 1);
-
-       /*
-        * Now we only have an extent_map at:
-        *     [em->start, em->start + pre]
-        */
-
-       /* Insert the middle extent_map. */
-       split_mid->start = em->start + pre;
-       split_mid->len = em->len - pre;
-       split_mid->orig_start = split_mid->start;
-       split_mid->block_start = em->block_start + pre;
-       split_mid->block_len = split_mid->len;
-       split_mid->orig_block_len = split_mid->block_len;
-       split_mid->ram_bytes = split_mid->len;
-       split_mid->flags = flags;
-       split_mid->compress_type = em->compress_type;
-       split_mid->generation = em->generation;
-       add_extent_mapping(em_tree, split_mid, 1);
-
-       /* Once for us */
-       free_extent_map(em);
-       /* Once for the tree */
-       free_extent_map(em);
-
-out_unlock:
-       write_unlock(&em_tree->lock);
-       unlock_extent(&inode->io_tree, start, start + len - 1, NULL);
-       free_extent_map(split_mid);
-out_free_pre:
-       free_extent_map(split_pre);
-       return ret;
-}
-
 int btrfs_extract_ordered_extent(struct btrfs_bio *bbio,
                                 struct btrfs_ordered_extent *ordered)
 {