Skip to content

Commit

Permalink
Btrfs: fix leaking block group on balance
Browse files Browse the repository at this point in the history 
The block group structs are referenced in many different
places, and it's not safe to free while balancing.  So, those block
group structs were simply leaked instead.

This patch replaces the block group pointer in the inode with the starting byte
offset of the block group and adds reference counting to the block group
struct.

Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
  • Loading branch information
Yan Zheng authored and Chris Mason committed Dec 11, 2008
1 parent cfc8ea8 commit d2fb343
Show file tree
Hide file tree
Showing 7 changed files with 88 additions and 118 deletions.
8 changes: 3 additions & 5 deletions fs/btrfs/btrfs_inode.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,11 +28,6 @@ struct btrfs_inode {
/* which subvolume this inode belongs to */
struct btrfs_root *root;

/* the block group preferred for allocations. This pointer is buggy
* and needs to be replaced with a bytenr instead
*/
struct btrfs_block_group_cache *block_group;

/* key used to find this inode on disk. This is used by the code
* to read in roots of subvolumes
*/
Expand Down Expand Up @@ -115,6 +110,9 @@ struct btrfs_inode {
*/
u64 index_cnt;

/* the start of block group preferred for allocations. */
u64 block_group;

struct inode vfs_inode;
};

Expand Down
17 changes: 9 additions & 8 deletions fs/btrfs/ctree.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -653,6 +653,9 @@ struct btrfs_block_group_cache {

/* for block groups in the same raid type */
struct list_head list;

/* usage count */
atomic_t count;
};

struct btrfs_leaf_ref_tree {
Expand Down Expand Up @@ -1706,10 +1709,8 @@ int btrfs_copy_pinned(struct btrfs_root *root, struct extent_io_tree *copy);
struct btrfs_block_group_cache *btrfs_lookup_block_group(struct
btrfs_fs_info *info,
u64 bytenr);
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);
u64 btrfs_find_block_group(struct btrfs_root *root,
u64 search_start, u64 search_hint, int owner);
struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
u32 blocksize, u64 parent,
Expand Down Expand Up @@ -1770,6 +1771,7 @@ int btrfs_update_extent_ref(struct btrfs_trans_handle *trans,
u64 owner_objectid);
int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
struct btrfs_root *root);
int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
int btrfs_free_block_groups(struct btrfs_fs_info *info);
int btrfs_read_block_groups(struct btrfs_root *root);
int btrfs_make_block_group(struct btrfs_trans_handle *trans,
Expand Down Expand Up @@ -2019,10 +2021,9 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root);
int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end);
int btrfs_writepages(struct address_space *mapping,
struct writeback_control *wbc);
int btrfs_create_subvol_root(struct btrfs_root *new_root, struct dentry *dentry,
struct btrfs_trans_handle *trans, u64 new_dirid,
struct btrfs_block_group_cache *block_group);

int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
struct btrfs_root *new_root, struct dentry *dentry,
u64 new_dirid, u64 alloc_hint);
int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
size_t size, struct bio *bio, unsigned long bio_flags);

Expand Down
132 changes: 60 additions & 72 deletions fs/btrfs/extent-tree.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -53,10 +53,6 @@ static int finish_current_insert(struct btrfs_trans_handle *trans, struct
btrfs_root *extent_root, int all);
static int del_pending_extents(struct btrfs_trans_handle *trans, struct
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);
static int pin_down_bytes(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
u64 bytenr, u64 num_bytes, int is_data);
Expand Down Expand Up @@ -142,6 +138,8 @@ block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr,
break;
}
}
if (ret)
atomic_inc(&ret->count);
spin_unlock(&info->block_group_cache_lock);

return ret;
Expand Down Expand Up @@ -318,6 +316,12 @@ struct btrfs_block_group_cache *btrfs_lookup_block_group(struct
return cache;
}

static inline void put_block_group(struct btrfs_block_group_cache *cache)
{
if (atomic_dec_and_test(&cache->count))
kfree(cache);
}

static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
u64 flags)
{
Expand All @@ -341,54 +345,16 @@ static u64 div_factor(u64 num, int factor)
return num;
}

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)
u64 btrfs_find_block_group(struct btrfs_root *root,
u64 search_start, u64 search_hint, int owner)
{
struct btrfs_block_group_cache *cache;
struct btrfs_block_group_cache *found_group = NULL;
struct btrfs_fs_info *info = root->fs_info;
u64 used;
u64 last = 0;
u64 free_check;
u64 last = max(search_hint, search_start);
u64 group_start = 0;
int full_search = 0;
int factor = 10;
int factor = 9;
int wrapped = 0;

if (data & BTRFS_BLOCK_GROUP_METADATA)
factor = 9;

if (search_start) {
struct btrfs_block_group_cache *shint;
shint = btrfs_lookup_first_block_group(info, search_start);
if (shint && block_group_bits(shint, data)) {
spin_lock(&shint->lock);
used = btrfs_block_group_used(&shint->item);
if (used + shint->pinned + shint->reserved <
div_factor(shint->key.offset, factor)) {
spin_unlock(&shint->lock);
return shint;
}
spin_unlock(&shint->lock);
}
}
if (hint && block_group_bits(hint, data)) {
spin_lock(&hint->lock);
used = btrfs_block_group_used(&hint->item);
if (used + hint->pinned + hint->reserved <
div_factor(hint->key.offset, factor)) {
spin_unlock(&hint->lock);
return hint;
}
spin_unlock(&hint->lock);
last = hint->key.objectid + hint->key.offset;
} else {
if (hint)
last = max(hint->key.objectid, search_start);
else
last = search_start;
}
again:
while (1) {
cache = btrfs_lookup_first_block_group(root->fs_info, last);
Expand All @@ -399,16 +365,18 @@ __btrfs_find_block_group(struct btrfs_root *root,
last = cache->key.objectid + cache->key.offset;
used = btrfs_block_group_used(&cache->item);

if (block_group_bits(cache, data)) {
free_check = div_factor(cache->key.offset, factor);
if ((full_search || !cache->ro) &&
block_group_bits(cache, BTRFS_BLOCK_GROUP_METADATA)) {
if (used + cache->pinned + cache->reserved <
free_check) {
found_group = cache;
div_factor(cache->key.offset, factor)) {
group_start = cache->key.objectid;
spin_unlock(&cache->lock);
put_block_group(cache);
goto found;
}
}
spin_unlock(&cache->lock);
put_block_group(cache);
cond_resched();
}
if (!wrapped) {
Expand All @@ -423,18 +391,7 @@ __btrfs_find_block_group(struct btrfs_root *root,
goto again;
}
found:
return found_group;
}

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)
{

struct btrfs_block_group_cache *ret;
ret = __btrfs_find_block_group(root, hint, search_start, data, owner);
return ret;
return group_start;
}

/* simple helper to search for an existing extent at a given offset */
Expand Down Expand Up @@ -1809,6 +1766,19 @@ int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
return werr;
}

int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr)
{
struct btrfs_block_group_cache *block_group;
int readonly = 0;

block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
if (!block_group || block_group->ro)
readonly = 1;
if (block_group)
put_block_group(block_group);
return readonly;
}

static int update_space_info(struct btrfs_fs_info *info, u64 flags,
u64 total_bytes, u64 bytes_used,
struct btrfs_space_info **space_info)
Expand Down Expand Up @@ -1995,10 +1965,10 @@ static int update_block_group(struct btrfs_trans_handle *trans,
int ret;
ret = btrfs_add_free_space(cache, bytenr,
num_bytes);
if (ret)
return -1;
WARN_ON(ret);
}
}
put_block_group(cache);
total -= num_bytes;
bytenr += num_bytes;
}
Expand All @@ -2008,12 +1978,16 @@ static int update_block_group(struct btrfs_trans_handle *trans,
static u64 first_logical_byte(struct btrfs_root *root, u64 search_start)
{
struct btrfs_block_group_cache *cache;
u64 bytenr;

cache = btrfs_lookup_first_block_group(root->fs_info, search_start);
if (!cache)
return 0;

return cache->key.objectid;
bytenr = cache->key.objectid;
put_block_group(cache);

return bytenr;
}

int btrfs_update_pinned_extents(struct btrfs_root *root,
Expand Down Expand Up @@ -2055,6 +2029,7 @@ int btrfs_update_pinned_extents(struct btrfs_root *root,
if (cache->cached)
btrfs_add_free_space(cache, bytenr, len);
}
put_block_group(cache);
bytenr += len;
num -= len;
}
Expand Down Expand Up @@ -2085,6 +2060,7 @@ static int update_reserved_extents(struct btrfs_root *root,
}
spin_unlock(&cache->lock);
spin_unlock(&cache->space_info->lock);
put_block_group(cache);
bytenr += len;
num -= len;
}
Expand Down Expand Up @@ -2724,6 +2700,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
cache = btrfs_lookup_block_group(root->fs_info, bytenr);
BUG_ON(!cache);
btrfs_add_free_space(cache, bytenr, num_bytes);
put_block_group(cache);
update_reserved_extents(root, bytenr, num_bytes, 0);
return 0;
}
Expand Down Expand Up @@ -2928,6 +2905,8 @@ static int noinline find_free_extent(struct btrfs_trans_handle *trans,
}
new_group:
mutex_unlock(&block_group->alloc_mutex);
put_block_group(block_group);
block_group = NULL;
new_group_no_lock:
/* don't try to compare new allocations against the
* last allocation any more
Expand Down Expand Up @@ -2997,14 +2976,16 @@ static int noinline find_free_extent(struct btrfs_trans_handle *trans,

block_group = list_entry(cur, struct btrfs_block_group_cache,
list);
atomic_inc(&block_group->count);

search_start = block_group->key.objectid;
cur = cur->next;
}

/* we found what we needed */
if (ins->objectid) {
if (!(data & BTRFS_BLOCK_GROUP_DATA))
trans->block_group = block_group;
trans->block_group = block_group->key.objectid;

if (last_ptr)
*last_ptr = ins->objectid + ins->offset;
Expand All @@ -3015,6 +2996,8 @@ static int noinline find_free_extent(struct btrfs_trans_handle *trans,
loop, allowed_chunk_alloc);
ret = -ENOSPC;
}
if (block_group)
put_block_group(block_group);

up_read(&space_info->groups_sem);
return ret;
Expand Down Expand Up @@ -3124,6 +3107,7 @@ int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len)
return -ENOSPC;
}
btrfs_add_free_space(cache, start, len);
put_block_group(cache);
update_reserved_extents(root, start, len, 0);
return 0;
}
Expand Down Expand Up @@ -3288,6 +3272,7 @@ int btrfs_alloc_logged_extent(struct btrfs_trans_handle *trans,
ret = btrfs_remove_free_space(block_group, ins->objectid,
ins->offset);
BUG_ON(ret);
put_block_group(block_group);
ret = __btrfs_alloc_reserved_extent(trans, root, parent, root_objectid,
ref_generation, owner, ins);
return ret;
Expand Down Expand Up @@ -5703,6 +5688,7 @@ int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start)
WARN_ON(block_group->reserved > 0);
WARN_ON(btrfs_block_group_used(&block_group->item) > 0);
spin_unlock(&block_group->lock);
put_block_group(block_group);
ret = 0;
out:
btrfs_free_path(path);
Expand Down Expand Up @@ -5763,6 +5749,8 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info)
down_write(&block_group->space_info->groups_sem);
list_del(&block_group->list);
up_write(&block_group->space_info->groups_sem);

WARN_ON(atomic_read(&block_group->count) != 1);
kfree(block_group);

spin_lock(&info->block_group_cache_lock);
Expand Down Expand Up @@ -5807,6 +5795,7 @@ int btrfs_read_block_groups(struct btrfs_root *root)
break;
}

atomic_set(&cache->count, 1);
spin_lock_init(&cache->lock);
mutex_init(&cache->alloc_mutex);
mutex_init(&cache->cache_mutex);
Expand Down Expand Up @@ -5861,11 +5850,12 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,

cache->key.objectid = chunk_offset;
cache->key.offset = size;
cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
atomic_set(&cache->count, 1);
spin_lock_init(&cache->lock);
mutex_init(&cache->alloc_mutex);
mutex_init(&cache->cache_mutex);
INIT_LIST_HEAD(&cache->list);
btrfs_set_key_type(&cache->key, BTRFS_BLOCK_GROUP_ITEM_KEY);

btrfs_set_block_group_used(&cache->item, bytes_used);
btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);
Expand Down Expand Up @@ -5926,10 +5916,8 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
spin_unlock(&block_group->space_info->lock);
block_group->space_info->full = 0;

/*
memset(shrink_block_group, 0, sizeof(*shrink_block_group));
kfree(shrink_block_group);
*/
put_block_group(block_group);
put_block_group(block_group);

ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
if (ret > 0)
Expand Down
Loading

0 comments on commit d2fb343

Please sign in to comment.