return 0;
}
-void __free_root_info(struct root_info *ri)
+static void __free_root_info(struct rb_node *node)
{
+ struct root_info *ri;
+
+ ri = rb_entry(node, struct root_info, rb_node);
if (ri->name)
free(ri->name);
free(ri);
}
-void __free_all_subvolumn(struct root_lookup *root_tree)
+static inline void __free_all_subvolumn(struct root_lookup *root_tree)
{
- struct root_info *entry;
- struct rb_node *n;
-
- n = rb_first(&root_tree->root);
- while (n) {
- entry = rb_entry(n, struct root_info, rb_node);
- rb_erase(n, &root_tree->root);
- __free_root_info(entry);
-
- n = rb_first(&root_tree->root);
- }
+ rb_free_nodes(&root_tree->root, __free_root_info);
}
/*
if (ino == BTRFS_FREE_INO_OBJECTID)
rec->found_link = 1;
- ret = insert_existing_cache_extent(inode_cache, &node->cache);
+ ret = insert_cache_extent(inode_cache, &node->cache);
BUG_ON(ret);
}
return rec;
ins->data = rec;
rec->refs++;
}
- ret = insert_existing_cache_extent(dst, &ins->cache);
+ ret = insert_cache_extent(dst, &ins->cache);
if (ret == -EEXIST) {
conflict = get_inode_rec(dst, rec->ino, 1);
merge_inode_recs(rec, conflict, dst);
return 0;
}
-static void free_inode_recs(struct cache_tree *inode_cache)
+static void free_inode_ptr(struct cache_extent *cache)
{
- struct cache_extent *cache;
struct ptr_node *node;
struct inode_record *rec;
- while (1) {
- cache = find_first_cache_extent(inode_cache, 0);
- if (!cache)
- break;
- node = container_of(cache, struct ptr_node, cache);
- rec = node->data;
- remove_cache_extent(inode_cache, &node->cache);
- free(node);
- free_inode_rec(rec);
- }
+ node = container_of(cache, struct ptr_node, cache);
+ rec = node->data;
+ free_inode_rec(rec);
+ free(node);
}
+FREE_EXTENT_CACHE_BASED_TREE(inode_recs, free_inode_ptr);
+
static struct shared_node *find_shared_node(struct cache_tree *shared,
u64 bytenr)
{
cache_tree_init(&node->inode_cache);
node->refs = refs;
- ret = insert_existing_cache_extent(shared, &node->cache);
+ ret = insert_cache_extent(shared, &node->cache);
BUG_ON(ret);
return 0;
}
if (wc->root_level == wc->active_node &&
btrfs_root_refs(&root->root_item) == 0) {
if (--node->refs == 0) {
- free_inode_recs(&node->root_cache);
- free_inode_recs(&node->inode_cache);
+ free_inode_recs_tree(&node->root_cache);
+ free_inode_recs_tree(&node->inode_cache);
remove_cache_extent(&wc->shared, &node->cache);
free(node);
}
rec->cache.start = objectid;
rec->cache.size = 1;
- ret = insert_existing_cache_extent(root_cache, &rec->cache);
+ ret = insert_cache_extent(root_cache, &rec->cache);
BUG_ON(ret);
}
return rec;
return backref;
}
-static void free_root_recs(struct cache_tree *root_cache)
+static void free_root_record(struct cache_extent *cache)
{
- struct cache_extent *cache;
struct root_record *rec;
struct root_backref *backref;
- while (1) {
- cache = find_first_cache_extent(root_cache, 0);
- if (!cache)
- break;
- rec = container_of(cache, struct root_record, cache);
- remove_cache_extent(root_cache, &rec->cache);
-
- while (!list_empty(&rec->backrefs)) {
- backref = list_entry(rec->backrefs.next,
- struct root_backref, list);
- list_del(&backref->list);
- free(backref);
- }
- kfree(rec);
+ rec = container_of(cache, struct root_record, cache);
+ while (!list_empty(&rec->backrefs)) {
+ backref = list_entry(rec->backrefs.next,
+ struct root_backref, list);
+ list_del(&backref->list);
+ free(backref);
}
+
+ kfree(rec);
}
+FREE_EXTENT_CACHE_BASED_TREE(root_recs, free_root_record);
+
static int add_root_backref(struct cache_tree *root_cache,
u64 root_id, u64 ref_root, u64 dir, u64 index,
const char *name, int namelen,
struct inode_backref *backref;
if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
- free_inode_recs(src_cache);
+ free_inode_recs_tree(src_cache);
return 0;
}
ret = check_fs_root(tmp_root, root_cache, &wc);
if (ret)
err = 1;
- btrfs_free_fs_root(root->fs_info, tmp_root);
+ btrfs_free_fs_root(tmp_root);
} else if (key.type == BTRFS_ROOT_REF_KEY ||
key.type == BTRFS_ROOT_BACKREF_KEY) {
process_root_ref(leaf, path.slots[0], &key,
(unsigned long long)rec->start,
back->full_backref ?
"parent" : "root",
- back->full_backref ?
+ back->full_backref ?
(unsigned long long)dback->parent:
(unsigned long long)dback->root,
(unsigned long long)dback->owner,
rec->cache.start = start;
rec->cache.size = nr;
- ret = insert_existing_cache_extent(extent_cache, &rec->cache);
+ ret = insert_cache_extent(extent_cache, &rec->cache);
BUG_ON(ret);
bytes_used += nr;
if (set_checked) {
struct cache_tree *seen, u64 bytenr, u32 size)
{
int ret;
- ret = insert_cache_extent(seen, bytenr, size);
+ ret = add_cache_extent(seen, bytenr, size);
if (ret)
return ret;
- insert_cache_extent(pending, bytenr, size);
+ add_cache_extent(pending, bytenr, size);
return 0;
}
struct cache_extent *cache;
int reada_bits;
- ret = pick_next_pending(pending, reada, nodes, *last, bits,
- bits_nr, &reada_bits);
- if (ret == 0) {
+ nritems = pick_next_pending(pending, reada, nodes, *last, bits,
+ bits_nr, &reada_bits);
+ if (nritems == 0)
return 1;
- }
+
if (!reada_bits) {
- for(i = 0; i < ret; i++) {
- insert_cache_extent(reada, bits[i].start,
- bits[i].size);
+ for(i = 0; i < nritems; i++) {
+ ret = add_cache_extent(reada, bits[i].start,
+ bits[i].size);
+ if (ret == -EEXIST)
+ continue;
/* fixme, get the parent transid */
readahead_tree_block(root, bits[i].start,
ref = btrfs_item_ptr(buf, i,
struct btrfs_shared_data_ref);
add_data_backref(extent_cache,
- key.objectid, key.offset, 0, 0, 0,
+ key.objectid, key.offset, 0, 0, 0,
btrfs_shared_data_ref_count(buf, ref),
0, root->sectorsize);
continue;
remove_cache_extent(extent_cache, &tmp->cache);
free(tmp);
}
- ret = insert_existing_cache_extent(extent_cache, &good->cache);
+ ret = insert_cache_extent(extent_cache, &good->cache);
BUG_ON(ret);
free(rec);
return good->num_duplicates ? 0 : 1;
return 0;
}
-static void free_corrupt_blocks(struct btrfs_fs_info *info)
+static void free_corrupt_block(struct cache_extent *cache)
{
- struct cache_extent *cache;
struct btrfs_corrupt_block *corrupt;
- while (1) {
- cache = find_first_cache_extent(info->corrupt_blocks, 0);
- if (!cache)
- break;
- corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
- remove_cache_extent(info->corrupt_blocks, cache);
- free(corrupt);
- }
+ corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
+ free(corrupt);
}
+FREE_EXTENT_CACHE_BASED_TREE(corrupt_blocks, free_corrupt_block);
+
static int check_block_group(struct btrfs_trans_handle *trans,
struct btrfs_fs_info *info,
struct map_lookup *map,
goto out;
}
- free_corrupt_blocks(root->fs_info);
+ free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
free_cache_tree(&seen);
free_cache_tree(&pending);
free_cache_tree(&reada);
}
out:
if (repair) {
- free_corrupt_blocks(root->fs_info);
+ free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
root->fs_info->fsck_extent_cache = NULL;
root->fs_info->free_extent_hook = NULL;
root->fs_info->corrupt_blocks = NULL;
fprintf(stderr, "checking root refs\n");
ret = check_root_refs(root, &root_cache);
out:
- free_root_recs(&root_cache);
+ free_root_recs_tree(&root_cache);
close_ctree(root);
if (found_old_backref) { /*
}
-int btrfs_free_fs_root(struct btrfs_fs_info *fs_info,
- struct btrfs_root *root)
+int btrfs_free_fs_root(struct btrfs_root *root)
{
if (root->node)
free_extent_buffer(root->node);
return 0;
}
-static int free_fs_roots(struct btrfs_fs_info *fs_info)
+static void __free_fs_root(struct cache_extent *cache)
{
- struct cache_extent *cache;
struct btrfs_root *root;
- while (1) {
- cache = find_first_cache_extent(&fs_info->fs_root_cache, 0);
- if (!cache)
- break;
- root = container_of(cache, struct btrfs_root, cache);
- remove_cache_extent(&fs_info->fs_root_cache, cache);
- btrfs_free_fs_root(fs_info, root);
- }
- return 0;
+ root = container_of(cache, struct btrfs_root, cache);
+ btrfs_free_fs_root(root);
}
+FREE_EXTENT_CACHE_BASED_TREE(fs_roots, __free_fs_root);
+
struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info,
struct btrfs_key *location)
{
root->cache.start = location->objectid;
root->cache.size = 1;
- ret = insert_existing_cache_extent(&fs_info->fs_root_cache,
- &root->cache);
+ ret = insert_cache_extent(&fs_info->fs_root_cache, &root->cache);
BUG_ON(ret);
return root;
}
free_extent_buffer(fs_info->chunk_root->node);
}
-static void free_mapping_cache(struct btrfs_fs_info *fs_info)
+static void free_map_lookup(struct cache_extent *ce)
{
- struct cache_tree *cache_tree = &fs_info->mapping_tree.cache_tree;
- struct cache_extent *ce;
struct map_lookup *map;
- while ((ce = find_first_cache_extent(cache_tree, 0))) {
- map = container_of(ce, struct map_lookup, ce);
- remove_cache_extent(cache_tree, ce);
- kfree(map);
- }
+ map = container_of(ce, struct map_lookup, ce);
+ kfree(map);
}
+FREE_EXTENT_CACHE_BASED_TREE(mapping_cache, free_map_lookup);
+
void btrfs_cleanup_all_caches(struct btrfs_fs_info *fs_info)
{
- free_mapping_cache(fs_info);
+ free_mapping_cache_tree(&fs_info->mapping_tree.cache_tree);
extent_io_tree_cleanup(&fs_info->extent_cache);
extent_io_tree_cleanup(&fs_info->free_space_cache);
extent_io_tree_cleanup(&fs_info->block_group_cache);
}
btrfs_free_block_groups(fs_info);
- free_fs_roots(fs_info);
+ free_fs_roots_tree(&fs_info->fs_root_cache);
btrfs_release_all_roots(fs_info);
btrfs_close_devices(fs_info->fs_devices);
struct btrfs_key *location);
struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info,
struct btrfs_key *location);
-int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root);
+int btrfs_free_fs_root(struct btrfs_root *root);
void btrfs_mark_buffer_dirty(struct extent_buffer *buf);
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid);
int btrfs_set_buffer_uptodate(struct extent_buffer *buf);
#include "kerncompat.h"
#include "extent-cache.h"
+struct cache_extent_search_range {
+ u64 start;
+ u64 size;
+};
+
void cache_tree_init(struct cache_tree *tree)
{
- tree->root.rb_node = NULL;
+ tree->root = RB_ROOT;
}
-static struct rb_node *tree_insert(struct rb_root *root, u64 offset,
- u64 size, struct rb_node *node)
+static int cache_tree_comp_range(struct rb_node *node, void *data)
{
- struct rb_node ** p = &root->rb_node;
- struct rb_node * parent = NULL;
struct cache_extent *entry;
+ struct cache_extent_search_range *range;
- while(*p) {
- parent = *p;
- entry = rb_entry(parent, struct cache_extent, rb_node);
-
- if (offset + size <= entry->start)
- p = &(*p)->rb_left;
- else if (offset >= entry->start + entry->size)
- p = &(*p)->rb_right;
- else
- return parent;
- }
+ range = (struct cache_extent_search_range *)data;
+ entry = rb_entry(node, struct cache_extent, rb_node);
- entry = rb_entry(parent, struct cache_extent, rb_node);
- rb_link_node(node, parent, p);
- rb_insert_color(node, root);
- return NULL;
+ if (entry->start + entry->size <= range->start)
+ return 1;
+ else if (range->start + range->size <= entry->start)
+ return -1;
+ else
+ return 0;
}
-static struct rb_node *__tree_search(struct rb_root *root, u64 offset,
- u64 size, struct rb_node **prev_ret)
+static int cache_tree_comp_nodes(struct rb_node *node1, struct rb_node *node2)
{
- struct rb_node * n = root->rb_node;
- struct rb_node *prev = NULL;
struct cache_extent *entry;
- struct cache_extent *prev_entry = NULL;
-
- while(n) {
- entry = rb_entry(n, struct cache_extent, rb_node);
- prev = n;
- prev_entry = entry;
-
- if (offset + size <= entry->start)
- n = n->rb_left;
- else if (offset >= entry->start + entry->size)
- n = n->rb_right;
- else
- return n;
- }
- if (!prev_ret)
- return NULL;
+ struct cache_extent_search_range range;
- while(prev && offset >= prev_entry->start + prev_entry->size) {
- prev = rb_next(prev);
- prev_entry = rb_entry(prev, struct cache_extent, rb_node);
- }
- *prev_ret = prev;
- return NULL;
+ entry = rb_entry(node2, struct cache_extent, rb_node);
+ range.start = entry->start;
+ range.size = entry->size;
+
+ return cache_tree_comp_range(node1, (void *)&range);
}
struct cache_extent *alloc_cache_extent(u64 start, u64 size)
if (!pe)
return pe;
+
pe->start = start;
pe->size = size;
return pe;
}
-int insert_existing_cache_extent(struct cache_tree *tree,
- struct cache_extent *pe)
+int insert_cache_extent(struct cache_tree *tree, struct cache_extent *pe)
{
- struct rb_node *found;
-
- found = tree_insert(&tree->root, pe->start, pe->size, &pe->rb_node);
- if (found)
- return -EEXIST;
-
- return 0;
+ return rb_insert(&tree->root, &pe->rb_node, cache_tree_comp_nodes);
}
-int insert_cache_extent(struct cache_tree *tree, u64 start, u64 size)
+int add_cache_extent(struct cache_tree *tree, u64 start, u64 size)
{
struct cache_extent *pe = alloc_cache_extent(start, size);
int ret;
- ret = insert_existing_cache_extent(tree, pe);
+
+ if (!pe) {
+ fprintf(stderr, "memory allocation failed\n");
+ exit(1);
+ }
+
+ ret = insert_cache_extent(tree, pe);
if (ret)
free(pe);
+
return ret;
}
struct cache_extent *find_cache_extent(struct cache_tree *tree,
- u64 start, u64 size)
+ u64 start, u64 size)
{
- struct rb_node *prev;
- struct rb_node *ret;
+ struct rb_node *node;
struct cache_extent *entry;
- ret = __tree_search(&tree->root, start, size, &prev);
- if (!ret)
+ struct cache_extent_search_range range;
+
+ range.start = start;
+ range.size = size;
+ node = rb_search(&tree->root, &range, cache_tree_comp_range, NULL);
+ if (!node)
return NULL;
- entry = rb_entry(ret, struct cache_extent, rb_node);
+ entry = rb_entry(node, struct cache_extent, rb_node);
return entry;
}
-struct cache_extent *find_first_cache_extent(struct cache_tree *tree,
- u64 start)
+struct cache_extent *find_first_cache_extent(struct cache_tree *tree, u64 start)
{
- struct rb_node *prev;
- struct rb_node *ret;
+ struct rb_node *next;
+ struct rb_node *node;
struct cache_extent *entry;
+ struct cache_extent_search_range range;
- ret = __tree_search(&tree->root, start, 1, &prev);
- if (!ret)
- ret = prev;
- if (!ret)
+ range.start = start;
+ range.size = 1;
+ node = rb_search(&tree->root, &range, cache_tree_comp_range, &next);
+ if (!node)
+ node = next;
+ if (!node)
return NULL;
- entry = rb_entry(ret, struct cache_extent, rb_node);
+
+ entry = rb_entry(node, struct cache_extent, rb_node);
return entry;
}
+struct cache_extent *first_cache_extent(struct cache_tree *tree)
+{
+ struct rb_node *node = rb_first(&tree->root);
+
+ if (!node)
+ return NULL;
+ return rb_entry(node, struct cache_extent, rb_node);
+}
+
struct cache_extent *prev_cache_extent(struct cache_extent *pe)
{
struct rb_node *node = rb_prev(&pe->rb_node);
return rb_entry(node, struct cache_extent, rb_node);
}
-void remove_cache_extent(struct cache_tree *tree,
- struct cache_extent *pe)
+void remove_cache_extent(struct cache_tree *tree, struct cache_extent *pe)
{
rb_erase(&pe->rb_node, &tree->root);
}
+void cache_tree_free_extents(struct cache_tree *tree,
+ free_cache_extent free_func)
+{
+ struct cache_extent *ce;
+
+ while ((ce = first_cache_extent(tree))) {
+ remove_cache_extent(tree, ce);
+ free_func(ce);
+ }
+}
* Boston, MA 021110-1307, USA.
*/
-#ifndef __PENDING_EXTENT__
-#define __PENDING_EXTENT__
+#ifndef __EXTENT_CACHE_H__
+#define __EXTENT_CACHE_H__
#if BTRFS_FLAT_INCLUDES
#include "kerncompat.h"
};
void cache_tree_init(struct cache_tree *tree);
-void remove_cache_extent(struct cache_tree *tree,
- struct cache_extent *pe);
-struct cache_extent *find_first_cache_extent(struct cache_tree *tree,
- u64 start);
+
+struct cache_extent *first_cache_extent(struct cache_tree *tree);
struct cache_extent *prev_cache_extent(struct cache_extent *pe);
struct cache_extent *next_cache_extent(struct cache_extent *pe);
+
+struct cache_extent *find_first_cache_extent(struct cache_tree *tree,
+ u64 start);
struct cache_extent *find_cache_extent(struct cache_tree *tree,
- u64 start, u64 size);
-int insert_cache_extent(struct cache_tree *tree, u64 start, u64 size);
-int insert_existing_cache_extent(struct cache_tree *tree,
- struct cache_extent *pe);
+ u64 start, u64 size);
+
+int add_cache_extent(struct cache_tree *tree, u64 start, u64 size);
+int insert_cache_extent(struct cache_tree *tree, struct cache_extent *pe);
+void remove_cache_extent(struct cache_tree *tree, struct cache_extent *pe);
static inline int cache_tree_empty(struct cache_tree *tree)
{
return RB_EMPTY_ROOT(&tree->root);
}
-static inline void free_cache_extent(struct cache_extent *pe)
-{
- free(pe);
-}
+typedef void (*free_cache_extent)(struct cache_extent *pe);
-struct cache_extent *alloc_pending_extent(u64 start, u64 size);
+void cache_tree_free_extents(struct cache_tree *tree,
+ free_cache_extent free_func);
+
+#define FREE_EXTENT_CACHE_BASED_TREE(name, free_func) \
+static void free_##name##_tree(struct cache_tree *tree) \
+{ \
+ cache_tree_free_extents(tree, free_func); \
+}
#endif
return state;
}
-static void free_extent_state(struct extent_state *state)
+static void btrfs_free_extent_state(struct extent_state *state)
{
state->refs--;
BUG_ON(state->refs < 0);
free(state);
}
-void extent_io_tree_cleanup(struct extent_io_tree *tree)
+static void free_extent_state_func(struct cache_extent *cache)
{
struct extent_state *es;
+
+ es = container_of(cache, struct extent_state, cache_node);
+ btrfs_free_extent_state(es);
+}
+
+void extent_io_tree_cleanup(struct extent_io_tree *tree)
+{
struct extent_buffer *eb;
- struct cache_extent *cache;
while(!list_empty(&tree->lru)) {
eb = list_entry(tree->lru.next, struct extent_buffer, lru);
}
free_extent_buffer(eb);
}
- while (1) {
- cache = find_first_cache_extent(&tree->state, 0);
- if (!cache)
- break;
- es = container_of(cache, struct extent_state, cache_node);
- remove_cache_extent(&tree->state, &es->cache_node);
- free_extent_state(es);
- }
+
+ cache_tree_free_extents(&tree->state, free_extent_state_func);
}
static inline void update_extent_state(struct extent_state *state)
state->start = other->start;
update_extent_state(state);
remove_cache_extent(&tree->state, &other->cache_node);
- free_extent_state(other);
+ btrfs_free_extent_state(other);
}
}
other_node = next_cache_extent(&state->cache_node);
other->start = state->start;
update_extent_state(other);
remove_cache_extent(&tree->state, &state->cache_node);
- free_extent_state(state);
+ btrfs_free_extent_state(state);
}
}
return 0;
state->start = start;
state->end = end;
update_extent_state(state);
- ret = insert_existing_cache_extent(&tree->state, &state->cache_node);
+ ret = insert_cache_extent(&tree->state, &state->cache_node);
BUG_ON(ret);
merge_state(tree, state);
return 0;
update_extent_state(prealloc);
orig->start = split;
update_extent_state(orig);
- ret = insert_existing_cache_extent(&tree->state,
- &prealloc->cache_node);
+ ret = insert_cache_extent(&tree->state, &prealloc->cache_node);
BUG_ON(ret);
return 0;
}
state->state &= ~bits;
if (state->state == 0) {
remove_cache_extent(&tree->state, &state->cache_node);
- free_extent_state(state);
+ btrfs_free_extent_state(state);
} else {
merge_state(tree, state);
}
goto search_again;
out:
if (prealloc)
- free_extent_state(prealloc);
+ btrfs_free_extent_state(prealloc);
return set;
search_again:
prealloc = NULL;
out:
if (prealloc)
- free_extent_state(prealloc);
+ btrfs_free_extent_state(prealloc);
return err;
search_again:
if (start > end)
eb->cache_node.size = blocksize;
free_some_buffers(tree);
- ret = insert_existing_cache_extent(&tree->cache, &eb->cache_node);
+ ret = insert_cache_extent(&tree->cache, &eb->cache_node);
if (ret) {
free(eb);
return NULL;
struct cache_extent *cache;
cache = find_cache_extent(&tree->cache, bytenr, blocksize);
- if (cache && cache->start == bytenr && cache->size == blocksize) {
+ if (cache && cache->start == bytenr &&
+ cache->size == blocksize) {
eb = container_of(cache, struct extent_buffer, cache_node);
list_move_tail(&eb->lru, &tree->lru);
eb->refs++;
struct cache_extent *cache;
cache = find_cache_extent(&tree->cache, bytenr, blocksize);
- if (cache && cache->start == bytenr && cache->size == blocksize) {
+ if (cache && cache->start == bytenr &&
+ cache->size == blocksize) {
eb = container_of(cache, struct extent_buffer, cache_node);
list_move_tail(&eb->lru, &tree->lru);
eb->refs++;
/* Copy the pointers/colour from the victim to the replacement */
*new = *victim;
}
+
+int rb_insert(struct rb_root *root, struct rb_node *node,
+ rb_compare_nodes comp)
+{
+ struct rb_node **p = &root->rb_node;
+ struct rb_node *parent = NULL;
+ int ret;
+
+ while(*p) {
+ parent = *p;
+
+ ret = comp(parent, node);
+ if (ret < 0)
+ p = &(*p)->rb_left;
+ else if (ret > 0)
+ p = &(*p)->rb_right;
+ else
+ return -EEXIST;
+ }
+
+ rb_link_node(node, parent, p);
+ rb_insert_color(node, root);
+ return 0;
+}
+
+struct rb_node *rb_search(struct rb_root *root, void *key, rb_compare_keys comp,
+ struct rb_node **next_ret)
+{
+ struct rb_node *n = root->rb_node;
+ struct rb_node *parent = NULL;
+ int ret = 0;
+
+ while(n) {
+ parent = n;
+
+ ret = comp(n, key);
+ if (ret < 0)
+ n = n->rb_left;
+ else if (ret > 0)
+ n = n->rb_right;
+ else
+ return n;
+ }
+
+ if (!next_ret)
+ return NULL;
+
+ if (parent && ret > 0)
+ parent = rb_next(parent);
+
+ *next_ret = parent;
+ return NULL;
+}
+
+void rb_free_nodes(struct rb_root *root, rb_free_node free_node)
+{
+ struct rb_node *node;
+
+ while ((node = rb_first(root))) {
+ rb_erase(node, root);
+ free_node(node);
+ }
+}
struct rb_root
{
struct rb_node *rb_node;
- void (*rotate_notify)(struct rb_node *old_parent, struct rb_node *node);
-
};
-
#define rb_parent(r) ((struct rb_node *)((r)->rb_parent_color & ~3))
#define rb_color(r) ((r)->rb_parent_color & 1)
#define rb_is_red(r) (!rb_color(r))
*rb_link = node;
}
+/* The common insert/search/free functions */
+typedef int (*rb_compare_nodes)(struct rb_node *node1, struct rb_node *node2);
+typedef int (*rb_compare_keys)(struct rb_node *node, void *key);
+typedef void (*rb_free_node)(struct rb_node *node);
+
+int rb_insert(struct rb_root *root, struct rb_node *node,
+ rb_compare_nodes comp);
+/*
+ * In some cases, we need return the next node if we don't find the node we
+ * specify. At this time, we can use next_ret.
+ */
+struct rb_node *rb_search(struct rb_root *root, void *key, rb_compare_keys comp,
+ struct rb_node **next_ret);
+void rb_free_nodes(struct rb_root *root, rb_free_node free_node);
+
+#define FREE_RB_BASED_TREE(name, free_func) \
+static void free_##name##_tree(struct rb_root *root) \
+{ \
+ rb_free_nodes(root, free_func); \
+}
+
#endif /* _LINUX_RBTREE_H */
corrupt->cache.size = len;
corrupt->level = level;
- ret = insert_existing_cache_extent(info->corrupt_blocks, &corrupt->cache);
+ ret = insert_cache_extent(info->corrupt_blocks, &corrupt->cache);
if (ret)
free(corrupt);
BUG_ON(ret && ret != -EEXIST);
{
u64 dev_offset;
struct btrfs_fs_info *info = extent_root->fs_info;
- struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
+ struct btrfs_root *chunk_root = info->chunk_root;
struct btrfs_stripe *stripes;
struct btrfs_device *device = NULL;
struct btrfs_chunk *chunk;
struct list_head private_devs;
- struct list_head *dev_list = &extent_root->fs_info->fs_devices->devices;
+ struct list_head *dev_list = &info->fs_devices->devices;
struct list_head *cur;
struct map_lookup *map;
int min_stripe_size = 1 * 1024 * 1024;
map->ce.start = key.offset;
map->ce.size = *num_bytes;
- ret = insert_existing_cache_extent(
- &extent_root->fs_info->mapping_tree.cache_tree,
- &map->ce);
+ ret = insert_cache_extent(&info->mapping_tree.cache_tree, &map->ce);
BUG_ON(ret);
if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
{
u64 dev_offset;
struct btrfs_fs_info *info = extent_root->fs_info;
- struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
+ struct btrfs_root *chunk_root = info->chunk_root;
struct btrfs_stripe *stripes;
struct btrfs_device *device = NULL;
struct btrfs_chunk *chunk;
- struct list_head *dev_list = &extent_root->fs_info->fs_devices->devices;
+ struct list_head *dev_list = &info->fs_devices->devices;
struct list_head *cur;
struct map_lookup *map;
u64 calc_size = 8 * 1024 * 1024;
map->ce.start = key.offset;
map->ce.size = num_bytes;
- ret = insert_existing_cache_extent(
- &extent_root->fs_info->mapping_tree.cache_tree,
- &map->ce);
+ ret = insert_cache_extent(&info->mapping_tree.cache_tree, &map->ce);
BUG_ON(ret);
kfree(chunk);
map->stripes[i].dev = device;
i++;
}
- ret = insert_existing_cache_extent(&map_tree->cache_tree, &map->ce);
+ ret = insert_cache_extent(&map_tree->cache_tree, &map->ce);
if (ret == -EEXIST) {
struct cache_extent *old;
struct map_lookup *old_map;
old_map = container_of(old, struct map_lookup, ce);
remove_cache_extent(&map_tree->cache_tree, old);
kfree(old_map);
- ret = insert_existing_cache_extent(&map_tree->cache_tree,
+ ret = insert_cache_extent(&map_tree->cache_tree,
&map->ce);
}
BUG_ON(ret);
}
}
- ret = insert_existing_cache_extent(&map_tree->cache_tree, &map->ce);
+ ret = insert_cache_extent(&map_tree->cache_tree, &map->ce);
BUG_ON(ret);
return 0;
projects / platform / upstream / btrfs-progs.git / commitdiff