};
static int finish_current_insert(struct btrfs_trans_handle *trans, struct
- btrfs_root *extent_root);
+ btrfs_root *extent_root, int all);
static int del_pending_extents(struct btrfs_trans_handle *trans, struct
- btrfs_root *extent_root);
+ btrfs_root *extent_root, int all);
static struct btrfs_block_group_cache *
__btrfs_find_block_group(struct btrfs_root *root,
struct btrfs_block_group_cache *hint,
u64 search_start, int data, int owner);
-void maybe_lock_mutex(struct btrfs_root *root)
-{
- if (root != root->fs_info->extent_root &&
- root != root->fs_info->chunk_root &&
- root != root->fs_info->dev_root) {
- mutex_lock(&root->fs_info->alloc_mutex);
- }
-}
-
-void maybe_unlock_mutex(struct btrfs_root *root)
-{
- if (root != root->fs_info->extent_root &&
- root != root->fs_info->chunk_root &&
- root != root->fs_info->dev_root) {
- mutex_unlock(&root->fs_info->alloc_mutex);
- }
-}
-
static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)
{
return (cache->flags & bits) == bits;
u64 extent_start, extent_end, size;
int ret;
+ mutex_lock(&info->pinned_mutex);
while (start < end) {
ret = find_first_extent_bit(&info->pinned_extents, start,
&extent_start, &extent_end,
start = extent_end + 1;
} else if (extent_start > start && extent_start < end) {
size = extent_start - start;
- ret = btrfs_add_free_space(block_group, start, size);
+ ret = btrfs_add_free_space_lock(block_group, start,
+ size);
BUG_ON(ret);
start = extent_end + 1;
} else {
if (start < end) {
size = end - start;
- ret = btrfs_add_free_space(block_group, start, size);
+ ret = btrfs_add_free_space_lock(block_group, start, size);
BUG_ON(ret);
}
+ mutex_unlock(&info->pinned_mutex);
return 0;
}
return cache;
}
-static int noinline find_free_space(struct btrfs_root *root,
- struct btrfs_block_group_cache **cache_ret,
- u64 *start_ret, u64 num, int data)
-{
- int ret;
- struct btrfs_block_group_cache *cache = *cache_ret;
- struct btrfs_free_space *info = NULL;
- u64 last;
- u64 search_start = *start_ret;
-
- WARN_ON(!mutex_is_locked(&root->fs_info->alloc_mutex));
- if (!cache)
- goto out;
-
- last = max(search_start, cache->key.objectid);
-
-again:
- ret = cache_block_group(root, cache);
- if (ret)
- goto out;
-
- if (cache->ro || !block_group_bits(cache, data))
- goto new_group;
-
- info = btrfs_find_free_space(cache, last, num);
- if (info) {
- *start_ret = info->offset;
- return 0;
- }
-
-new_group:
- last = cache->key.objectid + cache->key.offset;
-
- cache = btrfs_lookup_first_block_group(root->fs_info, last);
- if (!cache)
- goto out;
-
- *cache_ret = cache;
- goto again;
-
-out:
- return -ENOSPC;
-}
-
-static u64 div_factor(u64 num, int factor)
-{
- if (factor == 10)
- return num;
- num *= factor;
- do_div(num, 10);
- return num;
-}
-
static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
u64 flags)
{
return NULL;
}
+static u64 div_factor(u64 num, int factor)
+{
+ if (factor == 10)
+ return num;
+ num *= factor;
+ do_div(num, 10);
+ return num;
+}
+
static struct btrfs_block_group_cache *
__btrfs_find_block_group(struct btrfs_root *root,
struct btrfs_block_group_cache *hint,
path = btrfs_alloc_path();
BUG_ON(!path);
- maybe_lock_mutex(root);
key.objectid = start;
key.offset = len;
btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
0, 0);
- maybe_unlock_mutex(root);
btrfs_free_path(path);
return ret;
}
BUG_ON(owner_objectid >= BTRFS_MAX_LEVEL);
num_bytes = btrfs_level_size(root, (int)owner_objectid);
+ mutex_lock(&root->fs_info->extent_ins_mutex);
if (test_range_bit(&root->fs_info->extent_ins, bytenr,
- bytenr + num_bytes - 1, EXTENT_LOCKED, 0)) {
+ bytenr + num_bytes - 1, EXTENT_WRITEBACK, 0)) {
u64 priv;
ret = get_state_private(&root->fs_info->extent_ins,
bytenr, &priv);
(unsigned long)priv;
BUG_ON(extent_op->parent != orig_parent);
BUG_ON(extent_op->generation != orig_generation);
+
extent_op->parent = parent;
extent_op->generation = ref_generation;
} else {
set_extent_bits(&root->fs_info->extent_ins,
bytenr, bytenr + num_bytes - 1,
- EXTENT_LOCKED, GFP_NOFS);
+ EXTENT_WRITEBACK, GFP_NOFS);
set_state_private(&root->fs_info->extent_ins,
bytenr, (unsigned long)extent_op);
}
+ mutex_unlock(&root->fs_info->extent_ins_mutex);
return 0;
}
parent, ref_root, ref_generation,
owner_objectid);
BUG_ON(ret);
- finish_current_insert(trans, extent_root);
- del_pending_extents(trans, extent_root);
+ finish_current_insert(trans, extent_root, 0);
+ del_pending_extents(trans, extent_root, 0);
out:
btrfs_free_path(path);
return ret;
if (ref_root == BTRFS_TREE_LOG_OBJECTID &&
owner_objectid < BTRFS_FIRST_FREE_OBJECTID)
return 0;
- maybe_lock_mutex(root);
ret = __btrfs_update_extent_ref(trans, root, bytenr, orig_parent,
parent, ref_root, ref_root,
ref_generation, ref_generation,
owner_objectid);
- maybe_unlock_mutex(root);
return ret;
}
ref_root, ref_generation,
owner_objectid);
BUG_ON(ret);
- finish_current_insert(trans, root->fs_info->extent_root);
- del_pending_extents(trans, root->fs_info->extent_root);
+ finish_current_insert(trans, root->fs_info->extent_root, 0);
+ del_pending_extents(trans, root->fs_info->extent_root, 0);
btrfs_free_path(path);
return 0;
if (ref_root == BTRFS_TREE_LOG_OBJECTID &&
owner_objectid < BTRFS_FIRST_FREE_OBJECTID)
return 0;
- maybe_lock_mutex(root);
ret = __btrfs_inc_extent_ref(trans, root, bytenr, 0, parent,
0, ref_root, 0, ref_generation,
owner_objectid);
- maybe_unlock_mutex(root);
return ret;
}
int btrfs_extent_post_op(struct btrfs_trans_handle *trans,
struct btrfs_root *root)
{
- finish_current_insert(trans, root->fs_info->extent_root);
- del_pending_extents(trans, root->fs_info->extent_root);
+ finish_current_insert(trans, root->fs_info->extent_root, 1);
+ del_pending_extents(trans, root->fs_info->extent_root, 1);
return 0;
}
key.type = BTRFS_EXTENT_ITEM_KEY;
path = btrfs_alloc_path();
- mutex_lock(&root->fs_info->alloc_mutex);
ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
if (ret < 0)
goto out;
}
ret = 0;
out:
- mutex_unlock(&root->fs_info->alloc_mutex);
btrfs_free_path(path);
return ret;
}
nr_file_extents++;
- maybe_lock_mutex(root);
ret = process_func(trans, root, bytenr,
orig_buf->start, buf->start,
orig_root, ref_root,
orig_generation, ref_generation,
key.objectid);
- maybe_unlock_mutex(root);
if (ret) {
faili = i;
}
} else {
bytenr = btrfs_node_blockptr(buf, i);
- maybe_lock_mutex(root);
ret = process_func(trans, root, bytenr,
orig_buf->start, buf->start,
orig_root, ref_root,
orig_generation, ref_generation,
level - 1);
- maybe_unlock_mutex(root);
if (ret) {
faili = i;
WARN_ON(1);
bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
if (bytenr == 0)
continue;
- maybe_lock_mutex(root);
ret = __btrfs_update_extent_ref(trans, root, bytenr,
orig_buf->start, buf->start,
orig_root, ref_root,
orig_generation, ref_generation,
key.objectid);
- maybe_unlock_mutex(root);
if (ret)
goto fail;
} else {
bytenr = btrfs_node_blockptr(buf, slot);
- maybe_lock_mutex(root);
ret = __btrfs_update_extent_ref(trans, root, bytenr,
orig_buf->start, buf->start,
orig_root, ref_root,
orig_generation, ref_generation,
level - 1);
- maybe_unlock_mutex(root);
if (ret)
goto fail;
}
btrfs_mark_buffer_dirty(leaf);
btrfs_release_path(extent_root, path);
fail:
- finish_current_insert(trans, extent_root);
- pending_ret = del_pending_extents(trans, extent_root);
+ finish_current_insert(trans, extent_root, 0);
+ pending_ret = del_pending_extents(trans, extent_root, 0);
if (ret)
return ret;
if (pending_ret)
if (!path)
return -ENOMEM;
- mutex_lock(&root->fs_info->alloc_mutex);
while(1) {
cache = NULL;
spin_lock(&root->fs_info->block_group_cache_lock);
}
}
btrfs_free_path(path);
- mutex_unlock(&root->fs_info->alloc_mutex);
return werr;
}
found = __find_space_info(info, flags);
if (found) {
+ spin_lock(&found->lock);
found->total_bytes += total_bytes;
found->bytes_used += bytes_used;
found->full = 0;
+ spin_unlock(&found->lock);
*space_info = found;
return 0;
}
list_add(&found->list, &info->space_info);
INIT_LIST_HEAD(&found->block_groups);
+ init_rwsem(&found->groups_sem);
spin_lock_init(&found->lock);
found->flags = flags;
found->total_bytes = total_bytes;
}
BUG_ON(!space_info);
+ spin_lock(&space_info->lock);
if (space_info->force_alloc) {
force = 1;
space_info->force_alloc = 0;
}
- if (space_info->full)
+ if (space_info->full) {
+ spin_unlock(&space_info->lock);
goto out;
+ }
thresh = div_factor(space_info->total_bytes, 6);
if (!force &&
(space_info->bytes_used + space_info->bytes_pinned +
- space_info->bytes_reserved + alloc_bytes) < thresh)
+ space_info->bytes_reserved + alloc_bytes) < thresh) {
+ spin_unlock(&space_info->lock);
goto out;
+ }
- while (!mutex_trylock(&extent_root->fs_info->chunk_mutex)) {
- if (!force)
- goto out;
- mutex_unlock(&extent_root->fs_info->alloc_mutex);
- cond_resched();
- mutex_lock(&extent_root->fs_info->alloc_mutex);
+ spin_unlock(&space_info->lock);
+
+ ret = mutex_trylock(&extent_root->fs_info->chunk_mutex);
+ if (!ret && !force) {
+ goto out;
+ } else if (!ret) {
+ mutex_lock(&extent_root->fs_info->chunk_mutex);
waited = 1;
}
- if (waited && space_info->full)
- goto out_unlock;
+ if (waited) {
+ spin_lock(&space_info->lock);
+ if (space_info->full) {
+ spin_unlock(&space_info->lock);
+ goto out_unlock;
+ }
+ spin_unlock(&space_info->lock);
+ }
ret = btrfs_alloc_chunk(trans, extent_root, &start, &num_bytes, flags);
- if (ret == -ENOSPC) {
+ if (ret) {
printk("space info full %Lu\n", flags);
space_info->full = 1;
goto out_unlock;
}
- BUG_ON(ret);
ret = btrfs_make_block_group(trans, extent_root, 0, flags,
BTRFS_FIRST_CHUNK_TREE_OBJECTID, start, num_bytes);
BUG_ON(ret);
-
out_unlock:
mutex_unlock(&extent_root->fs_info->chunk_mutex);
out:
u64 old_val;
u64 byte_in_group;
- WARN_ON(!mutex_is_locked(&root->fs_info->alloc_mutex));
while(total) {
cache = btrfs_lookup_block_group(info, bytenr);
if (!cache) {
byte_in_group = bytenr - cache->key.objectid;
WARN_ON(byte_in_group > cache->key.offset);
+ spin_lock(&cache->space_info->lock);
spin_lock(&cache->lock);
cache->dirty = 1;
old_val = btrfs_block_group_used(&cache->item);
cache->space_info->bytes_used += num_bytes;
btrfs_set_block_group_used(&cache->item, old_val);
spin_unlock(&cache->lock);
+ spin_unlock(&cache->space_info->lock);
} else {
old_val -= num_bytes;
cache->space_info->bytes_used -= num_bytes;
btrfs_set_block_group_used(&cache->item, old_val);
spin_unlock(&cache->lock);
+ spin_unlock(&cache->space_info->lock);
if (mark_free) {
int ret;
ret = btrfs_add_free_space(cache, bytenr,
struct btrfs_block_group_cache *cache;
struct btrfs_fs_info *fs_info = root->fs_info;
- WARN_ON(!mutex_is_locked(&root->fs_info->alloc_mutex));
+ WARN_ON(!mutex_is_locked(&root->fs_info->pinned_mutex));
if (pin) {
set_extent_dirty(&fs_info->pinned_extents,
bytenr, bytenr + num - 1, GFP_NOFS);
len = min(num, cache->key.offset -
(bytenr - cache->key.objectid));
if (pin) {
+ spin_lock(&cache->space_info->lock);
spin_lock(&cache->lock);
cache->pinned += len;
cache->space_info->bytes_pinned += len;
spin_unlock(&cache->lock);
+ spin_unlock(&cache->space_info->lock);
fs_info->total_pinned += len;
} else {
+ spin_lock(&cache->space_info->lock);
spin_lock(&cache->lock);
cache->pinned -= len;
cache->space_info->bytes_pinned -= len;
spin_unlock(&cache->lock);
+ spin_unlock(&cache->space_info->lock);
fs_info->total_pinned -= len;
}
bytenr += len;
struct btrfs_block_group_cache *cache;
struct btrfs_fs_info *fs_info = root->fs_info;
- WARN_ON(!mutex_is_locked(&root->fs_info->alloc_mutex));
while (num > 0) {
cache = btrfs_lookup_block_group(fs_info, bytenr);
BUG_ON(!cache);
len = min(num, cache->key.offset -
(bytenr - cache->key.objectid));
+
+ spin_lock(&cache->space_info->lock);
+ spin_lock(&cache->lock);
if (reserve) {
- spin_lock(&cache->lock);
cache->reserved += len;
cache->space_info->bytes_reserved += len;
- spin_unlock(&cache->lock);
} else {
- spin_lock(&cache->lock);
cache->reserved -= len;
cache->space_info->bytes_reserved -= len;
- spin_unlock(&cache->lock);
}
+ spin_unlock(&cache->lock);
+ spin_unlock(&cache->space_info->lock);
bytenr += len;
num -= len;
}
struct extent_io_tree *pinned_extents = &root->fs_info->pinned_extents;
int ret;
+ mutex_lock(&root->fs_info->pinned_mutex);
while(1) {
ret = find_first_extent_bit(pinned_extents, last,
&start, &end, EXTENT_DIRTY);
set_extent_dirty(copy, start, end, GFP_NOFS);
last = end + 1;
}
+ mutex_unlock(&root->fs_info->pinned_mutex);
return 0;
}
int ret;
struct btrfs_block_group_cache *cache;
- mutex_lock(&root->fs_info->alloc_mutex);
+ mutex_lock(&root->fs_info->pinned_mutex);
while(1) {
ret = find_first_extent_bit(unpin, 0, &start, &end,
EXTENT_DIRTY);
if (cache->cached)
btrfs_add_free_space(cache, start, end - start + 1);
if (need_resched()) {
- mutex_unlock(&root->fs_info->alloc_mutex);
+ mutex_unlock(&root->fs_info->pinned_mutex);
cond_resched();
- mutex_lock(&root->fs_info->alloc_mutex);
+ mutex_lock(&root->fs_info->pinned_mutex);
}
}
- mutex_unlock(&root->fs_info->alloc_mutex);
+ mutex_unlock(&root->fs_info->pinned_mutex);
return 0;
}
static int finish_current_insert(struct btrfs_trans_handle *trans,
- struct btrfs_root *extent_root)
+ struct btrfs_root *extent_root, int all)
{
u64 start;
u64 end;
u64 priv;
+ u64 search = 0;
struct btrfs_fs_info *info = extent_root->fs_info;
struct btrfs_path *path;
struct btrfs_extent_ref *ref;
int ret;
int err = 0;
- WARN_ON(!mutex_is_locked(&extent_root->fs_info->alloc_mutex));
btrfs_set_stack_extent_refs(&extent_item, 1);
path = btrfs_alloc_path();
while(1) {
- ret = find_first_extent_bit(&info->extent_ins, 0, &start,
- &end, EXTENT_LOCKED);
- if (ret)
+ mutex_lock(&info->extent_ins_mutex);
+ ret = find_first_extent_bit(&info->extent_ins, search, &start,
+ &end, EXTENT_WRITEBACK);
+ if (ret) {
+ mutex_unlock(&info->extent_ins_mutex);
+ if (search && all) {
+ search = 0;
+ continue;
+ }
break;
+ }
+
+ ret = try_lock_extent(&info->extent_ins, start, end, GFP_NOFS);
+ if (!ret) {
+ search = end + 1;
+ mutex_unlock(&info->extent_ins_mutex);
+ cond_resched();
+ continue;
+ }
+ BUG_ON(ret < 0);
ret = get_state_private(&info->extent_ins, start, &priv);
BUG_ON(ret);
extent_op = (struct pending_extent_op *)(unsigned long)priv;
+ mutex_unlock(&info->extent_ins_mutex);
+
if (extent_op->type == PENDING_EXTENT_INSERT) {
key.objectid = start;
key.offset = end + 1 - start;
&extent_item, sizeof(extent_item));
BUG_ON(err);
+ mutex_lock(&info->extent_ins_mutex);
clear_extent_bits(&info->extent_ins, start, end,
- EXTENT_LOCKED, GFP_NOFS);
+ EXTENT_WRITEBACK, GFP_NOFS);
+ mutex_unlock(&info->extent_ins_mutex);
err = insert_extent_backref(trans, extent_root, path,
start, extent_op->parent,
extent_op->level, 0);
BUG_ON(err);
+ mutex_lock(&info->extent_ins_mutex);
clear_extent_bits(&info->extent_ins, start, end,
- EXTENT_LOCKED, GFP_NOFS);
+ EXTENT_WRITEBACK, GFP_NOFS);
+ mutex_unlock(&info->extent_ins_mutex);
key.objectid = start;
key.offset = extent_op->parent;
BUG_ON(1);
}
kfree(extent_op);
+ unlock_extent(&info->extent_ins, start, end, GFP_NOFS);
+ if (all)
+ search = 0;
+ else
+ search = end + 1;
- if (need_resched()) {
- mutex_unlock(&extent_root->fs_info->alloc_mutex);
- cond_resched();
- mutex_lock(&extent_root->fs_info->alloc_mutex);
- }
+ cond_resched();
}
btrfs_free_path(path);
return 0;
int err = 0;
struct extent_buffer *buf;
- WARN_ON(!mutex_is_locked(&root->fs_info->alloc_mutex));
if (is_data)
goto pinit;
struct btrfs_extent_item *ei;
u32 refs;
- WARN_ON(!mutex_is_locked(&root->fs_info->alloc_mutex));
key.objectid = bytenr;
btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
key.offset = num_bytes;
#endif
if (pin) {
+ mutex_lock(&root->fs_info->pinned_mutex);
ret = pin_down_bytes(trans, root, bytenr, num_bytes,
owner_objectid >= BTRFS_FIRST_FREE_OBJECTID);
+ mutex_unlock(&root->fs_info->pinned_mutex);
if (ret > 0)
mark_free = 1;
BUG_ON(ret < 0);
ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
num_to_del);
BUG_ON(ret);
+ btrfs_release_path(extent_root, path);
ret = update_block_group(trans, root, bytenr, num_bytes, 0,
mark_free);
BUG_ON(ret);
#endif
}
btrfs_free_path(path);
- finish_current_insert(trans, extent_root);
+ finish_current_insert(trans, extent_root, 0);
return ret;
}
* them from the extent map
*/
static int del_pending_extents(struct btrfs_trans_handle *trans, struct
- btrfs_root *extent_root)
+ btrfs_root *extent_root, int all)
{
int ret;
int err = 0;
- int mark_free = 0;
u64 start;
u64 end;
u64 priv;
+ u64 search = 0;
struct extent_io_tree *pending_del;
struct extent_io_tree *extent_ins;
struct pending_extent_op *extent_op;
+ struct btrfs_fs_info *info = extent_root->fs_info;
- WARN_ON(!mutex_is_locked(&extent_root->fs_info->alloc_mutex));
extent_ins = &extent_root->fs_info->extent_ins;
pending_del = &extent_root->fs_info->pending_del;
while(1) {
- ret = find_first_extent_bit(pending_del, 0, &start, &end,
- EXTENT_LOCKED);
- if (ret)
+ mutex_lock(&info->extent_ins_mutex);
+ ret = find_first_extent_bit(pending_del, search, &start, &end,
+ EXTENT_WRITEBACK);
+ if (ret) {
+ mutex_unlock(&info->extent_ins_mutex);
+ if (all && search) {
+ search = 0;
+ continue;
+ }
break;
+ }
+
+ ret = try_lock_extent(extent_ins, start, end, GFP_NOFS);
+ if (!ret) {
+ search = end+1;
+ mutex_unlock(&info->extent_ins_mutex);
+ cond_resched();
+ continue;
+ }
+ BUG_ON(ret < 0);
ret = get_state_private(pending_del, start, &priv);
BUG_ON(ret);
extent_op = (struct pending_extent_op *)(unsigned long)priv;
- clear_extent_bits(pending_del, start, end, EXTENT_LOCKED,
+ clear_extent_bits(pending_del, start, end, EXTENT_WRITEBACK,
GFP_NOFS);
-
- ret = pin_down_bytes(trans, extent_root, start,
- end + 1 - start, 0);
- mark_free = ret > 0;
if (!test_range_bit(extent_ins, start, end,
- EXTENT_LOCKED, 0)) {
+ EXTENT_WRITEBACK, 0)) {
+ mutex_unlock(&info->extent_ins_mutex);
free_extent:
ret = __free_extent(trans, extent_root,
start, end + 1 - start,
extent_op->orig_parent,
extent_root->root_key.objectid,
extent_op->orig_generation,
- extent_op->level, 0, mark_free);
+ extent_op->level, 1, 0);
kfree(extent_op);
} else {
kfree(extent_op);
- ret = get_state_private(extent_ins, start, &priv);
+
+ ret = get_state_private(&info->extent_ins, start,
+ &priv);
BUG_ON(ret);
extent_op = (struct pending_extent_op *)
- (unsigned long)priv;
+ (unsigned long)priv;
+
+ clear_extent_bits(&info->extent_ins, start, end,
+ EXTENT_WRITEBACK, GFP_NOFS);
- clear_extent_bits(extent_ins, start, end,
- EXTENT_LOCKED, GFP_NOFS);
+ mutex_unlock(&info->extent_ins_mutex);
if (extent_op->type == PENDING_BACKREF_UPDATE)
goto free_extent;
+ mutex_lock(&extent_root->fs_info->pinned_mutex);
+ ret = pin_down_bytes(trans, extent_root, start,
+ end + 1 - start, 0);
+ mutex_unlock(&extent_root->fs_info->pinned_mutex);
+
ret = update_block_group(trans, extent_root, start,
- end + 1 - start, 0, mark_free);
+ end + 1 - start, 0, ret > 0);
+
BUG_ON(ret);
kfree(extent_op);
}
if (ret)
err = ret;
+ unlock_extent(extent_ins, start, end, GFP_NOFS);
- if (need_resched()) {
- mutex_unlock(&extent_root->fs_info->alloc_mutex);
- cond_resched();
- mutex_lock(&extent_root->fs_info->alloc_mutex);
- }
+ if (all)
+ search = 0;
+ else
+ search = end + 1;
+ cond_resched();
}
return err;
}
extent_op->orig_generation = ref_generation;
extent_op->level = (int)owner_objectid;
+ mutex_lock(&root->fs_info->extent_ins_mutex);
set_extent_bits(&root->fs_info->pending_del,
bytenr, bytenr + num_bytes - 1,
- EXTENT_LOCKED, GFP_NOFS);
+ EXTENT_WRITEBACK, GFP_NOFS);
set_state_private(&root->fs_info->pending_del,
bytenr, (unsigned long)extent_op);
+ mutex_unlock(&root->fs_info->extent_ins_mutex);
return 0;
}
/* if metadata always pin */
root_objectid, ref_generation,
owner_objectid, pin, pin == 0);
- finish_current_insert(trans, root->fs_info->extent_root);
- pending_ret = del_pending_extents(trans, root->fs_info->extent_root);
+ finish_current_insert(trans, root->fs_info->extent_root, 0);
+ pending_ret = del_pending_extents(trans, root->fs_info->extent_root, 0);
return ret ? ret : pending_ret;
}
{
int ret;
- maybe_lock_mutex(root);
ret = __btrfs_free_extent(trans, root, bytenr, num_bytes, parent,
root_objectid, ref_generation,
owner_objectid, pin);
- maybe_unlock_mutex(root);
return ret;
}
u64 exclude_start, u64 exclude_nr,
int data)
{
- int ret;
- u64 orig_search_start;
+ int ret = 0;
struct btrfs_root * root = orig_root->fs_info->extent_root;
- struct btrfs_fs_info *info = root->fs_info;
u64 total_needed = num_bytes;
u64 *last_ptr = NULL;
- struct btrfs_block_group_cache *block_group;
+ struct btrfs_block_group_cache *block_group = NULL;
int chunk_alloc_done = 0;
int empty_cluster = 2 * 1024 * 1024;
int allowed_chunk_alloc = 0;
+ struct list_head *head = NULL, *cur = NULL;
+ int loop = 0;
+ struct btrfs_space_info *space_info;
WARN_ON(num_bytes < root->sectorsize);
btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
+ ins->objectid = 0;
+ ins->offset = 0;
if (orig_root->ref_cows || empty_size)
allowed_chunk_alloc = 1;
else
empty_size += empty_cluster;
}
-
search_start = max(search_start, first_logical_byte(root, 0));
- orig_search_start = search_start;
-
search_start = max(search_start, hint_byte);
total_needed += empty_size;
-new_group:
- block_group = btrfs_lookup_block_group(info, search_start);
- if (!block_group)
- block_group = btrfs_lookup_first_block_group(info,
- search_start);
+ block_group = btrfs_lookup_block_group(root->fs_info, search_start);
+ space_info = __find_space_info(root->fs_info, data);
- /*
- * Ok this looks a little tricky, buts its really simple. First if we
- * didn't find a block group obviously we want to start over.
- * Secondly, if the block group we found does not match the type we
- * need, and we have a last_ptr and its not 0, chances are the last
- * allocation we made was at the end of the block group, so lets go
- * ahead and skip the looking through the rest of the block groups and
- * start at the beginning. This helps with metadata allocations,
- * since you are likely to have a bunch of data block groups to search
- * through first before you realize that you need to start over, so go
- * ahead and start over and save the time.
- */
- if (!block_group || (!block_group_bits(block_group, data) &&
- last_ptr && *last_ptr)) {
- if (search_start != orig_search_start) {
- if (last_ptr && *last_ptr) {
- total_needed += empty_cluster;
- *last_ptr = 0;
- }
- search_start = orig_search_start;
- goto new_group;
- } else if (!chunk_alloc_done && allowed_chunk_alloc) {
- ret = do_chunk_alloc(trans, root,
- num_bytes + 2 * 1024 * 1024,
- data, 1);
- if (ret < 0)
- goto error;
- BUG_ON(ret);
- chunk_alloc_done = 1;
- search_start = orig_search_start;
- goto new_group;
- } else {
- ret = -ENOSPC;
- goto error;
- }
- }
-
- /*
- * this is going to seach through all of the existing block groups it
- * can find, so if we don't find something we need to see if we can
- * allocate what we need.
- */
- ret = find_free_space(root, &block_group, &search_start,
- total_needed, data);
- if (ret == -ENOSPC) {
+ down_read(&space_info->groups_sem);
+ while (1) {
+ struct btrfs_free_space *free_space;
/*
- * instead of allocating, start at the original search start
- * and see if there is something to be found, if not then we
- * allocate
+ * the only way this happens if our hint points to a block
+ * group thats not of the proper type, while looping this
+ * should never happen
*/
- if (search_start != orig_search_start) {
- if (last_ptr && *last_ptr) {
- *last_ptr = 0;
- total_needed += empty_cluster;
- }
- search_start = orig_search_start;
+ WARN_ON(!block_group);
+ mutex_lock(&block_group->alloc_mutex);
+ if (unlikely(!block_group_bits(block_group, data)))
goto new_group;
- }
- /*
- * we've already allocated, we're pretty screwed
- */
- if (chunk_alloc_done) {
- goto error;
- } else if (!allowed_chunk_alloc && block_group &&
- block_group_bits(block_group, data)) {
- block_group->space_info->force_alloc = 1;
- goto error;
- } else if (!allowed_chunk_alloc) {
- goto error;
+ ret = cache_block_group(root, block_group);
+ if (ret) {
+ mutex_unlock(&block_group->alloc_mutex);
+ break;
}
- ret = do_chunk_alloc(trans, root, num_bytes + 2 * 1024 * 1024,
- data, 1);
- if (ret < 0)
- goto error;
+ if (block_group->ro)
+ goto new_group;
- BUG_ON(ret);
- chunk_alloc_done = 1;
- if (block_group)
- search_start = block_group->key.objectid +
+ free_space = btrfs_find_free_space(block_group, search_start,
+ total_needed);
+ if (free_space) {
+ u64 start = block_group->key.objectid;
+ u64 end = block_group->key.objectid +
block_group->key.offset;
- else
- search_start = orig_search_start;
- goto new_group;
- }
- if (ret)
- goto error;
+ search_start = stripe_align(root, free_space->offset);
- search_start = stripe_align(root, search_start);
- ins->objectid = search_start;
- ins->offset = num_bytes;
+ /* move on to the next group */
+ if (search_start + num_bytes >= search_end)
+ goto new_group;
- if (ins->objectid + num_bytes >= search_end) {
- search_start = orig_search_start;
- if (chunk_alloc_done) {
- ret = -ENOSPC;
- goto error;
+ /* move on to the next group */
+ if (search_start + num_bytes > end)
+ goto new_group;
+
+ if (exclude_nr > 0 &&
+ (search_start + num_bytes > exclude_start &&
+ search_start < exclude_start + exclude_nr)) {
+ search_start = exclude_start + exclude_nr;
+ /*
+ * if search_start is still in this block group
+ * then we just re-search this block group
+ */
+ if (search_start >= start &&
+ search_start < end) {
+ mutex_unlock(&block_group->alloc_mutex);
+ continue;
+ }
+
+ /* else we go to the next block group */
+ goto new_group;
+ }
+
+ ins->objectid = search_start;
+ ins->offset = num_bytes;
+
+ btrfs_remove_free_space_lock(block_group, search_start,
+ num_bytes);
+ /* we are all good, lets return */
+ mutex_unlock(&block_group->alloc_mutex);
+ break;
}
- goto new_group;
- }
+new_group:
+ mutex_unlock(&block_group->alloc_mutex);
+ /*
+ * Here's how this works.
+ * loop == 0: we were searching a block group via a hint
+ * and didn't find anything, so we start at
+ * the head of the block groups and keep searching
+ * loop == 1: we're searching through all of the block groups
+ * if we hit the head again we have searched
+ * all of the block groups for this space and we
+ * need to try and allocate, if we cant error out.
+ * loop == 2: we allocated more space and are looping through
+ * all of the block groups again.
+ */
+ if (loop == 0) {
+ head = &space_info->block_groups;
+ cur = head->next;
- if (ins->objectid + num_bytes >
- block_group->key.objectid + block_group->key.offset) {
- if (search_start == orig_search_start && chunk_alloc_done) {
- ret = -ENOSPC;
- goto error;
+ if (last_ptr && *last_ptr) {
+ total_needed += empty_cluster;
+ *last_ptr = 0;
+ }
+ loop++;
+ } else if (loop == 1 && cur == head) {
+ if (allowed_chunk_alloc && !chunk_alloc_done) {
+ up_read(&space_info->groups_sem);
+ ret = do_chunk_alloc(trans, root, num_bytes +
+ 2 * 1024 * 1024, data, 1);
+ if (ret < 0)
+ break;
+ down_read(&space_info->groups_sem);
+ loop++;
+ head = &space_info->block_groups;
+ cur = head->next;
+ chunk_alloc_done = 1;
+ } else if (!allowed_chunk_alloc) {
+ space_info->force_alloc = 1;
+ break;
+ } else {
+ break;
+ }
+ } else if (cur == head) {
+ break;
}
- search_start = block_group->key.objectid +
- block_group->key.offset;
- goto new_group;
- }
- if (exclude_nr > 0 && (ins->objectid + num_bytes > exclude_start &&
- ins->objectid < exclude_start + exclude_nr)) {
- search_start = exclude_start + exclude_nr;
- goto new_group;
+ block_group = list_entry(cur, struct btrfs_block_group_cache,
+ list);
+ search_start = block_group->key.objectid;
+ cur = cur->next;
}
- if (!(data & BTRFS_BLOCK_GROUP_DATA))
- trans->block_group = block_group;
+ /* we found what we needed */
+ if (ins->objectid) {
+ if (!(data & BTRFS_BLOCK_GROUP_DATA))
+ trans->block_group = block_group;
- ins->offset = num_bytes;
- if (last_ptr) {
- *last_ptr = ins->objectid + ins->offset;
- if (*last_ptr ==
- btrfs_super_total_bytes(&root->fs_info->super_copy))
- *last_ptr = 0;
+ if (last_ptr)
+ *last_ptr = ins->objectid + ins->offset;
+ ret = 0;
+ } else if (!ret) {
+ ret = -ENOSPC;
}
- ret = 0;
-error:
+ up_read(&space_info->groups_sem);
return ret;
}
info->total_bytes - info->bytes_used - info->bytes_pinned -
info->bytes_reserved, (info->full) ? "" : "not ");
- spin_lock(&info->lock);
+ down_read(&info->groups_sem);
list_for_each(l, &info->block_groups) {
cache = list_entry(l, struct btrfs_block_group_cache, list);
spin_lock(&cache->lock);
btrfs_dump_free_space(cache, bytes);
spin_unlock(&cache->lock);
}
- spin_unlock(&info->lock);
+ up_read(&info->groups_sem);
}
static int __btrfs_reserve_extent(struct btrfs_trans_handle *trans,
u64 search_start = 0;
u64 alloc_profile;
struct btrfs_fs_info *info = root->fs_info;
- struct btrfs_block_group_cache *cache;
if (data) {
alloc_profile = info->avail_data_alloc_bits &
dump_space_info(sinfo, num_bytes);
BUG();
}
- cache = btrfs_lookup_block_group(root->fs_info, ins->objectid);
- if (!cache) {
- printk(KERN_ERR "Unable to find block group for %Lu\n", ins->objectid);
- return -ENOSPC;
- }
-
- ret = btrfs_remove_free_space(cache, ins->objectid, ins->offset);
return ret;
}
{
struct btrfs_block_group_cache *cache;
- maybe_lock_mutex(root);
cache = btrfs_lookup_block_group(root->fs_info, start);
if (!cache) {
printk(KERN_ERR "Unable to find block group for %Lu\n", start);
- maybe_unlock_mutex(root);
return -ENOSPC;
}
btrfs_add_free_space(cache, start, len);
update_reserved_extents(root, start, len, 0);
- maybe_unlock_mutex(root);
return 0;
}
u64 data)
{
int ret;
- maybe_lock_mutex(root);
ret = __btrfs_reserve_extent(trans, root, num_bytes, min_alloc_size,
empty_size, hint_byte, search_end, ins,
data);
update_reserved_extents(root, ins->objectid, ins->offset, 1);
- maybe_unlock_mutex(root);
return ret;
}
extent_op->orig_generation = 0;
extent_op->level = (int)owner;
+ mutex_lock(&root->fs_info->extent_ins_mutex);
set_extent_bits(&root->fs_info->extent_ins, ins->objectid,
ins->objectid + ins->offset - 1,
- EXTENT_LOCKED, GFP_NOFS);
+ EXTENT_WRITEBACK, GFP_NOFS);
set_state_private(&root->fs_info->extent_ins,
ins->objectid, (unsigned long)extent_op);
+ mutex_unlock(&root->fs_info->extent_ins_mutex);
goto update_block;
}
trans->alloc_exclude_start = 0;
trans->alloc_exclude_nr = 0;
btrfs_free_path(path);
- finish_current_insert(trans, extent_root);
- pending_ret = del_pending_extents(trans, extent_root);
+ finish_current_insert(trans, extent_root, 0);
+ pending_ret = del_pending_extents(trans, extent_root, 0);
if (ret)
goto out;
if (root_objectid == BTRFS_TREE_LOG_OBJECTID)
return 0;
- maybe_lock_mutex(root);
ret = __btrfs_alloc_reserved_extent(trans, root, parent, root_objectid,
ref_generation, owner, ins);
update_reserved_extents(root, ins->objectid, ins->offset, 0);
- maybe_unlock_mutex(root);
return ret;
}
int ret;
struct btrfs_block_group_cache *block_group;
- maybe_lock_mutex(root);
block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid);
+ mutex_lock(&block_group->alloc_mutex);
cache_block_group(root, block_group);
- ret = btrfs_remove_free_space(block_group, ins->objectid, ins->offset);
+ ret = btrfs_remove_free_space_lock(block_group, ins->objectid,
+ ins->offset);
+ mutex_unlock(&block_group->alloc_mutex);
BUG_ON(ret);
ret = __btrfs_alloc_reserved_extent(trans, root, parent, root_objectid,
ref_generation, owner, ins);
- maybe_unlock_mutex(root);
return ret;
}
{
int ret;
- maybe_lock_mutex(root);
-
ret = __btrfs_reserve_extent(trans, root, num_bytes,
min_alloc_size, empty_size, hint_byte,
search_end, ins, data);
} else {
update_reserved_extents(root, ins->objectid, ins->offset, 1);
}
- maybe_unlock_mutex(root);
return ret;
}
if (disk_bytenr == 0)
continue;
- mutex_lock(&root->fs_info->alloc_mutex);
ret = __btrfs_free_extent(trans, root, disk_bytenr,
btrfs_file_extent_disk_num_bytes(leaf, fi),
leaf->start, leaf_owner, leaf_generation,
key.objectid, 0);
- mutex_unlock(&root->fs_info->alloc_mutex);
BUG_ON(ret);
atomic_inc(&root->fs_info->throttle_gen);
struct btrfs_extent_info *info = ref->extents;
for (i = 0; i < ref->nritems; i++) {
- mutex_lock(&root->fs_info->alloc_mutex);
ret = __btrfs_free_extent(trans, root, info->bytenr,
info->num_bytes, ref->bytenr,
ref->owner, ref->generation,
info->objectid, 0);
- mutex_unlock(&root->fs_info->alloc_mutex);
atomic_inc(&root->fs_info->throttle_gen);
wake_up(&root->fs_info->transaction_throttle);
root_gen = btrfs_header_generation(parent);
path->slots[*level]++;
- mutex_lock(&root->fs_info->alloc_mutex);
ret = __btrfs_free_extent(trans, root, bytenr,
blocksize, parent->start,
root_owner, root_gen,
*level - 1, 1);
BUG_ON(ret);
- mutex_unlock(&root->fs_info->alloc_mutex);
atomic_inc(&root->fs_info->throttle_gen);
wake_up(&root->fs_info->transaction_throttle);
root_owner = btrfs_header_owner(parent);
root_gen = btrfs_header_generation(parent);
- mutex_lock(&root->fs_info->alloc_mutex);
ret = __btrfs_free_extent(trans, root, bytenr, blocksize,
parent->start, root_owner, root_gen,
*level, 1);
- mutex_unlock(&root->fs_info->alloc_mutex);
free_extent_buffer(path->nodes[*level]);
path->nodes[*level] = NULL;
*level += 1;
return 0;
}
+/*
+ * helper function for drop_subtree, this function is similar to
+ * walk_down_tree. The main difference is that it checks reference
+ * counts while tree blocks are locked.
+ */
+static int noinline walk_down_subtree(struct btrfs_trans_handle *trans,
+ struct btrfs_root *root,
+ struct btrfs_path *path, int *level)
+{
+ struct extent_buffer *next;
+ struct extent_buffer *cur;
+ struct extent_buffer *parent;
+ u64 bytenr;
+ u64 ptr_gen;
+ u32 blocksize;
+ u32 refs;
+ int ret;
+
+ cur = path->nodes[*level];
+ ret = btrfs_lookup_extent_ref(trans, root, cur->start, cur->len,
+ &refs);
+ BUG_ON(ret);
+ if (refs > 1)
+ goto out;
+
+ while (*level >= 0) {
+ cur = path->nodes[*level];
+ if (*level == 0) {
+ ret = btrfs_drop_leaf_ref(trans, root, cur);
+ BUG_ON(ret);
+ clean_tree_block(trans, root, cur);
+ break;
+ }
+ if (path->slots[*level] >= btrfs_header_nritems(cur)) {
+ clean_tree_block(trans, root, cur);
+ break;
+ }
+
+ bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
+ blocksize = btrfs_level_size(root, *level - 1);
+ ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
+
+ next = read_tree_block(root, bytenr, blocksize, ptr_gen);
+ btrfs_tree_lock(next);
+
+ ret = btrfs_lookup_extent_ref(trans, root, bytenr, blocksize,
+ &refs);
+ BUG_ON(ret);
+ if (refs > 1) {
+ parent = path->nodes[*level];
+ ret = btrfs_free_extent(trans, root, bytenr,
+ blocksize, parent->start,
+ btrfs_header_owner(parent),
+ btrfs_header_generation(parent),
+ *level - 1, 1);
+ BUG_ON(ret);
+ path->slots[*level]++;
+ btrfs_tree_unlock(next);
+ free_extent_buffer(next);
+ continue;
+ }
+
+ *level = btrfs_header_level(next);
+ path->nodes[*level] = next;
+ path->slots[*level] = 0;
+ path->locks[*level] = 1;
+ cond_resched();
+ }
+out:
+ parent = path->nodes[*level + 1];
+ bytenr = path->nodes[*level]->start;
+ blocksize = path->nodes[*level]->len;
+
+ ret = btrfs_free_extent(trans, root, bytenr, blocksize,
+ parent->start, btrfs_header_owner(parent),
+ btrfs_header_generation(parent), *level, 1);
+ BUG_ON(ret);
+
+ if (path->locks[*level]) {
+ btrfs_tree_unlock(path->nodes[*level]);
+ path->locks[*level] = 0;
+ }
+ free_extent_buffer(path->nodes[*level]);
+ path->nodes[*level] = NULL;
+ *level += 1;
+ cond_resched();
+ return 0;
+}
+
/*
* helper for dropping snapshots. This walks back up the tree in the path
* to find the first node higher up where we haven't yet gone through
*/
static int noinline walk_up_tree(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
- struct btrfs_path *path, int *level)
+ struct btrfs_path *path,
+ int *level, int max_level)
{
u64 root_owner;
u64 root_gen;
int slot;
int ret;
- for(i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
+ for (i = *level; i < max_level && path->nodes[i]; i++) {
slot = path->slots[i];
if (slot < btrfs_header_nritems(path->nodes[i]) - 1) {
struct extent_buffer *node;
root_owner = btrfs_header_owner(parent);
root_gen = btrfs_header_generation(parent);
+
+ clean_tree_block(trans, root, path->nodes[*level]);
ret = btrfs_free_extent(trans, root,
path->nodes[*level]->start,
path->nodes[*level]->len,
parent->start, root_owner,
root_gen, *level, 1);
BUG_ON(ret);
+ if (path->locks[*level]) {
+ btrfs_tree_unlock(path->nodes[*level]);
+ path->locks[*level] = 0;
+ }
free_extent_buffer(path->nodes[*level]);
path->nodes[*level] = NULL;
*level = i + 1;
if (wret < 0)
ret = wret;
- wret = walk_up_tree(trans, root, path, &level);
+ wret = walk_up_tree(trans, root, path, &level,
+ BTRFS_MAX_LEVEL);
if (wret > 0)
break;
if (wret < 0)
return ret;
}
+int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
+ struct btrfs_root *root,
+ struct extent_buffer *node,
+ struct extent_buffer *parent)
+{
+ struct btrfs_path *path;
+ int level;
+ int parent_level;
+ int ret = 0;
+ int wret;
+
+ path = btrfs_alloc_path();
+ BUG_ON(!path);
+
+ BUG_ON(!btrfs_tree_locked(parent));
+ parent_level = btrfs_header_level(parent);
+ extent_buffer_get(parent);
+ path->nodes[parent_level] = parent;
+ path->slots[parent_level] = btrfs_header_nritems(parent);
+
+ BUG_ON(!btrfs_tree_locked(node));
+ level = btrfs_header_level(node);
+ extent_buffer_get(node);
+ path->nodes[level] = node;
+ path->slots[level] = 0;
+
+ while (1) {
+ wret = walk_down_subtree(trans, root, path, &level);
+ if (wret < 0)
+ ret = wret;
+ if (wret != 0)
+ break;
+
+ wret = walk_up_tree(trans, root, path, &level, parent_level);
+ if (wret < 0)
+ ret = wret;
+ if (wret != 0)
+ break;
+ }
+
+ btrfs_free_path(path);
+ return ret;
+}
+
static unsigned long calc_ra(unsigned long start, unsigned long last,
unsigned long nr)
{
em->start = extent_key->objectid - offset;
em->len = extent_key->offset;
+ em->block_len = extent_key->offset;
em->block_start = extent_key->objectid;
em->bdev = root->fs_info->fs_devices->latest_bdev;
set_bit(EXTENT_FLAG_PINNED, &em->flags);
u32 num_refs;
int lowest_level;
int current_level;
+ int shared_level;
+
+ struct btrfs_key node_keys[BTRFS_MAX_LEVEL];
+ u64 new_nodes[BTRFS_MAX_LEVEL];
};
struct disk_extent {
+ u64 ram_bytes;
u64 disk_bytenr;
u64 disk_num_bytes;
u64 offset;
u64 num_bytes;
+ u8 compression;
+ u8 encryption;
+ u16 other_encoding;
};
static int is_cowonly_root(u64 root_objectid)
if (!path)
return -ENOMEM;
- mutex_lock(&extent_root->fs_info->alloc_mutex);
-
if (first_time) {
ref_path->lowest_level = -1;
ref_path->current_level = -1;
+ ref_path->shared_level = -1;
goto walk_up;
}
walk_down:
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
if (found_key.objectid == bytenr &&
- found_key.type == BTRFS_EXTENT_REF_KEY)
+ found_key.type == BTRFS_EXTENT_REF_KEY) {
+ if (level < ref_path->shared_level)
+ ref_path->shared_level = level;
goto found;
+ }
next:
level--;
btrfs_release_path(extent_root, path);
if (need_resched()) {
- mutex_unlock(&extent_root->fs_info->alloc_mutex);
cond_resched();
- mutex_lock(&extent_root->fs_info->alloc_mutex);
}
}
/* reached lowest level */
btrfs_release_path(extent_root, path);
if (need_resched()) {
- mutex_unlock(&extent_root->fs_info->alloc_mutex);
cond_resched();
- mutex_lock(&extent_root->fs_info->alloc_mutex);
}
}
/* reached max tree level, but no tree root found. */
BUG();
out:
- mutex_unlock(&extent_root->fs_info->alloc_mutex);
btrfs_free_path(path);
return ret;
}
btrfs_file_extent_disk_num_bytes(leaf, fi);
exts[nr].offset = btrfs_file_extent_offset(leaf, fi);
exts[nr].num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
+ exts[nr].ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
+ exts[nr].compression = btrfs_file_extent_compression(leaf, fi);
+ exts[nr].encryption = btrfs_file_extent_encryption(leaf, fi);
+ exts[nr].other_encoding = btrfs_file_extent_other_encoding(leaf,
+ fi);
WARN_ON(exts[nr].offset > 0);
WARN_ON(exts[nr].num_bytes != exts[nr].disk_num_bytes);
new_extents[0].disk_bytenr);
btrfs_set_file_extent_disk_num_bytes(leaf, fi,
new_extents[0].disk_num_bytes);
+ btrfs_set_file_extent_ram_bytes(leaf, fi,
+ new_extents[0].ram_bytes);
ext_offset += new_extents[0].offset;
btrfs_set_file_extent_offset(leaf, fi, ext_offset);
btrfs_mark_buffer_dirty(leaf);
new_extents[i].disk_bytenr);
btrfs_set_file_extent_disk_num_bytes(leaf, fi,
new_extents[i].disk_num_bytes);
+ btrfs_set_file_extent_ram_bytes(leaf, fi,
+ new_extents[i].ram_bytes);
+
+ btrfs_set_file_extent_compression(leaf, fi,
+ new_extents[i].compression);
+ btrfs_set_file_extent_encryption(leaf, fi,
+ new_extents[i].encryption);
+ btrfs_set_file_extent_other_encoding(leaf, fi,
+ new_extents[i].other_encoding);
+
btrfs_set_file_extent_num_bytes(leaf, fi,
extent_len);
ext_offset += new_extents[i].offset;
return ret;
}
-int btrfs_add_reloc_mapping(struct btrfs_root *root, u64 orig_bytenr,
- u64 num_bytes, u64 new_bytenr)
-{
- set_extent_bits(&root->fs_info->reloc_mapping_tree,
- orig_bytenr, orig_bytenr + num_bytes - 1,
- EXTENT_LOCKED, GFP_NOFS);
- set_state_private(&root->fs_info->reloc_mapping_tree,
- orig_bytenr, new_bytenr);
- return 0;
-}
-
-int btrfs_get_reloc_mapping(struct btrfs_root *root, u64 orig_bytenr,
- u64 num_bytes, u64 *new_bytenr)
-{
- u64 bytenr;
- u64 cur_bytenr = orig_bytenr;
- u64 prev_bytenr = orig_bytenr;
- int ret;
-
- while (1) {
- ret = get_state_private(&root->fs_info->reloc_mapping_tree,
- cur_bytenr, &bytenr);
- if (ret)
- break;
- prev_bytenr = cur_bytenr;
- cur_bytenr = bytenr;
- }
-
- if (orig_bytenr == cur_bytenr)
- return -ENOENT;
-
- if (prev_bytenr != orig_bytenr) {
- set_state_private(&root->fs_info->reloc_mapping_tree,
- orig_bytenr, cur_bytenr);
- }
- *new_bytenr = cur_bytenr;
- return 0;
-}
-
-void btrfs_free_reloc_mappings(struct btrfs_root *root)
-{
- clear_extent_bits(&root->fs_info->reloc_mapping_tree,
- 0, (u64)-1, -1, GFP_NOFS);
-}
-
int btrfs_reloc_tree_cache_ref(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct extent_buffer *buf, u64 orig_start)
ref->extents[ext_index].num_bytes = new_extent->disk_num_bytes;
btrfs_set_file_extent_generation(leaf, fi, trans->transid);
+ btrfs_set_file_extent_ram_bytes(leaf, fi,
+ new_extent->ram_bytes);
btrfs_set_file_extent_disk_bytenr(leaf, fi,
new_extent->disk_bytenr);
btrfs_set_file_extent_disk_num_bytes(leaf, fi,
return 0;
}
-int btrfs_free_reloc_root(struct btrfs_root *root)
+int btrfs_free_reloc_root(struct btrfs_trans_handle *trans,
+ struct btrfs_root *root)
{
struct btrfs_root *reloc_root;
+ int ret;
if (root->reloc_root) {
reloc_root = root->reloc_root;
root->reloc_root = NULL;
list_add(&reloc_root->dead_list,
&root->fs_info->dead_reloc_roots);
+
+ btrfs_set_root_bytenr(&reloc_root->root_item,
+ reloc_root->node->start);
+ btrfs_set_root_level(&root->root_item,
+ btrfs_header_level(reloc_root->node));
+ memset(&reloc_root->root_item.drop_progress, 0,
+ sizeof(struct btrfs_disk_key));
+ reloc_root->root_item.drop_level = 0;
+
+ ret = btrfs_update_root(trans, root->fs_info->tree_root,
+ &reloc_root->root_key,
+ &reloc_root->root_item);
+ BUG_ON(ret);
}
return 0;
}
btrfs_set_root_refs(root_item, 0);
btrfs_set_root_bytenr(root_item, eb->start);
btrfs_set_root_level(root_item, btrfs_header_level(eb));
- memset(&root_item->drop_progress, 0, sizeof(root_item->drop_progress));
- root_item->drop_level = 0;
+ btrfs_set_root_generation(root_item, trans->transid);
btrfs_tree_unlock(eb);
free_extent_buffer(eb);
* Core function of space balance.
*
* The idea is using reloc trees to relocate tree blocks in reference
- * counted roots. There is one reloc tree for each subvol, all reloc
- * trees share same key objectid. Reloc trees are snapshots of the
- * latest committed roots (subvol root->commit_root). To relocate a tree
- * block referenced by a subvol, the code COW the block through the reloc
- * tree, then update pointer in the subvol to point to the new block.
- * Since all reloc trees share same key objectid, we can easily do special
- * handing to share tree blocks between reloc trees. Once a tree block has
- * been COWed in one reloc tree, we can use the result when the same block
- * is COWed again through other reloc trees.
+ * counted roots. There is one reloc tree for each subvol, and all
+ * reloc trees share same root key objectid. Reloc trees are snapshots
+ * of the latest committed roots of subvols (root->commit_root).
+ *
+ * To relocate a tree block referenced by a subvol, there are two steps.
+ * COW the block through subvol's reloc tree, then update block pointer
+ * in the subvol to point to the new block. Since all reloc trees share
+ * same root key objectid, doing special handing for tree blocks owned
+ * by them is easy. Once a tree block has been COWed in one reloc tree,
+ * we can use the resulting new block directly when the same block is
+ * required to COW again through other reloc trees. By this way, relocated
+ * tree blocks are shared between reloc trees, so they are also shared
+ * between subvols.
*/
static int noinline relocate_one_path(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct btrfs_key *keys;
u64 *nodes;
int level;
- int lowest_merge;
+ int shared_level;
int lowest_level = 0;
- int update_refs;
int ret;
if (ref_path->owner_objectid < BTRFS_FIRST_FREE_OBJECTID)
lowest_level = ref_path->owner_objectid;
- if (is_cowonly_root(ref_path->root_objectid)) {
+ if (!root->ref_cows) {
path->lowest_level = lowest_level;
ret = btrfs_search_slot(trans, root, first_key, path, 0, 1);
BUG_ON(ret < 0);
return 0;
}
- keys = kzalloc(sizeof(*keys) * BTRFS_MAX_LEVEL, GFP_NOFS);
- BUG_ON(!keys);
- nodes = kzalloc(sizeof(*nodes) * BTRFS_MAX_LEVEL, GFP_NOFS);
- BUG_ON(!nodes);
-
mutex_lock(&root->fs_info->tree_reloc_mutex);
ret = init_reloc_tree(trans, root);
BUG_ON(ret);
reloc_root = root->reloc_root;
- path->lowest_level = lowest_level;
- ret = btrfs_search_slot(trans, reloc_root, first_key, path, 0, 0);
- BUG_ON(ret);
- /*
- * get relocation mapping for tree blocks in the path
- */
- lowest_merge = BTRFS_MAX_LEVEL;
- for (level = BTRFS_MAX_LEVEL - 1; level >= lowest_level; level--) {
- u64 new_bytenr;
- eb = path->nodes[level];
- if (!eb || eb == reloc_root->node)
- continue;
- ret = btrfs_get_reloc_mapping(reloc_root, eb->start, eb->len,
- &new_bytenr);
- if (ret)
- continue;
- if (level == 0)
- btrfs_item_key_to_cpu(eb, &keys[level], 0);
- else
- btrfs_node_key_to_cpu(eb, &keys[level], 0);
- nodes[level] = new_bytenr;
- lowest_merge = level;
- }
+ shared_level = ref_path->shared_level;
+ ref_path->shared_level = BTRFS_MAX_LEVEL - 1;
- update_refs = 0;
- if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
- eb = path->nodes[0];
- if (btrfs_header_generation(eb) < trans->transid)
- update_refs = 1;
- }
+ keys = ref_path->node_keys;
+ nodes = ref_path->new_nodes;
+ memset(&keys[shared_level + 1], 0,
+ sizeof(*keys) * (BTRFS_MAX_LEVEL - shared_level - 1));
+ memset(&nodes[shared_level + 1], 0,
+ sizeof(*nodes) * (BTRFS_MAX_LEVEL - shared_level - 1));
- btrfs_release_path(reloc_root, path);
- /*
- * merge tree blocks that already relocated in other reloc trees
- */
- if (lowest_merge != BTRFS_MAX_LEVEL) {
+ if (nodes[lowest_level] == 0) {
+ path->lowest_level = lowest_level;
+ ret = btrfs_search_slot(trans, reloc_root, first_key, path,
+ 0, 1);
+ BUG_ON(ret);
+ for (level = lowest_level; level < BTRFS_MAX_LEVEL; level++) {
+ eb = path->nodes[level];
+ if (!eb || eb == reloc_root->node)
+ break;
+ nodes[level] = eb->start;
+ if (level == 0)
+ btrfs_item_key_to_cpu(eb, &keys[level], 0);
+ else
+ btrfs_node_key_to_cpu(eb, &keys[level], 0);
+ }
+ if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
+ eb = path->nodes[0];
+ ret = replace_extents_in_leaf(trans, reloc_root, eb,
+ group, reloc_inode);
+ BUG_ON(ret);
+ }
+ btrfs_release_path(reloc_root, path);
+ } else {
ret = btrfs_merge_path(trans, reloc_root, keys, nodes,
- lowest_merge);
- BUG_ON(ret < 0);
- }
- /*
- * cow any tree blocks that still haven't been relocated
- */
- ret = btrfs_search_slot(trans, reloc_root, first_key, path, 0, 1);
- BUG_ON(ret);
- /*
- * if we are relocating data block group, update extent pointers
- * in the newly created tree leaf.
- */
- eb = path->nodes[0];
- if (update_refs && nodes[0] != eb->start) {
- ret = replace_extents_in_leaf(trans, reloc_root, eb, group,
- reloc_inode);
+ lowest_level);
BUG_ON(ret);
}
- memset(keys, 0, sizeof(*keys) * BTRFS_MAX_LEVEL);
- memset(nodes, 0, sizeof(*nodes) * BTRFS_MAX_LEVEL);
- for (level = BTRFS_MAX_LEVEL - 1; level >= lowest_level; level--) {
- eb = path->nodes[level];
- if (!eb || eb == reloc_root->node)
- continue;
- BUG_ON(btrfs_header_owner(eb) != BTRFS_TREE_RELOC_OBJECTID);
- nodes[level] = eb->start;
- if (level == 0)
- btrfs_item_key_to_cpu(eb, &keys[level], 0);
- else
- btrfs_node_key_to_cpu(eb, &keys[level], 0);
- }
-
- if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
- eb = path->nodes[0];
- extent_buffer_get(eb);
- }
- btrfs_release_path(reloc_root, path);
/*
* replace tree blocks in the fs tree with tree blocks in
* the reloc tree.
BUG_ON(ret < 0);
if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
+ ret = btrfs_search_slot(trans, reloc_root, first_key, path,
+ 0, 0);
+ BUG_ON(ret);
+ extent_buffer_get(path->nodes[0]);
+ eb = path->nodes[0];
+ btrfs_release_path(reloc_root, path);
ret = invalidate_extent_cache(reloc_root, eb, group, root);
BUG_ON(ret);
free_extent_buffer(eb);
}
- mutex_unlock(&root->fs_info->tree_reloc_mutex);
+ mutex_unlock(&root->fs_info->tree_reloc_mutex);
path->lowest_level = 0;
- kfree(nodes);
- kfree(keys);
return 0;
}
struct btrfs_ref_path *ref_path)
{
int ret;
- int needs_lock = 0;
-
- if (root == root->fs_info->extent_root ||
- root == root->fs_info->chunk_root ||
- root == root->fs_info->dev_root) {
- needs_lock = 1;
- mutex_lock(&root->fs_info->alloc_mutex);
- }
ret = relocate_one_path(trans, root, path, first_key,
ref_path, NULL, NULL);
if (root == root->fs_info->extent_root)
btrfs_extent_post_op(trans, root);
- if (needs_lock)
- mutex_unlock(&root->fs_info->alloc_mutex);
return 0;
}
{
int ret;
- mutex_lock(&extent_root->fs_info->alloc_mutex);
ret = btrfs_search_slot(trans, extent_root, extent_key, path, -1, 1);
if (ret)
goto out;
ret = btrfs_del_item(trans, extent_root, path);
out:
btrfs_release_path(extent_root, path);
- mutex_unlock(&extent_root->fs_info->alloc_mutex);
return ret;
}
struct btrfs_key first_key;
u64 prev_block = 0;
- mutex_unlock(&extent_root->fs_info->alloc_mutex);
trans = btrfs_start_transaction(extent_root, 1);
BUG_ON(!trans);
btrfs_end_transaction(trans, extent_root);
kfree(new_extents);
kfree(ref_path);
- mutex_lock(&extent_root->fs_info->alloc_mutex);
return ret;
}
spin_lock(&shrink_block_group->lock);
if (btrfs_block_group_used(&shrink_block_group->item) > 0) {
spin_unlock(&shrink_block_group->lock);
- mutex_unlock(&root->fs_info->alloc_mutex);
trans = btrfs_start_transaction(root, 1);
- mutex_lock(&root->fs_info->alloc_mutex);
spin_lock(&shrink_block_group->lock);
new_alloc_flags = update_block_group_flags(root,
do_chunk_alloc(trans, root->fs_info->extent_root,
calc + 2 * 1024 * 1024, new_alloc_flags, force);
- mutex_unlock(&root->fs_info->alloc_mutex);
btrfs_end_transaction(trans, root);
- mutex_lock(&root->fs_info->alloc_mutex);
} else
spin_unlock(&shrink_block_group->lock);
return 0;
BUG_ON(err);
err = btrfs_insert_file_extent(trans, root, objectid, 0, 0, 0,
- group->key.offset, 0);
+ group->key.offset, 0, group->key.offset,
+ 0, 0, 0);
BUG_ON(err);
inode = btrfs_iget_locked(root->fs_info->sb, objectid, root);
reloc_inode = create_reloc_inode(info, block_group);
BUG_ON(IS_ERR(reloc_inode));
- mutex_lock(&root->fs_info->alloc_mutex);
-
__alloc_chunk_for_shrink(root, block_group, 1);
block_group->ro = 1;
block_group->space_info->total_bytes -= block_group->key.offset;
- mutex_unlock(&root->fs_info->alloc_mutex);
-
btrfs_start_delalloc_inodes(info->tree_root);
btrfs_wait_ordered_extents(info->tree_root, 0);
again:
btrfs_remove_leaf_refs(info->tree_root, (u64)-1, 1);
mutex_unlock(&root->fs_info->cleaner_mutex);
- mutex_lock(&root->fs_info->alloc_mutex);
-
while(1) {
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
if (ret < 0)
if (progress && need_resched()) {
btrfs_release_path(root, path);
- mutex_unlock(&root->fs_info->alloc_mutex);
cond_resched();
- mutex_lock(&root->fs_info->alloc_mutex);
progress = 0;
continue;
}
}
btrfs_release_path(root, path);
- mutex_unlock(&root->fs_info->alloc_mutex);
if (pass == 0) {
btrfs_wait_ordered_range(reloc_inode, 0, (u64)-1);
trans = btrfs_start_transaction(info->tree_root, 1);
btrfs_commit_transaction(trans, info->tree_root);
- mutex_lock(&root->fs_info->alloc_mutex);
-
spin_lock(&block_group->lock);
WARN_ON(block_group->pinned > 0);
WARN_ON(block_group->reserved > 0);
spin_unlock(&block_group->lock);
ret = 0;
out:
- mutex_unlock(&root->fs_info->alloc_mutex);
btrfs_free_path(path);
return ret;
}
struct btrfs_block_group_cache *block_group;
struct rb_node *n;
- mutex_lock(&info->alloc_mutex);
spin_lock(&info->block_group_cache_lock);
while ((n = rb_last(&info->block_group_cache_tree)) != NULL) {
block_group = rb_entry(n, struct btrfs_block_group_cache,
rb_erase(&block_group->cache_node,
&info->block_group_cache_tree);
- spin_lock(&block_group->space_info->lock);
+ down_write(&block_group->space_info->groups_sem);
list_del(&block_group->list);
- spin_unlock(&block_group->space_info->lock);
+ up_write(&block_group->space_info->groups_sem);
kfree(block_group);
}
spin_unlock(&info->block_group_cache_lock);
- mutex_unlock(&info->alloc_mutex);
return 0;
}
if (!path)
return -ENOMEM;
- mutex_lock(&root->fs_info->alloc_mutex);
while(1) {
ret = find_first_block_group(root, path, &key);
if (ret > 0) {
}
spin_lock_init(&cache->lock);
+ mutex_init(&cache->alloc_mutex);
INIT_LIST_HEAD(&cache->list);
read_extent_buffer(leaf, &cache->item,
btrfs_item_ptr_offset(leaf, path->slots[0]),
&space_info);
BUG_ON(ret);
cache->space_info = space_info;
- spin_lock(&space_info->lock);
- list_add(&cache->list, &space_info->block_groups);
- spin_unlock(&space_info->lock);
+ down_write(&space_info->groups_sem);
+ list_add_tail(&cache->list, &space_info->block_groups);
+ up_write(&space_info->groups_sem);
ret = btrfs_add_block_group_cache(root->fs_info, cache);
BUG_ON(ret);
ret = 0;
error:
btrfs_free_path(path);
- mutex_unlock(&root->fs_info->alloc_mutex);
return ret;
}
struct btrfs_root *extent_root;
struct btrfs_block_group_cache *cache;
- WARN_ON(!mutex_is_locked(&root->fs_info->alloc_mutex));
extent_root = root->fs_info->extent_root;
root->fs_info->last_trans_new_blockgroup = trans->transid;
cache->key.objectid = chunk_offset;
cache->key.offset = size;
spin_lock_init(&cache->lock);
+ mutex_init(&cache->alloc_mutex);
INIT_LIST_HEAD(&cache->list);
btrfs_set_key_type(&cache->key, BTRFS_BLOCK_GROUP_ITEM_KEY);
ret = update_space_info(root->fs_info, cache->flags, size, bytes_used,
&cache->space_info);
BUG_ON(ret);
- spin_lock(&cache->space_info->lock);
- list_add(&cache->list, &cache->space_info->block_groups);
- spin_unlock(&cache->space_info->lock);
+ down_write(&cache->space_info->groups_sem);
+ list_add_tail(&cache->list, &cache->space_info->block_groups);
+ up_write(&cache->space_info->groups_sem);
ret = btrfs_add_block_group_cache(root->fs_info, cache);
BUG_ON(ret);
sizeof(cache->item));
BUG_ON(ret);
- finish_current_insert(trans, extent_root);
- ret = del_pending_extents(trans, extent_root);
+ finish_current_insert(trans, extent_root, 0);
+ ret = del_pending_extents(trans, extent_root, 0);
BUG_ON(ret);
set_avail_alloc_bits(extent_root->fs_info, type);
struct btrfs_key key;
int ret;
- BUG_ON(!mutex_is_locked(&root->fs_info->alloc_mutex));
root = root->fs_info->extent_root;
block_group = btrfs_lookup_block_group(root->fs_info, group_start);
btrfs_remove_free_space_cache(block_group);
rb_erase(&block_group->cache_node,
&root->fs_info->block_group_cache_tree);
- spin_lock(&block_group->space_info->lock);
+ down_write(&block_group->space_info->groups_sem);
list_del(&block_group->list);
- spin_unlock(&block_group->space_info->lock);
+ up_write(&block_group->space_info->groups_sem);
/*
memset(shrink_block_group, 0, sizeof(*shrink_block_group));
projects / mv-sheeva.git / blobdiff