Skip to content

Commit

Permalink
Btrfs: Add delayed allocation to the extent based page tree code
Browse files Browse the repository at this point in the history 
Signed-off-by: Chris Mason <chris.mason@oracle.com>
  • Loading branch information
Chris Mason authored and David Woodhouse committed Aug 27, 2007
1 parent a52d9a8 commit b888db2
Show file tree
Hide file tree
Showing 6 changed files with 216 additions and 135 deletions.
9 changes: 0 additions & 9 deletions fs/btrfs/extent-tree.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,7 +39,6 @@ static int cache_block_group(struct btrfs_root *root,
u64 i;
u64 last = 0;
u64 hole_size;
u64 limit;
int found = 0;

root = root->fs_info->extent_root;
Expand All @@ -62,7 +61,6 @@ static int cache_block_group(struct btrfs_root *root,
return ret;
if (ret && path->slots[0] > 0)
path->slots[0]--;
limit = block_group->key.objectid + block_group->key.offset;
while(1) {
leaf = btrfs_buffer_leaf(path->nodes[0]);
slot = path->slots[0];
Expand Down Expand Up @@ -982,7 +980,6 @@ static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
struct btrfs_block_group_cache *block_group;
int full_scan = 0;
int wrapped = 0;
u64 limit;

WARN_ON(num_blocks < 1);
ins->flags = 0;
Expand Down Expand Up @@ -1049,12 +1046,6 @@ static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
l = btrfs_buffer_leaf(path->nodes[0]);
slot = path->slots[0];
if (slot >= btrfs_header_nritems(&l->header)) {
if (start_found)
limit = last_block +
(block_group->key.offset >> 1);
else
limit = search_start +
(block_group->key.offset >> 1);
ret = btrfs_next_leaf(root, path);
if (ret == 0)
continue;
Expand Down
147 changes: 112 additions & 35 deletions fs/btrfs/extent_map.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,9 +30,6 @@ struct tree_entry {

#define EXTENT_IOBITS (EXTENT_LOCKED | EXTENT_WRITEBACK)

static LIST_HEAD(all_states);
spinlock_t state_lock = SPIN_LOCK_UNLOCKED;

void __init extent_map_init(void)
{
extent_map_cache = kmem_cache_create("extent_map",
Expand All @@ -49,15 +46,6 @@ void __init extent_map_init(void)

void __exit extent_map_exit(void)
{
while(!list_empty(&all_states)) {
struct extent_state *state;
struct list_head *cur = all_states.next;
state = list_entry(cur, struct extent_state, list);
printk("found leaked state %Lu %Lu state %d in_tree %d\n",
state->start, state->end, state->state, state->in_tree);
list_del(&state->list);
kfree(state);
}
if (extent_map_cache)
kmem_cache_destroy(extent_map_cache);
if (extent_state_cache)
Expand All @@ -69,6 +57,7 @@ void extent_map_tree_init(struct extent_map_tree *tree,
{
tree->map.rb_node = NULL;
tree->state.rb_node = NULL;
tree->fill_delalloc = NULL;
rwlock_init(&tree->lock);
tree->mapping = mapping;
}
Expand Down Expand Up @@ -106,9 +95,6 @@ struct extent_state *alloc_extent_state(gfp_t mask)
state->in_tree = 0;
atomic_set(&state->refs, 1);
init_waitqueue_head(&state->wq);
spin_lock_irq(&state_lock);
list_add(&state->list, &all_states);
spin_unlock_irq(&state_lock);
return state;
}
EXPORT_SYMBOL(alloc_extent_state);
Expand All @@ -117,9 +103,6 @@ void free_extent_state(struct extent_state *state)
{
if (atomic_dec_and_test(&state->refs)) {
WARN_ON(state->in_tree);
spin_lock_irq(&state_lock);
list_del_init(&state->list);
spin_unlock_irq(&state_lock);
kmem_cache_free(extent_state_cache, state);
}
}
Expand Down Expand Up @@ -369,7 +352,7 @@ static int insert_state(struct extent_map_tree *tree,
if (node) {
struct extent_state *found;
found = rb_entry(node, struct extent_state, rb_node);
printk("found node %Lu %Lu on insert of %Lu %Lu\n", found->start, found->end, start, end);
printk("found node %Lu %Lu on insert of %Lu %Lu\n", found->start, found->end, start, end);
free_extent_state(state);
return -EEXIST;
}
Expand Down Expand Up @@ -408,7 +391,7 @@ static int split_state(struct extent_map_tree *tree, struct extent_state *orig,
if (node) {
struct extent_state *found;
found = rb_entry(node, struct extent_state, rb_node);
printk("found node %Lu %Lu on insert of %Lu %Lu\n", found->start, found->end, prealloc->start, prealloc->end);
printk("found node %Lu %Lu on insert of %Lu %Lu\n", found->start, found->end, prealloc->start, prealloc->end);
free_extent_state(prealloc);
return -EEXIST;
}
Expand Down Expand Up @@ -792,10 +775,20 @@ int set_extent_dirty(struct extent_map_tree *tree, u64 start, u64 end,
}
EXPORT_SYMBOL(set_extent_dirty);

int set_extent_delalloc(struct extent_map_tree *tree, u64 start, u64 end,
gfp_t mask)
{
return set_extent_bit(tree, start, end,
EXTENT_DELALLOC | EXTENT_DIRTY, 0, NULL,
mask);
}
EXPORT_SYMBOL(set_extent_delalloc);

int clear_extent_dirty(struct extent_map_tree *tree, u64 start, u64 end,
gfp_t mask)
{
return clear_extent_bit(tree, start, end, EXTENT_DIRTY, 0, 0, mask);
return clear_extent_bit(tree, start, end,
EXTENT_DIRTY | EXTENT_DELALLOC, 0, 0, mask);
}
EXPORT_SYMBOL(clear_extent_dirty);

Expand Down Expand Up @@ -922,6 +915,62 @@ int set_range_writeback(struct extent_map_tree *tree, u64 start, u64 end)
}
EXPORT_SYMBOL(set_range_writeback);

u64 find_lock_delalloc_range(struct extent_map_tree *tree,
u64 start, u64 lock_start, u64 *end, u64 max_bytes)
{
struct rb_node *node;
struct extent_state *state;
u64 cur_start = start;
u64 found = 0;
u64 total_bytes = 0;

write_lock_irq(&tree->lock);
/*
* this search will find all the extents that end after
* our range starts.
*/
search_again:
node = tree_search(&tree->state, cur_start);
if (!node || IS_ERR(node)) {
goto out;
}

while(1) {
state = rb_entry(node, struct extent_state, rb_node);
if (state->start != cur_start) {
goto out;
}
if (!(state->state & EXTENT_DELALLOC)) {
goto out;
}
if (state->start >= lock_start) {
if (state->state & EXTENT_LOCKED) {
DEFINE_WAIT(wait);
atomic_inc(&state->refs);
write_unlock_irq(&tree->lock);
schedule();
write_lock_irq(&tree->lock);
finish_wait(&state->wq, &wait);
free_extent_state(state);
goto search_again;
}
state->state |= EXTENT_LOCKED;
}
found++;
*end = state->end;
cur_start = state->end + 1;
node = rb_next(node);
if (!node)
break;
total_bytes = state->end - state->start + 1;
if (total_bytes >= max_bytes)
break;
}
out:
write_unlock_irq(&tree->lock);
return found;
}

/*
* helper function to lock both pages and extents in the tree.
* pages must be locked first.
Expand Down Expand Up @@ -1285,6 +1334,7 @@ int extent_read_full_page(struct extent_map_tree *tree, struct page *page,
if (!PagePrivate(page)) {
SetPagePrivate(page);
set_page_private(page, 1);
WARN_ON(!page->mapping->a_ops->invalidatepage);
page_cache_get(page);
}

Expand Down Expand Up @@ -1384,7 +1434,10 @@ int extent_write_full_page(struct extent_map_tree *tree, struct page *page,
size_t blocksize;
loff_t i_size = i_size_read(inode);
unsigned long end_index = i_size >> PAGE_CACHE_SHIFT;
u64 nr_delalloc;
u64 delalloc_end;

WARN_ON(!PageLocked(page));
if (page->index > end_index) {
clear_extent_dirty(tree, start, page_end, GFP_NOFS);
unlock_page(page);
Expand All @@ -1400,11 +1453,34 @@ int extent_write_full_page(struct extent_map_tree *tree, struct page *page,
if (!PagePrivate(page)) {
SetPagePrivate(page);
set_page_private(page, 1);
WARN_ON(!page->mapping->a_ops->invalidatepage);
page_cache_get(page);
}

end = page_end;
lock_extent(tree, start, page_end, GFP_NOFS);
nr_delalloc = find_lock_delalloc_range(tree, start, page_end + 1,
&delalloc_end,
128 * 1024 * 1024);
if (nr_delalloc) {
tree->fill_delalloc(inode, start, delalloc_end);
if (delalloc_end >= page_end + 1) {
clear_extent_bit(tree, page_end + 1, delalloc_end,
EXTENT_LOCKED | EXTENT_DELALLOC,
1, 0, GFP_NOFS);
}
clear_extent_bit(tree, start, page_end, EXTENT_DELALLOC,
0, 0, GFP_NOFS);
if (test_range_bit(tree, start, page_end, EXTENT_DELALLOC, 0)) {
printk("found delalloc bits after clear extent_bit\n");
}
} else if (test_range_bit(tree, start, page_end, EXTENT_DELALLOC, 0)) {
printk("found delalloc bits after find_delalloc_range returns 0\n");
}

end = page_end;
if (test_range_bit(tree, start, page_end, EXTENT_DELALLOC, 0)) {
printk("found delalloc bits after lock_extent\n");
}

if (last_byte <= start) {
clear_extent_dirty(tree, start, page_end, GFP_NOFS);
Expand All @@ -1419,7 +1495,7 @@ int extent_write_full_page(struct extent_map_tree *tree, struct page *page,
clear_extent_dirty(tree, cur, page_end, GFP_NOFS);
break;
}
em = get_extent(inode, page, page_offset, cur, end, 1);
em = get_extent(inode, page, page_offset, cur, end, 0);
if (IS_ERR(em) || !em) {
SetPageError(page);
break;
Expand Down Expand Up @@ -1507,6 +1583,7 @@ int extent_commit_write(struct extent_map_tree *tree,
if (!PagePrivate(page)) {
SetPagePrivate(page);
set_page_private(page, 1);
WARN_ON(!page->mapping->a_ops->invalidatepage);
page_cache_get(page);
}

Expand Down Expand Up @@ -1543,6 +1620,7 @@ int extent_prepare_write(struct extent_map_tree *tree,
if (!PagePrivate(page)) {
SetPagePrivate(page);
set_page_private(page, 1);
WARN_ON(!page->mapping->a_ops->invalidatepage);
page_cache_get(page);
}
block_start = (page_start + from) & ~((u64)blocksize - 1);
Expand Down Expand Up @@ -1628,29 +1706,28 @@ int try_release_extent_mapping(struct extent_map_tree *tree, struct page *page)
u64 start = page->index << PAGE_CACHE_SHIFT;
u64 end = start + PAGE_CACHE_SIZE - 1;
u64 orig_start = start;
int ret = 1;

while (start <= end) {
em = lookup_extent_mapping(tree, start, end);
if (!em || IS_ERR(em))
break;
if (test_range_bit(tree, em->start, em->end,
EXTENT_LOCKED, 0)) {
if (!test_range_bit(tree, em->start, em->end,
EXTENT_LOCKED, 0)) {
remove_extent_mapping(tree, em);
/* once for the rb tree */
free_extent_map(em);
start = em->end + 1;
printk("range still locked %Lu %Lu\n", em->start, em->end);
break;
}
remove_extent_mapping(tree, em);
start = em->end + 1;
/* once for the rb tree */
free_extent_map(em);
/* once for us */
free_extent_map(em);
}
WARN_ON(test_range_bit(tree, orig_start, end, EXTENT_WRITEBACK, 0));
clear_extent_bit(tree, orig_start, end, EXTENT_UPTODATE,
1, 1, GFP_NOFS);
return 1;
if (test_range_bit(tree, orig_start, end, EXTENT_LOCKED, 0))
ret = 0;
else
clear_extent_bit(tree, orig_start, end, EXTENT_UPTODATE,
1, 1, GFP_NOFS);
return ret;
}
EXPORT_SYMBOL(try_release_extent_mapping);

3 changes: 3 additions & 0 deletions fs/btrfs/extent_map.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,7 @@ struct extent_map_tree {
struct rb_root state;
struct address_space *mapping;
rwlock_t lock;
int (*fill_delalloc)(struct inode *inode, u64 start, u64 end);
};

/* note, this must start with the same fields as fs/extent_map.c:tree_entry */
Expand Down Expand Up @@ -74,6 +75,8 @@ int set_extent_new(struct extent_map_tree *tree, u64 start, u64 end,
gfp_t mask);
int set_extent_dirty(struct extent_map_tree *tree, u64 start, u64 end,
gfp_t mask);
int set_extent_delalloc(struct extent_map_tree *tree, u64 start, u64 end,
gfp_t mask);
int extent_invalidatepage(struct extent_map_tree *tree,
struct page *page, unsigned long offset);
int extent_write_full_page(struct extent_map_tree *tree, struct page *page,
Expand Down
Loading

0 comments on commit b888db2

Please sign in to comment.