arm64: dts: rockchip: rk3399: add discrete vr support for box hardware

[firefly-linux-kernel-4.4.55.git] / fs / btrfs / extent_map.c

diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 0a3809500599e8cd71671ab46ca2f0f5e06c0eaa..6a98bddd8f33a96e82d0fe856763e53b67e9b064 100644 (file)
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -51,7 +51,7 @@ struct extent_map *alloc_extent_map(void)
        em = kmem_cache_zalloc(extent_map_cache, GFP_NOFS);
        if (!em)
                return NULL;
-       em->in_tree = 0;
+       RB_CLEAR_NODE(&em->rb_node);
        em->flags = 0;
        em->compress_type = BTRFS_COMPRESS_NONE;
        em->generation = 0;
@@ -73,38 +73,64 @@ void free_extent_map(struct extent_map *em)
                return;
        WARN_ON(atomic_read(&em->refs) == 0);
        if (atomic_dec_and_test(&em->refs)) {
-               WARN_ON(em->in_tree);
+               WARN_ON(extent_map_in_tree(em));
                WARN_ON(!list_empty(&em->list));
+               if (test_bit(EXTENT_FLAG_FS_MAPPING, &em->flags))
+                       kfree(em->bdev);
                kmem_cache_free(extent_map_cache, em);
        }
 }
 
-static struct rb_node *tree_insert(struct rb_root *root, u64 offset,
-                                  struct rb_node *node)
+/* simple helper to do math around the end of an extent, handling wrap */
+static u64 range_end(u64 start, u64 len)
+{
+       if (start + len < start)
+               return (u64)-1;
+       return start + len;
+}
+
+static int tree_insert(struct rb_root *root, struct extent_map *em)
 {
        struct rb_node **p = &root->rb_node;
        struct rb_node *parent = NULL;
-       struct extent_map *entry;
+       struct extent_map *entry = NULL;
+       struct rb_node *orig_parent = NULL;
+       u64 end = range_end(em->start, em->len);
 
        while (*p) {
                parent = *p;
                entry = rb_entry(parent, struct extent_map, rb_node);
 
-               WARN_ON(!entry->in_tree);
-
-               if (offset < entry->start)
+               if (em->start < entry->start)
                        p = &(*p)->rb_left;
-               else if (offset >= extent_map_end(entry))
+               else if (em->start >= extent_map_end(entry))
                        p = &(*p)->rb_right;
                else
-                       return parent;
+                       return -EEXIST;
        }
 
-       entry = rb_entry(node, struct extent_map, rb_node);
-       entry->in_tree = 1;
-       rb_link_node(node, parent, p);
-       rb_insert_color(node, root);
-       return NULL;
+       orig_parent = parent;
+       while (parent && em->start >= extent_map_end(entry)) {
+               parent = rb_next(parent);
+               entry = rb_entry(parent, struct extent_map, rb_node);
+       }
+       if (parent)
+               if (end > entry->start && em->start < extent_map_end(entry))
+                       return -EEXIST;
+
+       parent = orig_parent;
+       entry = rb_entry(parent, struct extent_map, rb_node);
+       while (parent && em->start < entry->start) {
+               parent = rb_prev(parent);
+               entry = rb_entry(parent, struct extent_map, rb_node);
+       }
+       if (parent)
+               if (end > entry->start && em->start < extent_map_end(entry))
+                       return -EEXIST;
+
+       rb_link_node(&em->rb_node, orig_parent, p);
+       rb_insert_color(&em->rb_node, root);
+       return 0;
 }
 
 /*
@@ -126,8 +152,6 @@ static struct rb_node *__tree_search(struct rb_root *root, u64 offset,
                prev = n;
                prev_entry = entry;
 
-               WARN_ON(!entry->in_tree);
-
                if (offset < entry->start)
                        n = n->rb_left;
                else if (offset >= extent_map_end(entry))
@@ -213,12 +237,12 @@ static void try_merge_map(struct extent_map_tree *tree, struct extent_map *em)
                        em->len += merge->len;
                        em->block_len += merge->block_len;
                        em->block_start = merge->block_start;
-                       merge->in_tree = 0;
                        em->mod_len = (em->mod_len + em->mod_start) - merge->mod_start;
                        em->mod_start = merge->mod_start;
                        em->generation = max(em->generation, merge->generation);
 
                        rb_erase(&merge->rb_node, &tree->map);
+                       RB_CLEAR_NODE(&merge->rb_node);
                        free_extent_map(merge);
                }
        }
@@ -228,9 +252,9 @@ static void try_merge_map(struct extent_map_tree *tree, struct extent_map *em)
                merge = rb_entry(rb, struct extent_map, rb_node);
        if (rb && mergable_maps(em, merge)) {
                em->len += merge->len;
-               em->block_len += merge->len;
+               em->block_len += merge->block_len;
                rb_erase(&merge->rb_node, &tree->map);
-               merge->in_tree = 0;
+               RB_CLEAR_NODE(&merge->rb_node);
                em->mod_len = (merge->mod_start + merge->mod_len) - em->mod_start;
                em->generation = max(em->generation, merge->generation);
                free_extent_map(merge);
@@ -290,7 +314,21 @@ out:
 void clear_em_logging(struct extent_map_tree *tree, struct extent_map *em)
 {
        clear_bit(EXTENT_FLAG_LOGGING, &em->flags);
-       if (em->in_tree)
+       if (extent_map_in_tree(em))
+               try_merge_map(tree, em);
+}
+
+static inline void setup_extent_mapping(struct extent_map_tree *tree,
+                                       struct extent_map *em,
+                                       int modified)
+{
+       atomic_inc(&em->refs);
+       em->mod_start = em->start;
+       em->mod_len = em->len;
+
+       if (modified)
+               list_move(&em->list, &tree->modified_extents);
+       else
                try_merge_map(tree, em);
 }
 
@@ -308,41 +346,16 @@ int add_extent_mapping(struct extent_map_tree *tree,
                       struct extent_map *em, int modified)
 {
        int ret = 0;
-       struct rb_node *rb;
-       struct extent_map *exist;
 
-       exist = lookup_extent_mapping(tree, em->start, em->len);
-       if (exist) {
-               free_extent_map(exist);
-               ret = -EEXIST;
-               goto out;
-       }
-       rb = tree_insert(&tree->map, em->start, &em->rb_node);
-       if (rb) {
-               ret = -EEXIST;
+       ret = tree_insert(&tree->map, em);
+       if (ret)
                goto out;
-       }
-       atomic_inc(&em->refs);
 
-       em->mod_start = em->start;
-       em->mod_len = em->len;
-
-       if (modified)
-               list_move(&em->list, &tree->modified_extents);
-       else
-               try_merge_map(tree, em);
+       setup_extent_mapping(tree, em, modified);
 out:
        return ret;
 }
 
-/* simple helper to do math around the end of an extent, handling wrap */
-static u64 range_end(u64 start, u64 len)
-{
-       if (start + len < start)
-               return (u64)-1;
-       return start + len;
-}
-
 static struct extent_map *
 __lookup_extent_mapping(struct extent_map_tree *tree,
                        u64 start, u64 len, int strict)
@@ -422,6 +435,21 @@ int remove_extent_mapping(struct extent_map_tree *tree, struct extent_map *em)
        rb_erase(&em->rb_node, &tree->map);
        if (!test_bit(EXTENT_FLAG_LOGGING, &em->flags))
                list_del_init(&em->list);
-       em->in_tree = 0;
+       RB_CLEAR_NODE(&em->rb_node);
        return ret;
 }
+
+void replace_extent_mapping(struct extent_map_tree *tree,
+                           struct extent_map *cur,
+                           struct extent_map *new,
+                           int modified)
+{
+       WARN_ON(test_bit(EXTENT_FLAG_PINNED, &cur->flags));
+       ASSERT(extent_map_in_tree(cur));
+       if (!test_bit(EXTENT_FLAG_LOGGING, &cur->flags))
+               list_del_init(&cur->list);
+       rb_replace_node(&cur->rb_node, &new->rb_node, &tree->map);
+       RB_CLEAR_NODE(&cur->rb_node);
+
+       setup_extent_mapping(tree, new, modified);
+}