Re: [PATCH] btrfs: Validate child tree block's level and first key

[Nikolay Borisov <n.borisov.lkml@gmail.com>]

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

> ---
>  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;
>