On 2018年03月22日 20:12, Nikolay Borisov wrote:
> 
> 
> On 19.03.2018 11:18, Qu Wenruo wrote:
>> We have several reports about node pointer points to incorrect child
>> tree blocks, which could have even wrong owner and level but still with
>> valid generation and checksum.
>>
>> Although btrfs check could handle it and print error message like:
>> leaf parent key incorrect 60670574592
>>
>> Kernel doesn't have enough check on this type of corruption correctly.
>> At least add such check to read_tree_block() and btrfs_read_buffer(),
>> where we need two new parameters @first_key and @level to verify the
>> child tree block.
>>
>> For case where we don't have parent node to get @first_key and @level,
>> just pass @first_key as NULL and kernel will skip such check.
>>
>> Signed-off-by: Qu Wenruo <wqu@suse.com>
> 
> 
> This patch breaks the build, at the very least you should update the
> call to read_tree_block in ref-verify.c

Didn't notice the new ref-verify option.

I'll update this with CONFIG_BTRFS_FS_REF_VERIFY set.

Thanks,
Qu

> 
>> ---
>>  fs/btrfs/backref.c     |  6 +++--
>>  fs/btrfs/ctree.c       | 25 +++++++++++++-----
>>  fs/btrfs/disk-io.c     | 69 ++++++++++++++++++++++++++++++++++++++++----------
>>  fs/btrfs/disk-io.h     |  8 +++---
>>  fs/btrfs/extent-tree.c |  6 ++++-
>>  fs/btrfs/print-tree.c  | 10 +++++---
>>  fs/btrfs/qgroup.c      |  7 +++--
>>  fs/btrfs/relocation.c  | 21 ++++++++++++---
>>  fs/btrfs/tree-log.c    | 12 ++++++---
>>  9 files changed, 126 insertions(+), 38 deletions(-)
>>
>> diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
>> index 26484648d090..3866b8ab20f1 100644
>> --- a/fs/btrfs/backref.c
>> +++ b/fs/btrfs/backref.c
>> @@ -738,7 +738,8 @@ static int add_missing_keys(struct btrfs_fs_info *fs_info,
>>  		BUG_ON(ref->key_for_search.type);
>>  		BUG_ON(!ref->wanted_disk_byte);
>>  
>> -		eb = read_tree_block(fs_info, ref->wanted_disk_byte, 0);
>> +		eb = read_tree_block(fs_info, ref->wanted_disk_byte, 0, NULL,
>> +				     0);
>>  		if (IS_ERR(eb)) {
>>  			free_pref(ref);
>>  			return PTR_ERR(eb);
>> @@ -1291,7 +1292,8 @@ static int find_parent_nodes(struct btrfs_trans_handle *trans,
>>  			    ref->level == 0) {
>>  				struct extent_buffer *eb;
>>  
>> -				eb = read_tree_block(fs_info, ref->parent, 0);
>> +				eb = read_tree_block(fs_info, ref->parent, 0,
>> +						     NULL, 0);
>>  				if (IS_ERR(eb)) {
>>  					ret = PTR_ERR(eb);
>>  					goto out;
>> diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
>> index b88a79e69ddf..e49ca6d529e8 100644
>> --- a/fs/btrfs/ctree.c
>> +++ b/fs/btrfs/ctree.c
>> @@ -1436,7 +1436,7 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
>>  	if (old_root && tm && tm->op != MOD_LOG_KEY_REMOVE_WHILE_FREEING) {
>>  		btrfs_tree_read_unlock(eb_root);
>>  		free_extent_buffer(eb_root);
>> -		old = read_tree_block(fs_info, logical, 0);
>> +		old = read_tree_block(fs_info, logical, 0, NULL, 0);
>>  		if (WARN_ON(IS_ERR(old) || !extent_buffer_uptodate(old))) {
>>  			if (!IS_ERR(old))
>>  				free_extent_buffer(old);
>> @@ -1656,6 +1656,7 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
>>  	btrfs_set_lock_blocking(parent);
>>  
>>  	for (i = start_slot; i <= end_slot; i++) {
>> +		struct btrfs_key first_key;
>>  		int close = 1;
>>  
>>  		btrfs_node_key(parent, &disk_key, i);
>> @@ -1665,6 +1666,7 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
>>  		progress_passed = 1;
>>  		blocknr = btrfs_node_blockptr(parent, i);
>>  		gen = btrfs_node_ptr_generation(parent, i);
>> +		btrfs_node_key_to_cpu(parent, &first_key, i);
>>  		if (last_block == 0)
>>  			last_block = blocknr;
>>  
>> @@ -1688,7 +1690,9 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
>>  			uptodate = 0;
>>  		if (!cur || !uptodate) {
>>  			if (!cur) {
>> -				cur = read_tree_block(fs_info, blocknr, gen);
>> +				cur = read_tree_block(fs_info, blocknr, gen,
>> +						      &first_key,
>> +						      parent_level - 1);
>>  				if (IS_ERR(cur)) {
>>  					return PTR_ERR(cur);
>>  				} else if (!extent_buffer_uptodate(cur)) {
>> @@ -1696,7 +1700,8 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
>>  					return -EIO;
>>  				}
>>  			} else if (!uptodate) {
>> -				err = btrfs_read_buffer(cur, gen);
>> +				err = btrfs_read_buffer(cur, gen, &first_key,
>> +							parent_level - 1);
>>  				if (err) {
>>  					free_extent_buffer(cur);
>>  					return err;
>> @@ -1849,14 +1854,17 @@ read_node_slot(struct btrfs_fs_info *fs_info, struct extent_buffer *parent,
>>  {
>>  	int level = btrfs_header_level(parent);
>>  	struct extent_buffer *eb;
>> +	struct btrfs_key first_key;
>>  
>>  	if (slot < 0 || slot >= btrfs_header_nritems(parent))
>>  		return ERR_PTR(-ENOENT);
>>  
>>  	BUG_ON(level == 0);
>>  
>> +	btrfs_node_key_to_cpu(parent, &first_key, slot);
>>  	eb = read_tree_block(fs_info, btrfs_node_blockptr(parent, slot),
>> -			     btrfs_node_ptr_generation(parent, slot));
>> +			     btrfs_node_ptr_generation(parent, slot),
>> +			     &first_key, level - 1);
>>  	if (!IS_ERR(eb) && !extent_buffer_uptodate(eb)) {
>>  		free_extent_buffer(eb);
>>  		eb = ERR_PTR(-EIO);
>> @@ -2445,10 +2453,14 @@ read_block_for_search(struct btrfs_root *root, struct btrfs_path *p,
>>  	u64 gen;
>>  	struct extent_buffer *b = *eb_ret;
>>  	struct extent_buffer *tmp;
>> +	struct btrfs_key first_key;
>>  	int ret;
>> +	int parent_level;
>>  
>>  	blocknr = btrfs_node_blockptr(b, slot);
>>  	gen = btrfs_node_ptr_generation(b, slot);
>> +	parent_level = btrfs_header_level(b);
>> +	btrfs_node_key_to_cpu(b, &first_key, slot);
>>  
>>  	tmp = find_extent_buffer(fs_info, blocknr);
>>  	if (tmp) {
>> @@ -2467,7 +2479,7 @@ read_block_for_search(struct btrfs_root *root, struct btrfs_path *p,
>>  		btrfs_set_path_blocking(p);
>>  
>>  		/* now we're allowed to do a blocking uptodate check */
>> -		ret = btrfs_read_buffer(tmp, gen);
>> +		ret = btrfs_read_buffer(tmp, gen, &first_key, parent_level - 1);
>>  		if (!ret) {
>>  			*eb_ret = tmp;
>>  			return 0;
>> @@ -2494,7 +2506,8 @@ read_block_for_search(struct btrfs_root *root, struct btrfs_path *p,
>>  	btrfs_release_path(p);
>>  
>>  	ret = -EAGAIN;
>> -	tmp = read_tree_block(fs_info, blocknr, 0);
>> +	tmp = read_tree_block(fs_info, blocknr, 0, &first_key,
>> +			      parent_level - 1);
>>  	if (!IS_ERR(tmp)) {
>>  		/*
>>  		 * If the read above didn't mark this buffer up to date,
>> diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
>> index 21f34ad0d411..46fbbbf34568 100644
>> --- a/fs/btrfs/disk-io.c
>> +++ b/fs/btrfs/disk-io.c
>> @@ -428,13 +428,40 @@ static int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,
>>  	return ret;
>>  }
>>  
>> +static int verify_parent_key(struct extent_buffer *eb,
>> +			     struct btrfs_key *first_key,
>> +			     int level)
>> +{
>> +	int found_level;
>> +	struct btrfs_key found_key;
>> +
>> +	if (!first_key)
>> +		return 0;
>> +
>> +	found_level = btrfs_header_level(eb);
>> +	if (found_level != level)
>> +		return -EIO;
>> +
>> +	if (found_level)
>> +		btrfs_node_key_to_cpu(eb, &found_key, 0);
>> +	else
>> +		btrfs_item_key_to_cpu(eb, &found_key, 0);
>> +	return btrfs_comp_cpu_keys(first_key, &found_key);
>> +}
>> +
>>  /*
>>   * helper to read a given tree block, doing retries as required when
>>   * the checksums don't match and we have alternate mirrors to try.
>> + *
>> + * @parent_transid:	expected transid, skip check if 0
>> + * @first_key:		expected key of first slot, skip check if NULL
>> + * @level:		expected level, skip check if @first_key is NULL
>>   */
>>  static int btree_read_extent_buffer_pages(struct btrfs_fs_info *fs_info,
>>  					  struct extent_buffer *eb,
>> -					  u64 parent_transid)
>> +					  u64 parent_transid,
>> +					  struct btrfs_key *first_key,
>> +					  int level)
>>  {
>>  	struct extent_io_tree *io_tree;
>>  	int failed = 0;
>> @@ -449,11 +476,13 @@ static int btree_read_extent_buffer_pages(struct btrfs_fs_info *fs_info,
>>  		ret = read_extent_buffer_pages(io_tree, eb, WAIT_COMPLETE,
>>  					       mirror_num);
>>  		if (!ret) {
>> -			if (!verify_parent_transid(io_tree, eb,
>> +			if (verify_parent_transid(io_tree, eb,
>>  						   parent_transid, 0))
>> -				break;
>> -			else
>>  				ret = -EIO;
>> +			else if (verify_parent_key(eb, first_key, level))
>> +				ret = -EUCLEAN;
>> +			else
>> +				break;
>>  		}
>>  
>>  		/*
>> @@ -461,7 +490,8 @@ static int btree_read_extent_buffer_pages(struct btrfs_fs_info *fs_info,
>>  		 * there is no reason to read the other copies, they won't be
>>  		 * any less wrong.
>>  		 */
>> -		if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
>> +		if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags) ||
>> +		    ret == -EUCLEAN)
>>  			break;
>>  
>>  		num_copies = btrfs_num_copies(fs_info,
>> @@ -1062,8 +1092,17 @@ void btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
>>  			        buf->start, buf->start + buf->len - 1);
>>  }
>>  
>> +/*
>> + * Read tree block at logical address @bytenr and do variant basic but critical
>> + * verfication.
>> + *
>> + * @parent_transid:	expected transid of this tree block, skip check if 0
>> + * @first_key:		expected key in slot 0, skip check if NULL
>> + * @level:		eppected level, skip check if @first_key is NULL
>> + */
>>  struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
>> -				      u64 parent_transid)
>> +				      u64 parent_transid,
>> +				      struct btrfs_key *first_key, int level)
>>  {
>>  	struct extent_buffer *buf = NULL;
>>  	int ret;
>> @@ -1072,7 +1111,8 @@ struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
>>  	if (IS_ERR(buf))
>>  		return buf;
>>  
>> -	ret = btree_read_extent_buffer_pages(fs_info, buf, parent_transid);
>> +	ret = btree_read_extent_buffer_pages(fs_info, buf, parent_transid,
>> +					     first_key, level);
>>  	if (ret) {
>>  		free_extent_buffer(buf);
>>  		return ERR_PTR(ret);
>> @@ -1425,7 +1465,7 @@ static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
>>  	generation = btrfs_root_generation(&root->root_item);
>>  	root->node = read_tree_block(fs_info,
>>  				     btrfs_root_bytenr(&root->root_item),
>> -				     generation);
>> +				     generation, NULL, 0);
>>  	if (IS_ERR(root->node)) {
>>  		ret = PTR_ERR(root->node);
>>  		goto find_fail;
>> @@ -2289,7 +2329,8 @@ static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
>>  	__setup_root(log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
>>  
>>  	log_tree_root->node = read_tree_block(fs_info, bytenr,
>> -					      fs_info->generation + 1);
>> +					      fs_info->generation + 1,
>> +					      NULL, 0);
>>  	if (IS_ERR(log_tree_root->node)) {
>>  		btrfs_warn(fs_info, "failed to read log tree");
>>  		ret = PTR_ERR(log_tree_root->node);
>> @@ -2746,7 +2787,7 @@ int open_ctree(struct super_block *sb,
>>  
>>  	chunk_root->node = read_tree_block(fs_info,
>>  					   btrfs_super_chunk_root(disk_super),
>> -					   generation);
>> +					   generation, NULL, 0);
>>  	if (IS_ERR(chunk_root->node) ||
>>  	    !extent_buffer_uptodate(chunk_root->node)) {
>>  		btrfs_err(fs_info, "failed to read chunk root");
>> @@ -2783,7 +2824,7 @@ int open_ctree(struct super_block *sb,
>>  
>>  	tree_root->node = read_tree_block(fs_info,
>>  					  btrfs_super_root(disk_super),
>> -					  generation);
>> +					  generation, NULL, 0);
>>  	if (IS_ERR(tree_root->node) ||
>>  	    !extent_buffer_uptodate(tree_root->node)) {
>>  		btrfs_warn(fs_info, "failed to read tree root");
>> @@ -3890,12 +3931,14 @@ void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)
>>  	__btrfs_btree_balance_dirty(fs_info, 0);
>>  }
>>  
>> -int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
>> +int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid,
>> +		      struct btrfs_key *first_key, int level)
>>  {
>>  	struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
>>  	struct btrfs_fs_info *fs_info = root->fs_info;
>>  
>> -	return btree_read_extent_buffer_pages(fs_info, buf, parent_transid);
>> +	return btree_read_extent_buffer_pages(fs_info, buf, parent_transid,
>> +					      first_key, level);
>>  }
>>  
>>  static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info)
>> diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
>> index 301151a50ac1..3a1f4b2fa6ff 100644
>> --- a/fs/btrfs/disk-io.h
>> +++ b/fs/btrfs/disk-io.h
>> @@ -52,8 +52,9 @@ static inline u64 btrfs_sb_offset(int mirror)
>>  struct btrfs_device;
>>  struct btrfs_fs_devices;
>>  
>> -struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info,
>> -				      u64 bytenr, u64 parent_transid);
>> +struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
>> +				      u64 parent_transid,
>> +				      struct btrfs_key *first_key, int level);
>>  void readahead_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr);
>>  int reada_tree_block_flagged(struct btrfs_fs_info *fs_info, u64 bytenr,
>>  			 int mirror_num, struct extent_buffer **eb);
>> @@ -123,7 +124,8 @@ static inline void btrfs_put_fs_root(struct btrfs_root *root)
>>  void btrfs_mark_buffer_dirty(struct extent_buffer *buf);
>>  int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
>>  			  int atomic);
>> -int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid);
>> +int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid,
>> +		      struct btrfs_key *first_key, int level);
>>  u32 btrfs_csum_data(const char *data, u32 seed, size_t len);
>>  void btrfs_csum_final(u32 crc, u8 *result);
>>  blk_status_t btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
>> diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
>> index c1618ab9fecf..156ac8e4ff62 100644
>> --- a/fs/btrfs/extent-tree.c
>> +++ b/fs/btrfs/extent-tree.c
>> @@ -8701,6 +8701,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
>>  	u64 parent;
>>  	u32 blocksize;
>>  	struct btrfs_key key;
>> +	struct btrfs_key first_key;
>>  	struct extent_buffer *next;
>>  	int level = wc->level;
>>  	int reada = 0;
>> @@ -8721,6 +8722,8 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
>>  	}
>>  
>>  	bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
>> +	btrfs_node_key_to_cpu(path->nodes[level], &first_key,
>> +			      path->slots[level]);
>>  	blocksize = fs_info->nodesize;
>>  
>>  	next = find_extent_buffer(fs_info, bytenr);
>> @@ -8785,7 +8788,8 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
>>  	if (!next) {
>>  		if (reada && level == 1)
>>  			reada_walk_down(trans, root, wc, path);
>> -		next = read_tree_block(fs_info, bytenr, generation);
>> +		next = read_tree_block(fs_info, bytenr, generation, &first_key,
>> +				       level - 1);
>>  		if (IS_ERR(next)) {
>>  			return PTR_ERR(next);
>>  		} else if (!extent_buffer_uptodate(next)) {
>> diff --git a/fs/btrfs/print-tree.c b/fs/btrfs/print-tree.c
>> index 569205e651c7..b00d88291085 100644
>> --- a/fs/btrfs/print-tree.c
>> +++ b/fs/btrfs/print-tree.c
>> @@ -365,9 +365,13 @@ void btrfs_print_tree(struct extent_buffer *c)
>>  		       btrfs_node_blockptr(c, i));
>>  	}
>>  	for (i = 0; i < nr; i++) {
>> -		struct extent_buffer *next = read_tree_block(fs_info,
>> -					btrfs_node_blockptr(c, i),
>> -					btrfs_node_ptr_generation(c, i));
>> +		struct btrfs_key first_key;
>> +		struct extent_buffer *next;
>> +
>> +		btrfs_node_key_to_cpu(c, &first_key, i);
>> +		next = read_tree_block(fs_info, btrfs_node_blockptr(c, i),
>> +				       btrfs_node_ptr_generation(c, i),
>> +				       &first_key, level - 1);
>>  		if (IS_ERR(next)) {
>>  			continue;
>>  		} else if (!extent_buffer_uptodate(next)) {
>> diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
>> index aa259d6986e1..86698702d08c 100644
>> --- a/fs/btrfs/qgroup.c
>> +++ b/fs/btrfs/qgroup.c
>> @@ -1614,7 +1614,7 @@ int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans,
>>  		return 0;
>>  
>>  	if (!extent_buffer_uptodate(root_eb)) {
>> -		ret = btrfs_read_buffer(root_eb, root_gen);
>> +		ret = btrfs_read_buffer(root_eb, root_gen, NULL, 0);
>>  		if (ret)
>>  			goto out;
>>  	}
>> @@ -1645,6 +1645,7 @@ int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans,
>>  	level = root_level;
>>  	while (level >= 0) {
>>  		if (path->nodes[level] == NULL) {
>> +			struct btrfs_key first_key;
>>  			int parent_slot;
>>  			u64 child_gen;
>>  			u64 child_bytenr;
>> @@ -1657,8 +1658,10 @@ int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans,
>>  			parent_slot = path->slots[level + 1];
>>  			child_bytenr = btrfs_node_blockptr(eb, parent_slot);
>>  			child_gen = btrfs_node_ptr_generation(eb, parent_slot);
>> +			btrfs_node_key_to_cpu(eb, &first_key, parent_slot);
>>  
>> -			eb = read_tree_block(fs_info, child_bytenr, child_gen);
>> +			eb = read_tree_block(fs_info, child_bytenr, child_gen,
>> +					     &first_key, level);
>>  			if (IS_ERR(eb)) {
>>  				ret = PTR_ERR(eb);
>>  				goto out;
>> diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
>> index cd2298d185dd..4a309f8c9535 100644
>> --- a/fs/btrfs/relocation.c
>> +++ b/fs/btrfs/relocation.c
>> @@ -1839,6 +1839,8 @@ int replace_path(struct btrfs_trans_handle *trans,
>>  
>>  	parent = eb;
>>  	while (1) {
>> +		struct btrfs_key first_key;
>> +
>>  		level = btrfs_header_level(parent);
>>  		BUG_ON(level < lowest_level);
>>  
>> @@ -1852,6 +1854,7 @@ int replace_path(struct btrfs_trans_handle *trans,
>>  		old_bytenr = btrfs_node_blockptr(parent, slot);
>>  		blocksize = fs_info->nodesize;
>>  		old_ptr_gen = btrfs_node_ptr_generation(parent, slot);
>> +		btrfs_node_key_to_cpu(parent, &key, slot);
>>  
>>  		if (level <= max_level) {
>>  			eb = path->nodes[level];
>> @@ -1876,7 +1879,8 @@ int replace_path(struct btrfs_trans_handle *trans,
>>  				break;
>>  			}
>>  
>> -			eb = read_tree_block(fs_info, old_bytenr, old_ptr_gen);
>> +			eb = read_tree_block(fs_info, old_bytenr, old_ptr_gen,
>> +					     &first_key, level - 1);
>>  			if (IS_ERR(eb)) {
>>  				ret = PTR_ERR(eb);
>>  				break;
>> @@ -2036,6 +2040,8 @@ int walk_down_reloc_tree(struct btrfs_root *root, struct btrfs_path *path,
>>  	last_snapshot = btrfs_root_last_snapshot(&root->root_item);
>>  
>>  	for (i = *level; i > 0; i--) {
>> +		struct btrfs_key first_key;
>> +
>>  		eb = path->nodes[i];
>>  		nritems = btrfs_header_nritems(eb);
>>  		while (path->slots[i] < nritems) {
>> @@ -2056,7 +2062,9 @@ int walk_down_reloc_tree(struct btrfs_root *root, struct btrfs_path *path,
>>  		}
>>  
>>  		bytenr = btrfs_node_blockptr(eb, path->slots[i]);
>> -		eb = read_tree_block(fs_info, bytenr, ptr_gen);
>> +		btrfs_node_key_to_cpu(eb, &first_key, path->slots[i]);
>> +		eb = read_tree_block(fs_info, bytenr, ptr_gen, &first_key,
>> +				     i - 1);
>>  		if (IS_ERR(eb)) {
>>  			return PTR_ERR(eb);
>>  		} else if (!extent_buffer_uptodate(eb)) {
>> @@ -2714,6 +2722,8 @@ static int do_relocation(struct btrfs_trans_handle *trans,
>>  	path->lowest_level = node->level + 1;
>>  	rc->backref_cache.path[node->level] = node;
>>  	list_for_each_entry(edge, &node->upper, list[LOWER]) {
>> +		struct btrfs_key first_key;
>> +
>>  		cond_resched();
>>  
>>  		upper = edge->node[UPPER];
>> @@ -2779,7 +2789,9 @@ static int do_relocation(struct btrfs_trans_handle *trans,
>>  
>>  		blocksize = root->fs_info->nodesize;
>>  		generation = btrfs_node_ptr_generation(upper->eb, slot);
>> -		eb = read_tree_block(fs_info, bytenr, generation);
>> +		btrfs_node_key_to_cpu(upper->eb, &first_key, slot);
>> +		eb = read_tree_block(fs_info, bytenr, generation, &first_key,
>> +				     upper->level - 1);
>>  		if (IS_ERR(eb)) {
>>  			err = PTR_ERR(eb);
>>  			goto next;
>> @@ -2944,7 +2956,8 @@ static int get_tree_block_key(struct btrfs_fs_info *fs_info,
>>  	struct extent_buffer *eb;
>>  
>>  	BUG_ON(block->key_ready);
>> -	eb = read_tree_block(fs_info, block->bytenr, block->key.offset);
>> +	eb = read_tree_block(fs_info, block->bytenr, block->key.offset, NULL,
>> +			     0);
>>  	if (IS_ERR(eb)) {
>>  		return PTR_ERR(eb);
>>  	} else if (!extent_buffer_uptodate(eb)) {
>> diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
>> index 434457794c27..b98a1801b406 100644
>> --- a/fs/btrfs/tree-log.c
>> +++ b/fs/btrfs/tree-log.c
>> @@ -304,7 +304,7 @@ static int process_one_buffer(struct btrfs_root *log,
>>  	 * pin down any logged extents, so we have to read the block.
>>  	 */
>>  	if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
>> -		ret = btrfs_read_buffer(eb, gen);
>> +		ret = btrfs_read_buffer(eb, gen, NULL, 0);
>>  		if (ret)
>>  			return ret;
>>  	}
>> @@ -2420,7 +2420,7 @@ static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
>>  	int i;
>>  	int ret;
>>  
>> -	ret = btrfs_read_buffer(eb, gen);
>> +	ret = btrfs_read_buffer(eb, gen, NULL, 0);
>>  	if (ret)
>>  		return ret;
>>  
>> @@ -2537,6 +2537,8 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
>>  	WARN_ON(*level >= BTRFS_MAX_LEVEL);
>>  
>>  	while (*level > 0) {
>> +		struct btrfs_key first_key;
>> +
>>  		WARN_ON(*level < 0);
>>  		WARN_ON(*level >= BTRFS_MAX_LEVEL);
>>  		cur = path->nodes[*level];
>> @@ -2549,6 +2551,7 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
>>  
>>  		bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
>>  		ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
>> +		btrfs_node_key_to_cpu(cur, &first_key, path->slots[*level]);
>>  		blocksize = fs_info->nodesize;
>>  
>>  		parent = path->nodes[*level];
>> @@ -2567,7 +2570,8 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
>>  
>>  			path->slots[*level]++;
>>  			if (wc->free) {
>> -				ret = btrfs_read_buffer(next, ptr_gen);
>> +				ret = btrfs_read_buffer(next, ptr_gen,
>> +							&first_key, *level - 1);
>>  				if (ret) {
>>  					free_extent_buffer(next);
>>  					return ret;
>> @@ -2597,7 +2601,7 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
>>  			free_extent_buffer(next);
>>  			continue;
>>  		}
>> -		ret = btrfs_read_buffer(next, ptr_gen);
>> +		ret = btrfs_read_buffer(next, ptr_gen, &first_key, *level - 1);
>>  		if (ret) {
>>  			free_extent_buffer(next);
>>  			return ret;
>>
>