Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-29 06:12:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'cleanup/blocksize-diet-part1' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux into for-linus

Browse Source
This commit is contained in:
Chris Mason 2014-10-04 09:57:14 -07:00
commit 27b19cc886
9 changed files with 57 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
fs/btrfs/backref.c
View File

@ -490,7 +490,7 @@ static int __add_missing_keys(struct btrfs_fs_info *fs_info,
continue; continue;
BUG_ON(!ref->wanted_disk_byte); BUG_ON(!ref->wanted_disk_byte);
eb = read_tree_block(fs_info->tree_root, ref->wanted_disk_byte, eb = read_tree_block(fs_info->tree_root, ref->wanted_disk_byte,
fs_info->tree_root->nodesize, 0); 0);
if (!eb || !extent_buffer_uptodate(eb)) { if (!eb || !extent_buffer_uptodate(eb)) {
free_extent_buffer(eb); free_extent_buffer(eb);
return -EIO; return -EIO;
@ -1028,12 +1028,10 @@ again:
if (ref->count && ref->parent) { if (ref->count && ref->parent) {
if (extent_item_pos && !ref->inode_list && if (extent_item_pos && !ref->inode_list &&
ref->level == 0) { ref->level == 0) {
u32 bsz;
struct extent_buffer *eb; struct extent_buffer *eb;
bsz = fs_info->extent_root->nodesize;
eb = read_tree_block(fs_info->extent_root, eb = read_tree_block(fs_info->extent_root,
ref->parent, bsz, 0); ref->parent, 0);
if (!eb || !extent_buffer_uptodate(eb)) { if (!eb || !extent_buffer_uptodate(eb)) {
free_extent_buffer(eb); free_extent_buffer(eb);
ret = -EIO; ret = -EIO;

54
fs/btrfs/ctree.c
View File

@ -258,9 +258,8 @@ int btrfs_copy_root(struct btrfs_trans_handle *trans,
else else
btrfs_node_key(buf, &disk_key, 0); btrfs_node_key(buf, &disk_key, 0);
cow = btrfs_alloc_free_block(trans, root, buf->len, 0, cow = btrfs_alloc_tree_block(trans, root, 0, new_root_objectid,
new_root_objectid, &disk_key, level, &disk_key, level, buf->start, 0);
buf->start, 0);
if (IS_ERR(cow)) if (IS_ERR(cow))
return PTR_ERR(cow); return PTR_ERR(cow);
@ -1133,9 +1132,9 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
} else } else
parent_start = 0; parent_start = 0;
cow = btrfs_alloc_free_block(trans, root, buf->len, parent_start, cow = btrfs_alloc_tree_block(trans, root, parent_start,
root->root_key.objectid, &disk_key, root->root_key.objectid, &disk_key, level,
level, search_start, empty_size); search_start, empty_size);
if (IS_ERR(cow)) if (IS_ERR(cow))
return PTR_ERR(cow); return PTR_ERR(cow);
@ -1425,7 +1424,6 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
struct tree_mod_root *old_root = NULL; struct tree_mod_root *old_root = NULL;
u64 old_generation = 0; u64 old_generation = 0;
u64 logical; u64 logical;
u32 blocksize;
eb_root = btrfs_read_lock_root_node(root); eb_root = btrfs_read_lock_root_node(root);
tm = __tree_mod_log_oldest_root(root->fs_info, eb_root, time_seq); tm = __tree_mod_log_oldest_root(root->fs_info, eb_root, time_seq);
@ -1444,8 +1442,7 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
if (old_root && tm && tm->op != MOD_LOG_KEY_REMOVE_WHILE_FREEING) { if (old_root && tm && tm->op != MOD_LOG_KEY_REMOVE_WHILE_FREEING) {
btrfs_tree_read_unlock(eb_root); btrfs_tree_read_unlock(eb_root);
free_extent_buffer(eb_root); free_extent_buffer(eb_root);
blocksize = root->nodesize; old = read_tree_block(root, logical, 0);
old = read_tree_block(root, logical, blocksize, 0);
if (WARN_ON(!old || !extent_buffer_uptodate(old))) { if (WARN_ON(!old || !extent_buffer_uptodate(old))) {
free_extent_buffer(old); free_extent_buffer(old);
btrfs_warn(root->fs_info, btrfs_warn(root->fs_info,
@ -1684,15 +1681,14 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
continue; continue;
} }
cur = btrfs_find_tree_block(root, blocknr, blocksize); cur = btrfs_find_tree_block(root, blocknr);
if (cur) if (cur)
uptodate = btrfs_buffer_uptodate(cur, gen, 0); uptodate = btrfs_buffer_uptodate(cur, gen, 0);
else else
uptodate = 0; uptodate = 0;
if (!cur || !uptodate) { if (!cur || !uptodate) {
if (!cur) { if (!cur) {
cur = read_tree_block(root, blocknr, cur = read_tree_block(root, blocknr, gen);
blocksize, gen);
if (!cur || !extent_buffer_uptodate(cur)) { if (!cur || !extent_buffer_uptodate(cur)) {
free_extent_buffer(cur); free_extent_buffer(cur);
return -EIO; return -EIO;
@ -1871,7 +1867,6 @@ static noinline struct extent_buffer *read_node_slot(struct btrfs_root *root,
BUG_ON(level == 0); BUG_ON(level == 0);
eb = read_tree_block(root, btrfs_node_blockptr(parent, slot), eb = read_tree_block(root, btrfs_node_blockptr(parent, slot),
root->nodesize,
btrfs_node_ptr_generation(parent, slot)); btrfs_node_ptr_generation(parent, slot));
if (eb && !extent_buffer_uptodate(eb)) { if (eb && !extent_buffer_uptodate(eb)) {
free_extent_buffer(eb); free_extent_buffer(eb);
@ -2267,7 +2262,7 @@ static void reada_for_search(struct btrfs_root *root,
search = btrfs_node_blockptr(node, slot); search = btrfs_node_blockptr(node, slot);
blocksize = root->nodesize; blocksize = root->nodesize;
eb = btrfs_find_tree_block(root, search, blocksize); eb = btrfs_find_tree_block(root, search);
if (eb) { if (eb) {
free_extent_buffer(eb); free_extent_buffer(eb);
return; return;
@ -2297,7 +2292,7 @@ static void reada_for_search(struct btrfs_root *root,
if ((search <= target && target - search <= 65536) || if ((search <= target && target - search <= 65536) ||
(search > target && search - target <= 65536)) { (search > target && search - target <= 65536)) {
gen = btrfs_node_ptr_generation(node, nr); gen = btrfs_node_ptr_generation(node, nr);
readahead_tree_block(root, search, blocksize, gen); readahead_tree_block(root, search, blocksize);
nread += blocksize; nread += blocksize;
} }
nscan++; nscan++;
@ -2329,7 +2324,7 @@ static noinline void reada_for_balance(struct btrfs_root *root,
if (slot > 0) { if (slot > 0) {
block1 = btrfs_node_blockptr(parent, slot - 1); block1 = btrfs_node_blockptr(parent, slot - 1);
gen = btrfs_node_ptr_generation(parent, slot - 1); gen = btrfs_node_ptr_generation(parent, slot - 1);
eb = btrfs_find_tree_block(root, block1, blocksize); eb = btrfs_find_tree_block(root, block1);
/* /*
* if we get -eagain from btrfs_buffer_uptodate, we * if we get -eagain from btrfs_buffer_uptodate, we
* don't want to return eagain here. That will loop * don't want to return eagain here. That will loop
@ -2342,16 +2337,16 @@ static noinline void reada_for_balance(struct btrfs_root *root,
if (slot + 1 < nritems) { if (slot + 1 < nritems) {
block2 = btrfs_node_blockptr(parent, slot + 1); block2 = btrfs_node_blockptr(parent, slot + 1);
gen = btrfs_node_ptr_generation(parent, slot + 1); gen = btrfs_node_ptr_generation(parent, slot + 1);
eb = btrfs_find_tree_block(root, block2, blocksize); eb = btrfs_find_tree_block(root, block2);
if (eb && btrfs_buffer_uptodate(eb, gen, 1) != 0) if (eb && btrfs_buffer_uptodate(eb, gen, 1) != 0)
block2 = 0; block2 = 0;
free_extent_buffer(eb); free_extent_buffer(eb);
} }
if (block1) if (block1)
readahead_tree_block(root, block1, blocksize, 0); readahead_tree_block(root, block1, blocksize);
if (block2) if (block2)
readahead_tree_block(root, block2, blocksize, 0); readahead_tree_block(root, block2, blocksize);
} }
@ -2453,16 +2448,14 @@ read_block_for_search(struct btrfs_trans_handle *trans,
{ {
u64 blocknr; u64 blocknr;
u64 gen; u64 gen;
u32 blocksize;
struct extent_buffer *b = *eb_ret; struct extent_buffer *b = *eb_ret;
struct extent_buffer *tmp; struct extent_buffer *tmp;
int ret; int ret;
blocknr = btrfs_node_blockptr(b, slot); blocknr = btrfs_node_blockptr(b, slot);
gen = btrfs_node_ptr_generation(b, slot); gen = btrfs_node_ptr_generation(b, slot);
blocksize = root->nodesize;
tmp = btrfs_find_tree_block(root, blocknr, blocksize); tmp = btrfs_find_tree_block(root, blocknr);
if (tmp) { if (tmp) {
/* first we do an atomic uptodate check */ /* first we do an atomic uptodate check */
if (btrfs_buffer_uptodate(tmp, gen, 1) > 0) { if (btrfs_buffer_uptodate(tmp, gen, 1) > 0) {
@ -2506,7 +2499,7 @@ read_block_for_search(struct btrfs_trans_handle *trans,
btrfs_release_path(p); btrfs_release_path(p);
ret = -EAGAIN; ret = -EAGAIN;
tmp = read_tree_block(root, blocknr, blocksize, 0); tmp = read_tree_block(root, blocknr, 0);
if (tmp) { if (tmp) {
/* /*
* If the read above didn't mark this buffer up to date, * If the read above didn't mark this buffer up to date,
@ -3360,9 +3353,8 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans,
else else
btrfs_node_key(lower, &lower_key, 0); btrfs_node_key(lower, &lower_key, 0);
c = btrfs_alloc_free_block(trans, root, root->nodesize, 0, c = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
root->root_key.objectid, &lower_key, &lower_key, level, root->node->start, 0);
level, root->node->start, 0);
if (IS_ERR(c)) if (IS_ERR(c))
return PTR_ERR(c); return PTR_ERR(c);
@ -3500,9 +3492,8 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
mid = (c_nritems + 1) / 2; mid = (c_nritems + 1) / 2;
btrfs_node_key(c, &disk_key, mid); btrfs_node_key(c, &disk_key, mid);
split = btrfs_alloc_free_block(trans, root, root->nodesize, 0, split = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
root->root_key.objectid, &disk_key, level, c->start, 0);
&disk_key, level, c->start, 0);
if (IS_ERR(split)) if (IS_ERR(split))
return PTR_ERR(split); return PTR_ERR(split);
@ -4280,9 +4271,8 @@ again:
else else
btrfs_item_key(l, &disk_key, mid); btrfs_item_key(l, &disk_key, mid);
right = btrfs_alloc_free_block(trans, root, root->nodesize, 0, right = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid,
root->root_key.objectid, &disk_key, 0, l->start, 0);
&disk_key, 0, l->start, 0);
if (IS_ERR(right)) if (IS_ERR(right))
return PTR_ERR(right); return PTR_ERR(right);

6
fs/btrfs/ctree.h
View File

@ -3291,9 +3291,9 @@ struct btrfs_block_group_cache *btrfs_lookup_block_group(
u64 bytenr); u64 bytenr);
void btrfs_put_block_group(struct btrfs_block_group_cache *cache); void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
int get_block_group_index(struct btrfs_block_group_cache *cache); int get_block_group_index(struct btrfs_block_group_cache *cache);
struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root, u32 blocksize, struct btrfs_root *root, u64 parent,
u64 parent, u64 root_objectid, u64 root_objectid,
struct btrfs_disk_key *key, int level, struct btrfs_disk_key *key, int level,
u64 hint, u64 empty_size); u64 hint, u64 empty_size);
void btrfs_free_tree_block(struct btrfs_trans_handle *trans, void btrfs_free_tree_block(struct btrfs_trans_handle *trans,

37
fs/btrfs/disk-io.c
View File

@ -1073,20 +1073,17 @@ static const struct address_space_operations btree_aops = {
.set_page_dirty = btree_set_page_dirty, .set_page_dirty = btree_set_page_dirty,
}; };
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize, void readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize)
u64 parent_transid)
{ {
struct extent_buffer *buf = NULL; struct extent_buffer *buf = NULL;
struct inode *btree_inode = root->fs_info->btree_inode; struct inode *btree_inode = root->fs_info->btree_inode;
int ret = 0;
buf = btrfs_find_create_tree_block(root, bytenr, blocksize); buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
if (!buf) if (!buf)
return 0; return;
read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree, read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
buf, 0, WAIT_NONE, btree_get_extent, 0); buf, 0, WAIT_NONE, btree_get_extent, 0);
free_extent_buffer(buf); free_extent_buffer(buf);
return ret;
} }
int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize, int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
@ -1122,7 +1119,7 @@ int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
} }
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root, struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
u64 bytenr, u32 blocksize) u64 bytenr)
{ {
return find_extent_buffer(root->fs_info, bytenr); return find_extent_buffer(root->fs_info, bytenr);
} }
@ -1150,12 +1147,12 @@ int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
} }
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr, struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
u32 blocksize, u64 parent_transid) u64 parent_transid)
{ {
struct extent_buffer *buf = NULL; struct extent_buffer *buf = NULL;
int ret; int ret;
buf = btrfs_find_create_tree_block(root, bytenr, blocksize); buf = btrfs_find_create_tree_block(root, bytenr, root->nodesize);
if (!buf) if (!buf)
return NULL; return NULL;
@ -1336,8 +1333,7 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
root->root_key.type = BTRFS_ROOT_ITEM_KEY; root->root_key.type = BTRFS_ROOT_ITEM_KEY;
root->root_key.offset = 0; root->root_key.offset = 0;
leaf = btrfs_alloc_free_block(trans, root, root->nodesize, leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0);
0, objectid, NULL, 0, 0, 0);
if (IS_ERR(leaf)) { if (IS_ERR(leaf)) {
ret = PTR_ERR(leaf); ret = PTR_ERR(leaf);
leaf = NULL; leaf = NULL;
@ -1424,9 +1420,8 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
* updated (along with back refs to the log tree). * updated (along with back refs to the log tree).
*/ */
leaf = btrfs_alloc_free_block(trans, root, root->nodesize, 0, leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
BTRFS_TREE_LOG_OBJECTID, NULL, NULL, 0, 0, 0);
0, 0, 0);
if (IS_ERR(leaf)) { if (IS_ERR(leaf)) {
kfree(root); kfree(root);
return ERR_CAST(leaf); return ERR_CAST(leaf);
@ -1496,7 +1491,6 @@ static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
struct btrfs_fs_info *fs_info = tree_root->fs_info; struct btrfs_fs_info *fs_info = tree_root->fs_info;
struct btrfs_path *path; struct btrfs_path *path;
u64 generation; u64 generation;
u32 blocksize;
int ret; int ret;
path = btrfs_alloc_path(); path = btrfs_alloc_path();
@ -1521,9 +1515,8 @@ static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
} }
generation = btrfs_root_generation(&root->root_item); generation = btrfs_root_generation(&root->root_item);
blocksize = root->nodesize;
root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item), root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
blocksize, generation); generation);
if (!root->node) { if (!root->node) {
ret = -ENOMEM; ret = -ENOMEM;
goto find_fail; goto find_fail;
@ -2151,7 +2144,6 @@ int open_ctree(struct super_block *sb,
{ {
u32 sectorsize; u32 sectorsize;
u32 nodesize; u32 nodesize;
u32 blocksize;
u32 stripesize; u32 stripesize;
u64 generation; u64 generation;
u64 features; u64 features;
@ -2655,7 +2647,6 @@ int open_ctree(struct super_block *sb,
goto fail_sb_buffer; goto fail_sb_buffer;
} }
blocksize = tree_root->nodesize;
generation = btrfs_super_chunk_root_generation(disk_super); generation = btrfs_super_chunk_root_generation(disk_super);
__setup_root(nodesize, sectorsize, stripesize, chunk_root, __setup_root(nodesize, sectorsize, stripesize, chunk_root,
@ -2663,7 +2654,7 @@ int open_ctree(struct super_block *sb,
chunk_root->node = read_tree_block(chunk_root, chunk_root->node = read_tree_block(chunk_root,
btrfs_super_chunk_root(disk_super), btrfs_super_chunk_root(disk_super),
blocksize, generation); generation);
if (!chunk_root->node || if (!chunk_root->node ||
!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) { !test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
printk(KERN_WARNING "BTRFS: failed to read chunk root on %s\n", printk(KERN_WARNING "BTRFS: failed to read chunk root on %s\n",
@ -2696,12 +2687,11 @@ int open_ctree(struct super_block *sb,
} }
retry_root_backup: retry_root_backup:
blocksize = tree_root->nodesize;
generation = btrfs_super_generation(disk_super); generation = btrfs_super_generation(disk_super);
tree_root->node = read_tree_block(tree_root, tree_root->node = read_tree_block(tree_root,
btrfs_super_root(disk_super), btrfs_super_root(disk_super),
blocksize, generation); generation);
if (!tree_root->node || if (!tree_root->node ||
!test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) { !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
printk(KERN_WARNING "BTRFS: failed to read tree root on %s\n", printk(KERN_WARNING "BTRFS: failed to read tree root on %s\n",
@ -2870,7 +2860,6 @@ retry_root_backup:
err = -EIO; err = -EIO;
goto fail_qgroup; goto fail_qgroup;
} }
blocksize = tree_root->nodesize;
log_tree_root = btrfs_alloc_root(fs_info); log_tree_root = btrfs_alloc_root(fs_info);
if (!log_tree_root) { if (!log_tree_root) {
@ -2882,7 +2871,6 @@ retry_root_backup:
log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID); log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
log_tree_root->node = read_tree_block(tree_root, bytenr, log_tree_root->node = read_tree_block(tree_root, bytenr,
blocksize,
generation + 1); generation + 1);
if (!log_tree_root->node || if (!log_tree_root->node ||
!extent_buffer_uptodate(log_tree_root->node)) { !extent_buffer_uptodate(log_tree_root->node)) {
@ -4084,8 +4072,7 @@ static int btrfs_destroy_marked_extents(struct btrfs_root *root,
clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS); clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
while (start <= end) { while (start <= end) {
eb = btrfs_find_tree_block(root, start, eb = btrfs_find_tree_block(root, start);
root->nodesize);
start += root->nodesize; start += root->nodesize;
if (!eb) if (!eb)
continue; continue;

7
fs/btrfs/disk-io.h
View File

@ -45,9 +45,8 @@ struct btrfs_device;
struct btrfs_fs_devices; struct btrfs_fs_devices;
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr, struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
u32 blocksize, u64 parent_transid); u64 parent_transid);
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize, void readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize);
u64 parent_transid);
int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize, int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
int mirror_num, struct extent_buffer **eb); int mirror_num, struct extent_buffer **eb);
struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root, struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
@ -63,7 +62,7 @@ int write_ctree_super(struct btrfs_trans_handle *trans,
struct buffer_head *btrfs_read_dev_super(struct block_device *bdev); struct buffer_head *btrfs_read_dev_super(struct block_device *bdev);
int btrfs_commit_super(struct btrfs_root *root); int btrfs_commit_super(struct btrfs_root *root);
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root, struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
u64 bytenr, u32 blocksize); u64 bytenr);
struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root, struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root,
struct btrfs_key *location); struct btrfs_key *location);
int btrfs_init_fs_root(struct btrfs_root *root); int btrfs_init_fs_root(struct btrfs_root *root);

20
fs/btrfs/extent-tree.c
View File

@ -7323,8 +7323,8 @@ static void unuse_block_rsv(struct btrfs_fs_info *fs_info,
* *
* returns the tree buffer or NULL. * returns the tree buffer or NULL.
*/ */
struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root, u32 blocksize, struct btrfs_root *root,
u64 parent, u64 root_objectid, u64 parent, u64 root_objectid,
struct btrfs_disk_key *key, int level, struct btrfs_disk_key *key, int level,
u64 hint, u64 empty_size) u64 hint, u64 empty_size)
@ -7334,6 +7334,7 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
struct extent_buffer *buf; struct extent_buffer *buf;
u64 flags = 0; u64 flags = 0;
int ret; int ret;
u32 blocksize = root->nodesize;
bool skinny_metadata = btrfs_fs_incompat(root->fs_info, bool skinny_metadata = btrfs_fs_incompat(root->fs_info,
SKINNY_METADATA); SKINNY_METADATA);
@ -7486,10 +7487,7 @@ static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
continue; continue;
} }
reada: reada:
ret = readahead_tree_block(root, bytenr, blocksize, readahead_tree_block(root, bytenr, blocksize);
generation);
if (ret)
break;
nread++; nread++;
} }
wc->reada_slot = slot; wc->reada_slot = slot;
@ -7648,7 +7646,6 @@ walk_down:
level = root_level; level = root_level;
while (level >= 0) { while (level >= 0) {
if (path->nodes[level] == NULL) { if (path->nodes[level] == NULL) {
int child_bsize = root->nodesize;
int parent_slot; int parent_slot;
u64 child_gen; u64 child_gen;
u64 child_bytenr; u64 child_bytenr;
@ -7660,8 +7657,7 @@ walk_down:
child_bytenr = btrfs_node_blockptr(eb, parent_slot); child_bytenr = btrfs_node_blockptr(eb, parent_slot);
child_gen = btrfs_node_ptr_generation(eb, parent_slot); child_gen = btrfs_node_ptr_generation(eb, parent_slot);
eb = read_tree_block(root, child_bytenr, child_bsize, eb = read_tree_block(root, child_bytenr, child_gen);
child_gen);
if (!eb || !extent_buffer_uptodate(eb)) { if (!eb || !extent_buffer_uptodate(eb)) {
ret = -EIO; ret = -EIO;
goto out; goto out;
@ -7677,7 +7673,7 @@ walk_down:
ret = btrfs_qgroup_record_ref(trans, root->fs_info, ret = btrfs_qgroup_record_ref(trans, root->fs_info,
root->objectid, root->objectid,
child_bytenr, child_bytenr,
child_bsize, root->nodesize,
BTRFS_QGROUP_OPER_SUB_SUBTREE, BTRFS_QGROUP_OPER_SUB_SUBTREE,
0); 0);
if (ret) if (ret)
@ -7830,7 +7826,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]); bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
blocksize = root->nodesize; blocksize = root->nodesize;
next = btrfs_find_tree_block(root, bytenr, blocksize); next = btrfs_find_tree_block(root, bytenr);
if (!next) { if (!next) {
next = btrfs_find_create_tree_block(root, bytenr, blocksize); next = btrfs_find_create_tree_block(root, bytenr, blocksize);
if (!next) if (!next)
@ -7892,7 +7888,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
if (!next) { if (!next) {
if (reada && level == 1) if (reada && level == 1)
reada_walk_down(trans, root, wc, path); reada_walk_down(trans, root, wc, path);
next = read_tree_block(root, bytenr, blocksize, generation); next = read_tree_block(root, bytenr, generation);
if (!next || !extent_buffer_uptodate(next)) { if (!next || !extent_buffer_uptodate(next)) {
free_extent_buffer(next); free_extent_buffer(next);
return -EIO; return -EIO;

3
fs/btrfs/ioctl.c
View File

@ -480,8 +480,7 @@ static noinline int create_subvol(struct inode *dir,
if (ret) if (ret)
goto fail; goto fail;
leaf = btrfs_alloc_free_block(trans, root, root->nodesize, leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0);
0, objectid, NULL, 0, 0, 0);
if (IS_ERR(leaf)) { if (IS_ERR(leaf)) {
ret = PTR_ERR(leaf); ret = PTR_ERR(leaf);
goto fail; goto fail;

1
fs/btrfs/print-tree.c
View File

@ -336,7 +336,6 @@ void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *c)
for (i = 0; i < nr; i++) { for (i = 0; i < nr; i++) {
struct extent_buffer *next = read_tree_block(root, struct extent_buffer *next = read_tree_block(root,
btrfs_node_blockptr(c, i), btrfs_node_blockptr(c, i),
root->nodesize,
btrfs_node_ptr_generation(c, i)); btrfs_node_ptr_generation(c, i));
if (btrfs_is_leaf(next) && if (btrfs_is_leaf(next) &&
level != 1) level != 1)

28
fs/btrfs/relocation.c
View File

@ -1846,8 +1846,7 @@ again:
break; break;
} }
eb = read_tree_block(dest, old_bytenr, blocksize, eb = read_tree_block(dest, old_bytenr, old_ptr_gen);
old_ptr_gen);
if (!eb || !extent_buffer_uptodate(eb)) { if (!eb || !extent_buffer_uptodate(eb)) {
ret = (!eb) ? -ENOMEM : -EIO; ret = (!eb) ? -ENOMEM : -EIO;
free_extent_buffer(eb); free_extent_buffer(eb);
@ -1977,7 +1976,6 @@ int walk_down_reloc_tree(struct btrfs_root *root, struct btrfs_path *path,
u64 bytenr; u64 bytenr;
u64 ptr_gen = 0; u64 ptr_gen = 0;
u64 last_snapshot; u64 last_snapshot;
u32 blocksize;
u32 nritems; u32 nritems;
last_snapshot = btrfs_root_last_snapshot(&root->root_item); last_snapshot = btrfs_root_last_snapshot(&root->root_item);
@ -2003,8 +2001,7 @@ int walk_down_reloc_tree(struct btrfs_root *root, struct btrfs_path *path,
} }
bytenr = btrfs_node_blockptr(eb, path->slots[i]); bytenr = btrfs_node_blockptr(eb, path->slots[i]);
blocksize = root->nodesize; eb = read_tree_block(root, bytenr, ptr_gen);
eb = read_tree_block(root, bytenr, blocksize, ptr_gen);
if (!eb || !extent_buffer_uptodate(eb)) { if (!eb || !extent_buffer_uptodate(eb)) {
free_extent_buffer(eb); free_extent_buffer(eb);
return -EIO; return -EIO;
@ -2712,7 +2709,7 @@ static int do_relocation(struct btrfs_trans_handle *trans,
blocksize = root->nodesize; blocksize = root->nodesize;
generation = btrfs_node_ptr_generation(upper->eb, slot); generation = btrfs_node_ptr_generation(upper->eb, slot);
eb = read_tree_block(root, bytenr, blocksize, generation); eb = read_tree_block(root, bytenr, generation);
if (!eb || !extent_buffer_uptodate(eb)) { if (!eb || !extent_buffer_uptodate(eb)) {
free_extent_buffer(eb); free_extent_buffer(eb);
err = -EIO; err = -EIO;
@ -2874,7 +2871,7 @@ static int get_tree_block_key(struct reloc_control *rc,
BUG_ON(block->key_ready); BUG_ON(block->key_ready);
eb = read_tree_block(rc->extent_root, block->bytenr, eb = read_tree_block(rc->extent_root, block->bytenr,
block->key.objectid, block->key.offset); block->key.offset);
if (!eb || !extent_buffer_uptodate(eb)) { if (!eb || !extent_buffer_uptodate(eb)) {
free_extent_buffer(eb); free_extent_buffer(eb);
return -EIO; return -EIO;
@ -2889,20 +2886,6 @@ static int get_tree_block_key(struct reloc_control *rc,
return 0; return 0;
} }
static int reada_tree_block(struct reloc_control *rc,
struct tree_block *block)
{
BUG_ON(block->key_ready);
if (block->key.type == BTRFS_METADATA_ITEM_KEY)
readahead_tree_block(rc->extent_root, block->bytenr,
block->key.objectid,
rc->extent_root->nodesize);
else
readahead_tree_block(rc->extent_root, block->bytenr,
block->key.objectid, block->key.offset);
return 0;
}
/* /*
* helper function to relocate a tree block * helper function to relocate a tree block
*/ */
@ -2982,7 +2965,8 @@ int relocate_tree_blocks(struct btrfs_trans_handle *trans,
while (rb_node) { while (rb_node) {
block = rb_entry(rb_node, struct tree_block, rb_node); block = rb_entry(rb_node, struct tree_block, rb_node);
if (!block->key_ready) if (!block->key_ready)
reada_tree_block(rc, block); readahead_tree_block(rc->extent_root, block->bytenr,
block->key.objectid);
rb_node = rb_next(rb_node); rb_node = rb_next(rb_node);
} }