2018-04-03 20:23:33 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2011-06-13 21:52:59 +04:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2011 STRATO. All rights reserved.
|
|
|
|
*/
|
|
|
|
|
2017-05-31 20:32:09 +03:00
|
|
|
#include <linux/mm.h>
|
btrfs: fix check_shared for fiemap ioctl
Only in the case of different root_id or different object_id, check_shared
identified extent as the shared. However, If a extent was referred by
different offset of same file, it should also be identified as shared.
In addition, check_shared's loop scale is at least n^3, so if a extent
has too many references, even causes soft hang up.
First, add all delayed_ref to the ref_tree and calculate the unqiue_refs,
if the unique_refs is greater than one, return BACKREF_FOUND_SHARED.
Then individually add the on-disk reference(inline/keyed) to the ref_tree
and calculate the unique_refs of the ref_tree to check if the unique_refs
is greater than one.Because once there are two references to return
SHARED, so the time complexity is close to the constant.
Reported-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: Lu Fengqi <lufq.fnst@cn.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-06-13 04:36:46 +03:00
|
|
|
#include <linux/rbtree.h>
|
2017-07-13 01:20:08 +03:00
|
|
|
#include <trace/events/btrfs.h>
|
2011-06-13 21:52:59 +04:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "disk-io.h"
|
|
|
|
#include "backref.h"
|
2011-11-23 21:55:04 +04:00
|
|
|
#include "ulist.h"
|
|
|
|
#include "transaction.h"
|
|
|
|
#include "delayed-ref.h"
|
2012-04-13 14:28:08 +04:00
|
|
|
#include "locking.h"
|
2020-03-23 11:08:34 +03:00
|
|
|
#include "misc.h"
|
2021-03-11 17:31:07 +03:00
|
|
|
#include "tree-mod-log.h"
|
2011-06-13 21:52:59 +04:00
|
|
|
|
2014-09-11 00:20:45 +04:00
|
|
|
/* Just an arbitrary number so we can be sure this happened */
|
|
|
|
#define BACKREF_FOUND_SHARED 6
|
|
|
|
|
2012-05-17 18:43:03 +04:00
|
|
|
struct extent_inode_elem {
|
|
|
|
u64 inum;
|
|
|
|
u64 offset;
|
|
|
|
struct extent_inode_elem *next;
|
|
|
|
};
|
|
|
|
|
2017-06-29 06:56:55 +03:00
|
|
|
static int check_extent_in_eb(const struct btrfs_key *key,
|
|
|
|
const struct extent_buffer *eb,
|
|
|
|
const struct btrfs_file_extent_item *fi,
|
|
|
|
u64 extent_item_pos,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
struct extent_inode_elem **eie,
|
|
|
|
bool ignore_offset)
|
2012-05-17 18:43:03 +04:00
|
|
|
{
|
2013-07-05 21:58:19 +04:00
|
|
|
u64 offset = 0;
|
2012-05-17 18:43:03 +04:00
|
|
|
struct extent_inode_elem *e;
|
|
|
|
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
if (!ignore_offset &&
|
|
|
|
!btrfs_file_extent_compression(eb, fi) &&
|
2013-07-05 21:58:19 +04:00
|
|
|
!btrfs_file_extent_encryption(eb, fi) &&
|
|
|
|
!btrfs_file_extent_other_encoding(eb, fi)) {
|
|
|
|
u64 data_offset;
|
|
|
|
u64 data_len;
|
2012-05-17 18:43:03 +04:00
|
|
|
|
2013-07-05 21:58:19 +04:00
|
|
|
data_offset = btrfs_file_extent_offset(eb, fi);
|
|
|
|
data_len = btrfs_file_extent_num_bytes(eb, fi);
|
|
|
|
|
|
|
|
if (extent_item_pos < data_offset ||
|
|
|
|
extent_item_pos >= data_offset + data_len)
|
|
|
|
return 1;
|
|
|
|
offset = extent_item_pos - data_offset;
|
|
|
|
}
|
2012-05-17 18:43:03 +04:00
|
|
|
|
|
|
|
e = kmalloc(sizeof(*e), GFP_NOFS);
|
|
|
|
if (!e)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
e->next = *eie;
|
|
|
|
e->inum = key->objectid;
|
2013-07-05 21:58:19 +04:00
|
|
|
e->offset = key->offset + offset;
|
2012-05-17 18:43:03 +04:00
|
|
|
*eie = e;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-28 15:13:38 +04:00
|
|
|
static void free_inode_elem_list(struct extent_inode_elem *eie)
|
|
|
|
{
|
|
|
|
struct extent_inode_elem *eie_next;
|
|
|
|
|
|
|
|
for (; eie; eie = eie_next) {
|
|
|
|
eie_next = eie->next;
|
|
|
|
kfree(eie);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-29 06:56:55 +03:00
|
|
|
static int find_extent_in_eb(const struct extent_buffer *eb,
|
|
|
|
u64 wanted_disk_byte, u64 extent_item_pos,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
struct extent_inode_elem **eie,
|
|
|
|
bool ignore_offset)
|
2012-05-17 18:43:03 +04:00
|
|
|
{
|
|
|
|
u64 disk_byte;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_file_extent_item *fi;
|
|
|
|
int slot;
|
|
|
|
int nritems;
|
|
|
|
int extent_type;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* from the shared data ref, we only have the leaf but we need
|
|
|
|
* the key. thus, we must look into all items and see that we
|
|
|
|
* find one (some) with a reference to our extent item.
|
|
|
|
*/
|
|
|
|
nritems = btrfs_header_nritems(eb);
|
|
|
|
for (slot = 0; slot < nritems; ++slot) {
|
|
|
|
btrfs_item_key_to_cpu(eb, &key, slot);
|
|
|
|
if (key.type != BTRFS_EXTENT_DATA_KEY)
|
|
|
|
continue;
|
|
|
|
fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
|
|
|
|
extent_type = btrfs_file_extent_type(eb, fi);
|
|
|
|
if (extent_type == BTRFS_FILE_EXTENT_INLINE)
|
|
|
|
continue;
|
|
|
|
/* don't skip BTRFS_FILE_EXTENT_PREALLOC, we can handle that */
|
|
|
|
disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
|
|
|
|
if (disk_byte != wanted_disk_byte)
|
|
|
|
continue;
|
|
|
|
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
ret = check_extent_in_eb(&key, eb, fi, extent_item_pos, eie, ignore_offset);
|
2012-05-17 18:43:03 +04:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-13 01:20:06 +03:00
|
|
|
struct preftree {
|
2018-08-22 22:51:53 +03:00
|
|
|
struct rb_root_cached root;
|
2017-07-13 01:20:07 +03:00
|
|
|
unsigned int count;
|
2017-07-13 01:20:06 +03:00
|
|
|
};
|
|
|
|
|
2018-08-22 22:51:53 +03:00
|
|
|
#define PREFTREE_INIT { .root = RB_ROOT_CACHED, .count = 0 }
|
2017-07-13 01:20:06 +03:00
|
|
|
|
|
|
|
struct preftrees {
|
|
|
|
struct preftree direct; /* BTRFS_SHARED_[DATA|BLOCK]_REF_KEY */
|
|
|
|
struct preftree indirect; /* BTRFS_[TREE_BLOCK|EXTENT_DATA]_REF_KEY */
|
|
|
|
struct preftree indirect_missing_keys;
|
|
|
|
};
|
|
|
|
|
2017-07-13 01:20:10 +03:00
|
|
|
/*
|
|
|
|
* Checks for a shared extent during backref search.
|
|
|
|
*
|
|
|
|
* The share_count tracks prelim_refs (direct and indirect) having a
|
|
|
|
* ref->count >0:
|
|
|
|
* - incremented when a ref->count transitions to >0
|
|
|
|
* - decremented when a ref->count transitions to <1
|
|
|
|
*/
|
|
|
|
struct share_check {
|
|
|
|
u64 root_objectid;
|
|
|
|
u64 inum;
|
|
|
|
int share_count;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline int extent_is_shared(struct share_check *sc)
|
|
|
|
{
|
|
|
|
return (sc && sc->share_count > 1) ? BACKREF_FOUND_SHARED : 0;
|
|
|
|
}
|
|
|
|
|
2013-08-09 09:25:36 +04:00
|
|
|
static struct kmem_cache *btrfs_prelim_ref_cache;
|
|
|
|
|
|
|
|
int __init btrfs_prelim_ref_init(void)
|
|
|
|
{
|
|
|
|
btrfs_prelim_ref_cache = kmem_cache_create("btrfs_prelim_ref",
|
2017-06-29 06:56:57 +03:00
|
|
|
sizeof(struct prelim_ref),
|
2013-08-09 09:25:36 +04:00
|
|
|
0,
|
2016-06-23 21:17:08 +03:00
|
|
|
SLAB_MEM_SPREAD,
|
2013-08-09 09:25:36 +04:00
|
|
|
NULL);
|
|
|
|
if (!btrfs_prelim_ref_cache)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-19 19:24:18 +03:00
|
|
|
void __cold btrfs_prelim_ref_exit(void)
|
2013-08-09 09:25:36 +04:00
|
|
|
{
|
2016-01-29 16:36:35 +03:00
|
|
|
kmem_cache_destroy(btrfs_prelim_ref_cache);
|
2013-08-09 09:25:36 +04:00
|
|
|
}
|
|
|
|
|
2017-07-13 01:20:06 +03:00
|
|
|
static void free_pref(struct prelim_ref *ref)
|
|
|
|
{
|
|
|
|
kmem_cache_free(btrfs_prelim_ref_cache, ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return 0 when both refs are for the same block (and can be merged).
|
|
|
|
* A -1 return indicates ref1 is a 'lower' block than ref2, while 1
|
|
|
|
* indicates a 'higher' block.
|
|
|
|
*/
|
|
|
|
static int prelim_ref_compare(struct prelim_ref *ref1,
|
|
|
|
struct prelim_ref *ref2)
|
|
|
|
{
|
|
|
|
if (ref1->level < ref2->level)
|
|
|
|
return -1;
|
|
|
|
if (ref1->level > ref2->level)
|
|
|
|
return 1;
|
|
|
|
if (ref1->root_id < ref2->root_id)
|
|
|
|
return -1;
|
|
|
|
if (ref1->root_id > ref2->root_id)
|
|
|
|
return 1;
|
|
|
|
if (ref1->key_for_search.type < ref2->key_for_search.type)
|
|
|
|
return -1;
|
|
|
|
if (ref1->key_for_search.type > ref2->key_for_search.type)
|
|
|
|
return 1;
|
|
|
|
if (ref1->key_for_search.objectid < ref2->key_for_search.objectid)
|
|
|
|
return -1;
|
|
|
|
if (ref1->key_for_search.objectid > ref2->key_for_search.objectid)
|
|
|
|
return 1;
|
|
|
|
if (ref1->key_for_search.offset < ref2->key_for_search.offset)
|
|
|
|
return -1;
|
|
|
|
if (ref1->key_for_search.offset > ref2->key_for_search.offset)
|
|
|
|
return 1;
|
|
|
|
if (ref1->parent < ref2->parent)
|
|
|
|
return -1;
|
|
|
|
if (ref1->parent > ref2->parent)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-11-30 15:14:47 +03:00
|
|
|
static void update_share_count(struct share_check *sc, int oldcount,
|
|
|
|
int newcount)
|
2017-07-13 01:20:10 +03:00
|
|
|
{
|
|
|
|
if ((!sc) || (oldcount == 0 && newcount < 1))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (oldcount > 0 && newcount < 1)
|
|
|
|
sc->share_count--;
|
|
|
|
else if (oldcount < 1 && newcount > 0)
|
|
|
|
sc->share_count++;
|
|
|
|
}
|
|
|
|
|
2017-07-13 01:20:06 +03:00
|
|
|
/*
|
|
|
|
* Add @newref to the @root rbtree, merging identical refs.
|
|
|
|
*
|
2017-07-13 01:20:10 +03:00
|
|
|
* Callers should assume that newref has been freed after calling.
|
2017-07-13 01:20:06 +03:00
|
|
|
*/
|
2017-07-13 01:20:08 +03:00
|
|
|
static void prelim_ref_insert(const struct btrfs_fs_info *fs_info,
|
|
|
|
struct preftree *preftree,
|
2017-07-13 01:20:10 +03:00
|
|
|
struct prelim_ref *newref,
|
|
|
|
struct share_check *sc)
|
2017-07-13 01:20:06 +03:00
|
|
|
{
|
2018-08-22 22:51:53 +03:00
|
|
|
struct rb_root_cached *root;
|
2017-07-13 01:20:06 +03:00
|
|
|
struct rb_node **p;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct prelim_ref *ref;
|
|
|
|
int result;
|
2018-08-22 22:51:53 +03:00
|
|
|
bool leftmost = true;
|
2017-07-13 01:20:06 +03:00
|
|
|
|
|
|
|
root = &preftree->root;
|
2018-08-22 22:51:53 +03:00
|
|
|
p = &root->rb_root.rb_node;
|
2017-07-13 01:20:06 +03:00
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
ref = rb_entry(parent, struct prelim_ref, rbnode);
|
|
|
|
result = prelim_ref_compare(ref, newref);
|
|
|
|
if (result < 0) {
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
} else if (result > 0) {
|
|
|
|
p = &(*p)->rb_right;
|
2018-08-22 22:51:53 +03:00
|
|
|
leftmost = false;
|
2017-07-13 01:20:06 +03:00
|
|
|
} else {
|
|
|
|
/* Identical refs, merge them and free @newref */
|
|
|
|
struct extent_inode_elem *eie = ref->inode_list;
|
|
|
|
|
|
|
|
while (eie && eie->next)
|
|
|
|
eie = eie->next;
|
|
|
|
|
|
|
|
if (!eie)
|
|
|
|
ref->inode_list = newref->inode_list;
|
|
|
|
else
|
|
|
|
eie->next = newref->inode_list;
|
2017-07-13 01:20:08 +03:00
|
|
|
trace_btrfs_prelim_ref_merge(fs_info, ref, newref,
|
|
|
|
preftree->count);
|
2017-07-13 01:20:10 +03:00
|
|
|
/*
|
|
|
|
* A delayed ref can have newref->count < 0.
|
|
|
|
* The ref->count is updated to follow any
|
|
|
|
* BTRFS_[ADD|DROP]_DELAYED_REF actions.
|
|
|
|
*/
|
|
|
|
update_share_count(sc, ref->count,
|
|
|
|
ref->count + newref->count);
|
2017-07-13 01:20:06 +03:00
|
|
|
ref->count += newref->count;
|
|
|
|
free_pref(newref);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-13 01:20:10 +03:00
|
|
|
update_share_count(sc, 0, newref->count);
|
2017-07-13 01:20:07 +03:00
|
|
|
preftree->count++;
|
2017-07-13 01:20:08 +03:00
|
|
|
trace_btrfs_prelim_ref_insert(fs_info, newref, NULL, preftree->count);
|
2017-07-13 01:20:06 +03:00
|
|
|
rb_link_node(&newref->rbnode, parent, p);
|
2018-08-22 22:51:53 +03:00
|
|
|
rb_insert_color_cached(&newref->rbnode, root, leftmost);
|
2017-07-13 01:20:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Release the entire tree. We don't care about internal consistency so
|
|
|
|
* just free everything and then reset the tree root.
|
|
|
|
*/
|
|
|
|
static void prelim_release(struct preftree *preftree)
|
|
|
|
{
|
|
|
|
struct prelim_ref *ref, *next_ref;
|
|
|
|
|
2018-08-22 22:51:53 +03:00
|
|
|
rbtree_postorder_for_each_entry_safe(ref, next_ref,
|
|
|
|
&preftree->root.rb_root, rbnode)
|
2017-07-13 01:20:06 +03:00
|
|
|
free_pref(ref);
|
|
|
|
|
2018-08-22 22:51:53 +03:00
|
|
|
preftree->root = RB_ROOT_CACHED;
|
2017-07-13 01:20:07 +03:00
|
|
|
preftree->count = 0;
|
2017-07-13 01:20:06 +03:00
|
|
|
}
|
|
|
|
|
2012-05-15 19:55:51 +04:00
|
|
|
/*
|
|
|
|
* the rules for all callers of this function are:
|
|
|
|
* - obtaining the parent is the goal
|
|
|
|
* - if you add a key, you must know that it is a correct key
|
|
|
|
* - if you cannot add the parent or a correct key, then we will look into the
|
|
|
|
* block later to set a correct key
|
|
|
|
*
|
|
|
|
* delayed refs
|
|
|
|
* ============
|
|
|
|
* backref type | shared | indirect | shared | indirect
|
|
|
|
* information | tree | tree | data | data
|
|
|
|
* --------------------+--------+----------+--------+----------
|
|
|
|
* parent logical | y | - | - | -
|
|
|
|
* key to resolve | - | y | y | y
|
|
|
|
* tree block logical | - | - | - | -
|
|
|
|
* root for resolving | y | y | y | y
|
|
|
|
*
|
|
|
|
* - column 1: we've the parent -> done
|
|
|
|
* - column 2, 3, 4: we use the key to find the parent
|
|
|
|
*
|
|
|
|
* on disk refs (inline or keyed)
|
|
|
|
* ==============================
|
|
|
|
* backref type | shared | indirect | shared | indirect
|
|
|
|
* information | tree | tree | data | data
|
|
|
|
* --------------------+--------+----------+--------+----------
|
|
|
|
* parent logical | y | - | y | -
|
|
|
|
* key to resolve | - | - | - | y
|
|
|
|
* tree block logical | y | y | y | y
|
|
|
|
* root for resolving | - | y | y | y
|
|
|
|
*
|
|
|
|
* - column 1, 3: we've the parent -> done
|
|
|
|
* - column 2: we take the first key from the block to find the parent
|
2017-06-29 06:56:57 +03:00
|
|
|
* (see add_missing_keys)
|
2012-05-15 19:55:51 +04:00
|
|
|
* - column 4: we use the key to find the parent
|
|
|
|
*
|
|
|
|
* additional information that's available but not required to find the parent
|
|
|
|
* block might help in merging entries to gain some speed.
|
|
|
|
*/
|
2017-07-13 01:20:08 +03:00
|
|
|
static int add_prelim_ref(const struct btrfs_fs_info *fs_info,
|
|
|
|
struct preftree *preftree, u64 root_id,
|
2017-06-29 06:56:57 +03:00
|
|
|
const struct btrfs_key *key, int level, u64 parent,
|
2017-07-13 01:20:10 +03:00
|
|
|
u64 wanted_disk_byte, int count,
|
|
|
|
struct share_check *sc, gfp_t gfp_mask)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
2017-06-29 06:56:57 +03:00
|
|
|
struct prelim_ref *ref;
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2013-10-30 09:25:24 +04:00
|
|
|
if (root_id == BTRFS_DATA_RELOC_TREE_OBJECTID)
|
|
|
|
return 0;
|
|
|
|
|
2013-08-09 09:25:36 +04:00
|
|
|
ref = kmem_cache_alloc(btrfs_prelim_ref_cache, gfp_mask);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (!ref)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ref->root_id = root_id;
|
2020-02-07 12:38:15 +03:00
|
|
|
if (key)
|
2012-05-15 19:55:51 +04:00
|
|
|
ref->key_for_search = *key;
|
2020-02-07 12:38:15 +03:00
|
|
|
else
|
2012-05-15 19:55:51 +04:00
|
|
|
memset(&ref->key_for_search, 0, sizeof(ref->key_for_search));
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2012-05-30 20:05:21 +04:00
|
|
|
ref->inode_list = NULL;
|
2011-11-23 21:55:04 +04:00
|
|
|
ref->level = level;
|
|
|
|
ref->count = count;
|
|
|
|
ref->parent = parent;
|
|
|
|
ref->wanted_disk_byte = wanted_disk_byte;
|
2017-07-13 01:20:10 +03:00
|
|
|
prelim_ref_insert(fs_info, preftree, ref, sc);
|
|
|
|
return extent_is_shared(sc);
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
2017-07-13 01:20:06 +03:00
|
|
|
/* direct refs use root == 0, key == NULL */
|
2017-07-13 01:20:08 +03:00
|
|
|
static int add_direct_ref(const struct btrfs_fs_info *fs_info,
|
|
|
|
struct preftrees *preftrees, int level, u64 parent,
|
2017-07-13 01:20:10 +03:00
|
|
|
u64 wanted_disk_byte, int count,
|
|
|
|
struct share_check *sc, gfp_t gfp_mask)
|
2017-07-13 01:20:06 +03:00
|
|
|
{
|
2017-07-13 01:20:08 +03:00
|
|
|
return add_prelim_ref(fs_info, &preftrees->direct, 0, NULL, level,
|
2017-07-13 01:20:10 +03:00
|
|
|
parent, wanted_disk_byte, count, sc, gfp_mask);
|
2017-07-13 01:20:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* indirect refs use parent == 0 */
|
2017-07-13 01:20:08 +03:00
|
|
|
static int add_indirect_ref(const struct btrfs_fs_info *fs_info,
|
|
|
|
struct preftrees *preftrees, u64 root_id,
|
2017-07-13 01:20:06 +03:00
|
|
|
const struct btrfs_key *key, int level,
|
2017-07-13 01:20:10 +03:00
|
|
|
u64 wanted_disk_byte, int count,
|
|
|
|
struct share_check *sc, gfp_t gfp_mask)
|
2017-07-13 01:20:06 +03:00
|
|
|
{
|
|
|
|
struct preftree *tree = &preftrees->indirect;
|
|
|
|
|
|
|
|
if (!key)
|
|
|
|
tree = &preftrees->indirect_missing_keys;
|
2017-07-13 01:20:08 +03:00
|
|
|
return add_prelim_ref(fs_info, tree, root_id, key, level, 0,
|
2017-07-13 01:20:10 +03:00
|
|
|
wanted_disk_byte, count, sc, gfp_mask);
|
2017-07-13 01:20:06 +03:00
|
|
|
}
|
|
|
|
|
2020-02-07 12:38:16 +03:00
|
|
|
static int is_shared_data_backref(struct preftrees *preftrees, u64 bytenr)
|
|
|
|
{
|
|
|
|
struct rb_node **p = &preftrees->direct.root.rb_root.rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct prelim_ref *ref = NULL;
|
2020-04-29 16:27:32 +03:00
|
|
|
struct prelim_ref target = {};
|
2020-02-07 12:38:16 +03:00
|
|
|
int result;
|
|
|
|
|
|
|
|
target.parent = bytenr;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
ref = rb_entry(parent, struct prelim_ref, rbnode);
|
|
|
|
result = prelim_ref_compare(ref, &target);
|
|
|
|
|
|
|
|
if (result < 0)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (result > 0)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path,
|
2020-02-07 12:38:16 +03:00
|
|
|
struct ulist *parents,
|
|
|
|
struct preftrees *preftrees, struct prelim_ref *ref,
|
2014-03-19 21:35:14 +04:00
|
|
|
int level, u64 time_seq, const u64 *extent_item_pos,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
bool ignore_offset)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
2012-06-19 17:42:26 +04:00
|
|
|
int ret = 0;
|
|
|
|
int slot;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
struct btrfs_key key;
|
2014-01-24 23:05:42 +04:00
|
|
|
struct btrfs_key *key_for_search = &ref->key_for_search;
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_file_extent_item *fi;
|
2013-07-05 22:03:47 +04:00
|
|
|
struct extent_inode_elem *eie = NULL, *old = NULL;
|
2011-11-23 21:55:04 +04:00
|
|
|
u64 disk_byte;
|
2014-01-24 23:05:42 +04:00
|
|
|
u64 wanted_disk_byte = ref->wanted_disk_byte;
|
|
|
|
u64 count = 0;
|
2020-02-07 12:38:15 +03:00
|
|
|
u64 data_offset;
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2012-06-19 17:42:26 +04:00
|
|
|
if (level != 0) {
|
|
|
|
eb = path->nodes[level];
|
|
|
|
ret = ulist_add(parents, eb->start, 0, GFP_NOFS);
|
2012-05-30 20:05:21 +04:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-11-23 21:55:04 +04:00
|
|
|
return 0;
|
2012-06-19 17:42:26 +04:00
|
|
|
}
|
2011-11-23 21:55:04 +04:00
|
|
|
|
|
|
|
/*
|
2020-02-07 12:38:16 +03:00
|
|
|
* 1. We normally enter this function with the path already pointing to
|
|
|
|
* the first item to check. But sometimes, we may enter it with
|
|
|
|
* slot == nritems.
|
|
|
|
* 2. We are searching for normal backref but bytenr of this leaf
|
|
|
|
* matches shared data backref
|
2020-02-07 12:38:17 +03:00
|
|
|
* 3. The leaf owner is not equal to the root we are searching
|
|
|
|
*
|
2020-02-07 12:38:16 +03:00
|
|
|
* For these cases, go to the next leaf before we continue.
|
2011-11-23 21:55:04 +04:00
|
|
|
*/
|
2020-02-07 12:38:16 +03:00
|
|
|
eb = path->nodes[0];
|
|
|
|
if (path->slots[0] >= btrfs_header_nritems(eb) ||
|
2020-02-07 12:38:17 +03:00
|
|
|
is_shared_data_backref(preftrees, eb->start) ||
|
|
|
|
ref->root_id != btrfs_header_owner(eb)) {
|
2021-03-11 17:31:07 +03:00
|
|
|
if (time_seq == BTRFS_SEQ_LAST)
|
2015-04-16 09:54:50 +03:00
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
else
|
|
|
|
ret = btrfs_next_old_leaf(root, path, time_seq);
|
|
|
|
}
|
2011-11-23 21:55:04 +04:00
|
|
|
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
while (!ret && count < ref->count) {
|
2011-11-23 21:55:04 +04:00
|
|
|
eb = path->nodes[0];
|
2012-06-19 17:42:26 +04:00
|
|
|
slot = path->slots[0];
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(eb, &key, slot);
|
|
|
|
|
|
|
|
if (key.objectid != key_for_search->objectid ||
|
|
|
|
key.type != BTRFS_EXTENT_DATA_KEY)
|
|
|
|
break;
|
|
|
|
|
2020-02-07 12:38:16 +03:00
|
|
|
/*
|
|
|
|
* We are searching for normal backref but bytenr of this leaf
|
2020-02-07 12:38:17 +03:00
|
|
|
* matches shared data backref, OR
|
|
|
|
* the leaf owner is not equal to the root we are searching for
|
2020-02-07 12:38:16 +03:00
|
|
|
*/
|
2020-02-07 12:38:17 +03:00
|
|
|
if (slot == 0 &&
|
|
|
|
(is_shared_data_backref(preftrees, eb->start) ||
|
|
|
|
ref->root_id != btrfs_header_owner(eb))) {
|
2021-03-11 17:31:07 +03:00
|
|
|
if (time_seq == BTRFS_SEQ_LAST)
|
2020-02-07 12:38:16 +03:00
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
else
|
|
|
|
ret = btrfs_next_old_leaf(root, path, time_seq);
|
|
|
|
continue;
|
|
|
|
}
|
2012-06-19 17:42:26 +04:00
|
|
|
fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
|
|
|
|
disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
|
2020-02-07 12:38:15 +03:00
|
|
|
data_offset = btrfs_file_extent_offset(eb, fi);
|
2012-06-19 17:42:26 +04:00
|
|
|
|
|
|
|
if (disk_byte == wanted_disk_byte) {
|
|
|
|
eie = NULL;
|
2013-07-05 22:03:47 +04:00
|
|
|
old = NULL;
|
2020-02-07 12:38:15 +03:00
|
|
|
if (ref->key_for_search.offset == key.offset - data_offset)
|
|
|
|
count++;
|
|
|
|
else
|
|
|
|
goto next;
|
2012-06-19 17:42:26 +04:00
|
|
|
if (extent_item_pos) {
|
|
|
|
ret = check_extent_in_eb(&key, eb, fi,
|
|
|
|
*extent_item_pos,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
&eie, ignore_offset);
|
2012-06-19 17:42:26 +04:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
}
|
2013-07-05 22:03:47 +04:00
|
|
|
if (ret > 0)
|
|
|
|
goto next;
|
2014-07-28 12:57:04 +04:00
|
|
|
ret = ulist_add_merge_ptr(parents, eb->start,
|
|
|
|
eie, (void **)&old, GFP_NOFS);
|
2013-07-05 22:03:47 +04:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
if (!ret && extent_item_pos) {
|
|
|
|
while (old->next)
|
|
|
|
old = old->next;
|
|
|
|
old->next = eie;
|
2012-06-19 17:42:26 +04:00
|
|
|
}
|
2014-01-28 15:13:38 +04:00
|
|
|
eie = NULL;
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
2013-07-05 22:03:47 +04:00
|
|
|
next:
|
2021-03-11 17:31:07 +03:00
|
|
|
if (time_seq == BTRFS_SEQ_LAST)
|
2015-04-16 09:54:50 +03:00
|
|
|
ret = btrfs_next_item(root, path);
|
|
|
|
else
|
|
|
|
ret = btrfs_next_old_item(root, path, time_seq);
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
2012-06-19 17:42:26 +04:00
|
|
|
if (ret > 0)
|
|
|
|
ret = 0;
|
2014-01-28 15:13:38 +04:00
|
|
|
else if (ret < 0)
|
|
|
|
free_inode_elem_list(eie);
|
2012-06-19 17:42:26 +04:00
|
|
|
return ret;
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* resolve an indirect backref in the form (root_id, key, level)
|
|
|
|
* to a logical address
|
|
|
|
*/
|
2017-06-29 06:56:57 +03:00
|
|
|
static int resolve_indirect_ref(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_path *path, u64 time_seq,
|
2020-02-07 12:38:16 +03:00
|
|
|
struct preftrees *preftrees,
|
2017-06-29 06:56:57 +03:00
|
|
|
struct prelim_ref *ref, struct ulist *parents,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
const u64 *extent_item_pos, bool ignore_offset)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
|
|
|
struct btrfs_root *root;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
int ret = 0;
|
|
|
|
int root_level;
|
|
|
|
int level = ref->level;
|
2020-02-07 12:38:15 +03:00
|
|
|
struct btrfs_key search_key = ref->key_for_search;
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2020-10-19 23:02:31 +03:00
|
|
|
/*
|
|
|
|
* If we're search_commit_root we could possibly be holding locks on
|
|
|
|
* other tree nodes. This happens when qgroups does backref walks when
|
|
|
|
* adding new delayed refs. To deal with this we need to look in cache
|
|
|
|
* for the root, and if we don't find it then we need to search the
|
|
|
|
* tree_root's commit root, thus the btrfs_get_fs_root_commit_root usage
|
|
|
|
* here.
|
|
|
|
*/
|
|
|
|
if (path->search_commit_root)
|
|
|
|
root = btrfs_get_fs_root_commit_root(fs_info, path, ref->root_id);
|
|
|
|
else
|
|
|
|
root = btrfs_get_fs_root(fs_info, ref->root_id, false);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (IS_ERR(root)) {
|
|
|
|
ret = PTR_ERR(root);
|
2020-01-24 17:32:28 +03:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
btrfs: do not resolve backrefs for roots that are being deleted
Zygo reported a deadlock where a task was stuck in the inode logical
resolve code. The deadlock looks like this
Task 1
btrfs_ioctl_logical_to_ino
->iterate_inodes_from_logical
->iterate_extent_inodes
->path->search_commit_root isn't set, so a transaction is started
->resolve_indirect_ref for a root that's being deleted
->search for our key, attempt to lock a node, DEADLOCK
Task 2
btrfs_drop_snapshot
->walk down to a leaf, lock it, walk up, lock node
->end transaction
->start transaction
-> wait_cur_trans
Task 3
btrfs_commit_transaction
->wait_event(cur_trans->write_wait, num_writers == 1) DEADLOCK
We are holding a transaction open in btrfs_ioctl_logical_to_ino while we
try to resolve our references. btrfs_drop_snapshot() holds onto its
locks while it stops and starts transaction handles, because it assumes
nobody is going to touch the root now. Commit just does what commit
does, waiting for the writers to finish, blocking any new trans handles
from starting.
Fix this by making the backref code not try to resolve backrefs of roots
that are currently being deleted. This will keep us from walking into a
snapshot that's currently being deleted.
This problem was harder to hit before because we rarely broke out of the
snapshot delete halfway through, but with my delayed ref throttling code
it happened much more often. However we've always been able to do this,
so it's not a new problem.
Fixes: 8da6d5815c59 ("Btrfs: added btrfs_find_all_roots()")
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2020-03-14 00:17:09 +03:00
|
|
|
if (!path->search_commit_root &&
|
|
|
|
test_bit(BTRFS_ROOT_DELETING, &root->state)) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-06-21 16:52:41 +03:00
|
|
|
if (btrfs_is_testing(fs_info)) {
|
2015-10-05 17:35:29 +03:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-03-13 23:42:13 +04:00
|
|
|
if (path->search_commit_root)
|
|
|
|
root_level = btrfs_header_level(root->commit_root);
|
2021-03-11 17:31:07 +03:00
|
|
|
else if (time_seq == BTRFS_SEQ_LAST)
|
2015-04-16 09:54:50 +03:00
|
|
|
root_level = btrfs_header_level(root->node);
|
2014-03-13 23:42:13 +04:00
|
|
|
else
|
|
|
|
root_level = btrfs_old_root_level(root, time_seq);
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2020-02-15 00:11:47 +03:00
|
|
|
if (root_level + 1 == level)
|
2011-11-23 21:55:04 +04:00
|
|
|
goto out;
|
|
|
|
|
2020-02-07 12:38:15 +03:00
|
|
|
/*
|
|
|
|
* We can often find data backrefs with an offset that is too large
|
|
|
|
* (>= LLONG_MAX, maximum allowed file offset) due to underflows when
|
|
|
|
* subtracting a file's offset with the data offset of its
|
|
|
|
* corresponding extent data item. This can happen for example in the
|
|
|
|
* clone ioctl.
|
|
|
|
*
|
|
|
|
* So if we detect such case we set the search key's offset to zero to
|
|
|
|
* make sure we will find the matching file extent item at
|
|
|
|
* add_all_parents(), otherwise we will miss it because the offset
|
|
|
|
* taken form the backref is much larger then the offset of the file
|
|
|
|
* extent item. This can make us scan a very large number of file
|
|
|
|
* extent items, but at least it will not make us miss any.
|
|
|
|
*
|
|
|
|
* This is an ugly workaround for a behaviour that should have never
|
|
|
|
* existed, but it does and a fix for the clone ioctl would touch a lot
|
|
|
|
* of places, cause backwards incompatibility and would not fix the
|
|
|
|
* problem for extents cloned with older kernels.
|
|
|
|
*/
|
|
|
|
if (search_key.type == BTRFS_EXTENT_DATA_KEY &&
|
|
|
|
search_key.offset >= LLONG_MAX)
|
|
|
|
search_key.offset = 0;
|
2011-11-23 21:55:04 +04:00
|
|
|
path->lowest_level = level;
|
2021-03-11 17:31:07 +03:00
|
|
|
if (time_seq == BTRFS_SEQ_LAST)
|
2020-02-07 12:38:15 +03:00
|
|
|
ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
|
2015-04-16 09:54:50 +03:00
|
|
|
else
|
2020-02-07 12:38:15 +03:00
|
|
|
ret = btrfs_search_old_slot(root, &search_key, path, time_seq);
|
2014-01-23 09:47:48 +04:00
|
|
|
|
2016-09-20 17:05:02 +03:00
|
|
|
btrfs_debug(fs_info,
|
|
|
|
"search slot in root %llu (level %d, ref count %d) returned %d for key (%llu %u %llu)",
|
2013-08-20 15:20:07 +04:00
|
|
|
ref->root_id, level, ref->count, ret,
|
|
|
|
ref->key_for_search.objectid, ref->key_for_search.type,
|
|
|
|
ref->key_for_search.offset);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
eb = path->nodes[level];
|
2012-06-27 17:23:09 +04:00
|
|
|
while (!eb) {
|
2013-10-31 09:00:08 +04:00
|
|
|
if (WARN_ON(!level)) {
|
2012-06-27 17:23:09 +04:00
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
level--;
|
|
|
|
eb = path->nodes[level];
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
2020-02-07 12:38:16 +03:00
|
|
|
ret = add_all_parents(root, path, parents, preftrees, ref, level,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
time_seq, extent_item_pos, ignore_offset);
|
2011-11-23 21:55:04 +04:00
|
|
|
out:
|
2020-01-24 17:33:01 +03:00
|
|
|
btrfs_put_root(root);
|
2020-01-24 17:32:28 +03:00
|
|
|
out_free:
|
2013-06-13 00:20:08 +04:00
|
|
|
path->lowest_level = 0;
|
|
|
|
btrfs_release_path(path);
|
2011-11-23 21:55:04 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-06-29 06:56:56 +03:00
|
|
|
static struct extent_inode_elem *
|
|
|
|
unode_aux_to_inode_list(struct ulist_node *node)
|
|
|
|
{
|
|
|
|
if (!node)
|
|
|
|
return NULL;
|
|
|
|
return (struct extent_inode_elem *)(uintptr_t)node->aux;
|
|
|
|
}
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
/*
|
2018-11-28 14:05:13 +03:00
|
|
|
* We maintain three separate rbtrees: one for direct refs, one for
|
2017-07-13 01:20:06 +03:00
|
|
|
* indirect refs which have a key, and one for indirect refs which do not
|
|
|
|
* have a key. Each tree does merge on insertion.
|
|
|
|
*
|
|
|
|
* Once all of the references are located, we iterate over the tree of
|
|
|
|
* indirect refs with missing keys. An appropriate key is located and
|
|
|
|
* the ref is moved onto the tree for indirect refs. After all missing
|
|
|
|
* keys are thus located, we iterate over the indirect ref tree, resolve
|
|
|
|
* each reference, and then insert the resolved reference onto the
|
|
|
|
* direct tree (merging there too).
|
|
|
|
*
|
|
|
|
* New backrefs (i.e., for parent nodes) are added to the appropriate
|
|
|
|
* rbtree as they are encountered. The new backrefs are subsequently
|
|
|
|
* resolved as above.
|
2011-11-23 21:55:04 +04:00
|
|
|
*/
|
2017-06-29 06:56:57 +03:00
|
|
|
static int resolve_indirect_refs(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_path *path, u64 time_seq,
|
2017-07-13 01:20:06 +03:00
|
|
|
struct preftrees *preftrees,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
const u64 *extent_item_pos,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
struct share_check *sc, bool ignore_offset)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int ret = 0;
|
|
|
|
struct ulist *parents;
|
|
|
|
struct ulist_node *node;
|
2012-05-22 16:56:50 +04:00
|
|
|
struct ulist_iterator uiter;
|
2017-07-13 01:20:06 +03:00
|
|
|
struct rb_node *rnode;
|
2011-11-23 21:55:04 +04:00
|
|
|
|
|
|
|
parents = ulist_alloc(GFP_NOFS);
|
|
|
|
if (!parents)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/*
|
2017-07-13 01:20:06 +03:00
|
|
|
* We could trade memory usage for performance here by iterating
|
|
|
|
* the tree, allocating new refs for each insertion, and then
|
|
|
|
* freeing the entire indirect tree when we're done. In some test
|
|
|
|
* cases, the tree can grow quite large (~200k objects).
|
2011-11-23 21:55:04 +04:00
|
|
|
*/
|
2018-08-22 22:51:53 +03:00
|
|
|
while ((rnode = rb_first_cached(&preftrees->indirect.root))) {
|
2017-07-13 01:20:06 +03:00
|
|
|
struct prelim_ref *ref;
|
|
|
|
|
|
|
|
ref = rb_entry(rnode, struct prelim_ref, rbnode);
|
|
|
|
if (WARN(ref->parent,
|
|
|
|
"BUG: direct ref found in indirect tree")) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-08-22 22:51:53 +03:00
|
|
|
rb_erase_cached(&ref->rbnode, &preftrees->indirect.root);
|
2017-07-13 01:20:07 +03:00
|
|
|
preftrees->indirect.count--;
|
2017-07-13 01:20:06 +03:00
|
|
|
|
|
|
|
if (ref->count == 0) {
|
|
|
|
free_pref(ref);
|
2011-11-23 21:55:04 +04:00
|
|
|
continue;
|
2017-07-13 01:20:06 +03:00
|
|
|
}
|
|
|
|
|
2017-07-13 01:20:10 +03:00
|
|
|
if (sc && sc->root_objectid &&
|
|
|
|
ref->root_id != sc->root_objectid) {
|
2017-07-13 01:20:06 +03:00
|
|
|
free_pref(ref);
|
2014-09-11 00:20:45 +04:00
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
goto out;
|
|
|
|
}
|
2020-02-07 12:38:16 +03:00
|
|
|
err = resolve_indirect_ref(fs_info, path, time_seq, preftrees,
|
|
|
|
ref, parents, extent_item_pos,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
ignore_offset);
|
2014-01-23 09:47:49 +04:00
|
|
|
/*
|
|
|
|
* we can only tolerate ENOENT,otherwise,we should catch error
|
|
|
|
* and return directly.
|
|
|
|
*/
|
|
|
|
if (err == -ENOENT) {
|
2017-07-13 01:20:10 +03:00
|
|
|
prelim_ref_insert(fs_info, &preftrees->direct, ref,
|
|
|
|
NULL);
|
2011-11-23 21:55:04 +04:00
|
|
|
continue;
|
2014-01-23 09:47:49 +04:00
|
|
|
} else if (err) {
|
2017-07-13 01:20:06 +03:00
|
|
|
free_pref(ref);
|
2014-01-23 09:47:49 +04:00
|
|
|
ret = err;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-11-23 21:55:04 +04:00
|
|
|
|
|
|
|
/* we put the first parent into the ref at hand */
|
2012-05-22 16:56:50 +04:00
|
|
|
ULIST_ITER_INIT(&uiter);
|
|
|
|
node = ulist_next(parents, &uiter);
|
2011-11-23 21:55:04 +04:00
|
|
|
ref->parent = node ? node->val : 0;
|
2017-06-29 06:56:56 +03:00
|
|
|
ref->inode_list = unode_aux_to_inode_list(node);
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2017-07-13 01:20:06 +03:00
|
|
|
/* Add a prelim_ref(s) for any other parent(s). */
|
2012-05-22 16:56:50 +04:00
|
|
|
while ((node = ulist_next(parents, &uiter))) {
|
2017-07-13 01:20:06 +03:00
|
|
|
struct prelim_ref *new_ref;
|
|
|
|
|
2013-08-09 09:25:36 +04:00
|
|
|
new_ref = kmem_cache_alloc(btrfs_prelim_ref_cache,
|
|
|
|
GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (!new_ref) {
|
2017-07-13 01:20:06 +03:00
|
|
|
free_pref(ref);
|
2011-11-23 21:55:04 +04:00
|
|
|
ret = -ENOMEM;
|
2013-04-15 14:26:38 +04:00
|
|
|
goto out;
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
memcpy(new_ref, ref, sizeof(*ref));
|
|
|
|
new_ref->parent = node->val;
|
2017-06-29 06:56:56 +03:00
|
|
|
new_ref->inode_list = unode_aux_to_inode_list(node);
|
2017-07-13 01:20:10 +03:00
|
|
|
prelim_ref_insert(fs_info, &preftrees->direct,
|
|
|
|
new_ref, NULL);
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
2017-07-13 01:20:06 +03:00
|
|
|
|
2017-07-13 01:20:10 +03:00
|
|
|
/*
|
2018-11-28 14:05:13 +03:00
|
|
|
* Now it's a direct ref, put it in the direct tree. We must
|
2017-07-13 01:20:10 +03:00
|
|
|
* do this last because the ref could be merged/freed here.
|
|
|
|
*/
|
|
|
|
prelim_ref_insert(fs_info, &preftrees->direct, ref, NULL);
|
2017-07-13 01:20:06 +03:00
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
ulist_reinit(parents);
|
2017-07-13 01:20:09 +03:00
|
|
|
cond_resched();
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
2013-04-15 14:26:38 +04:00
|
|
|
out:
|
2011-11-23 21:55:04 +04:00
|
|
|
ulist_free(parents);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-15 19:55:51 +04:00
|
|
|
/*
|
|
|
|
* read tree blocks and add keys where required.
|
|
|
|
*/
|
2017-06-29 06:56:57 +03:00
|
|
|
static int add_missing_keys(struct btrfs_fs_info *fs_info,
|
btrfs: honor path->skip_locking in backref code
Qgroups will do the old roots lookup at delayed ref time, which could be
while walking down the extent root while running a delayed ref. This
should be fine, except we specifically lock eb's in the backref walking
code irrespective of path->skip_locking, which deadlocks the system.
Fix up the backref code to honor path->skip_locking, nobody will be
modifying the commit_root when we're searching so it's completely safe
to do.
This happens since fb235dc06fac ("btrfs: qgroup: Move half of the qgroup
accounting time out of commit trans"), kernel may lockup with quota
enabled.
There is one backref trace triggered by snapshot dropping along with
write operation in the source subvolume. The example can be reliably
reproduced:
btrfs-cleaner D 0 4062 2 0x80000000
Call Trace:
schedule+0x32/0x90
btrfs_tree_read_lock+0x93/0x130 [btrfs]
find_parent_nodes+0x29b/0x1170 [btrfs]
btrfs_find_all_roots_safe+0xa8/0x120 [btrfs]
btrfs_find_all_roots+0x57/0x70 [btrfs]
btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
btrfs_qgroup_trace_leaf_items+0x10b/0x140 [btrfs]
btrfs_qgroup_trace_subtree+0xc8/0xe0 [btrfs]
do_walk_down+0x541/0x5e3 [btrfs]
walk_down_tree+0xab/0xe7 [btrfs]
btrfs_drop_snapshot+0x356/0x71a [btrfs]
btrfs_clean_one_deleted_snapshot+0xb8/0xf0 [btrfs]
cleaner_kthread+0x12b/0x160 [btrfs]
kthread+0x112/0x130
ret_from_fork+0x27/0x50
When dropping snapshots with qgroup enabled, we will trigger backref
walk.
However such backref walk at that timing is pretty dangerous, as if one
of the parent nodes get WRITE locked by other thread, we could cause a
dead lock.
For example:
FS 260 FS 261 (Dropped)
node A node B
/ \ / \
node C node D node E
/ \ / \ / \
leaf F|leaf G|leaf H|leaf I|leaf J|leaf K
The lock sequence would be:
Thread A (cleaner) | Thread B (other writer)
-----------------------------------------------------------------------
write_lock(B) |
write_lock(D) |
^^^ called by walk_down_tree() |
| write_lock(A)
| write_lock(D) << Stall
read_lock(H) << for backref walk |
read_lock(D) << lock owner is |
the same thread A |
so read lock is OK |
read_lock(A) << Stall |
So thread A hold write lock D, and needs read lock A to unlock.
While thread B holds write lock A, while needs lock D to unlock.
This will cause a deadlock.
This is not only limited to snapshot dropping case. As the backref
walk, even only happens on commit trees, is breaking the normal top-down
locking order, makes it deadlock prone.
Fixes: fb235dc06fac ("btrfs: qgroup: Move half of the qgroup accounting time out of commit trans")
CC: stable@vger.kernel.org # 4.14+
Reported-and-tested-by: David Sterba <dsterba@suse.com>
Reported-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
[ rebase to latest branch and fix lock assert bug in btrfs/007 ]
Signed-off-by: Qu Wenruo <wqu@suse.com>
[ copy logs and deadlock analysis from Qu's patch ]
Signed-off-by: David Sterba <dsterba@suse.com>
2019-01-16 19:00:57 +03:00
|
|
|
struct preftrees *preftrees, bool lock)
|
2012-05-15 19:55:51 +04:00
|
|
|
{
|
2017-06-29 06:56:57 +03:00
|
|
|
struct prelim_ref *ref;
|
2012-05-15 19:55:51 +04:00
|
|
|
struct extent_buffer *eb;
|
2017-07-13 01:20:06 +03:00
|
|
|
struct preftree *tree = &preftrees->indirect_missing_keys;
|
|
|
|
struct rb_node *node;
|
2012-05-15 19:55:51 +04:00
|
|
|
|
2018-08-22 22:51:53 +03:00
|
|
|
while ((node = rb_first_cached(&tree->root))) {
|
2017-07-13 01:20:06 +03:00
|
|
|
ref = rb_entry(node, struct prelim_ref, rbnode);
|
2018-08-22 22:51:53 +03:00
|
|
|
rb_erase_cached(node, &tree->root);
|
2017-07-13 01:20:06 +03:00
|
|
|
|
|
|
|
BUG_ON(ref->parent); /* should not be a direct ref */
|
|
|
|
BUG_ON(ref->key_for_search.type);
|
2012-05-15 19:55:51 +04:00
|
|
|
BUG_ON(!ref->wanted_disk_byte);
|
2017-07-13 01:20:06 +03:00
|
|
|
|
2020-11-05 18:45:18 +03:00
|
|
|
eb = read_tree_block(fs_info, ref->wanted_disk_byte,
|
|
|
|
ref->root_id, 0, ref->level - 1, NULL);
|
2015-05-25 12:30:15 +03:00
|
|
|
if (IS_ERR(eb)) {
|
2017-07-13 01:20:06 +03:00
|
|
|
free_pref(ref);
|
2015-05-25 12:30:15 +03:00
|
|
|
return PTR_ERR(eb);
|
|
|
|
} else if (!extent_buffer_uptodate(eb)) {
|
2017-07-13 01:20:06 +03:00
|
|
|
free_pref(ref);
|
2013-04-23 22:17:42 +04:00
|
|
|
free_extent_buffer(eb);
|
|
|
|
return -EIO;
|
|
|
|
}
|
btrfs: honor path->skip_locking in backref code
Qgroups will do the old roots lookup at delayed ref time, which could be
while walking down the extent root while running a delayed ref. This
should be fine, except we specifically lock eb's in the backref walking
code irrespective of path->skip_locking, which deadlocks the system.
Fix up the backref code to honor path->skip_locking, nobody will be
modifying the commit_root when we're searching so it's completely safe
to do.
This happens since fb235dc06fac ("btrfs: qgroup: Move half of the qgroup
accounting time out of commit trans"), kernel may lockup with quota
enabled.
There is one backref trace triggered by snapshot dropping along with
write operation in the source subvolume. The example can be reliably
reproduced:
btrfs-cleaner D 0 4062 2 0x80000000
Call Trace:
schedule+0x32/0x90
btrfs_tree_read_lock+0x93/0x130 [btrfs]
find_parent_nodes+0x29b/0x1170 [btrfs]
btrfs_find_all_roots_safe+0xa8/0x120 [btrfs]
btrfs_find_all_roots+0x57/0x70 [btrfs]
btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
btrfs_qgroup_trace_leaf_items+0x10b/0x140 [btrfs]
btrfs_qgroup_trace_subtree+0xc8/0xe0 [btrfs]
do_walk_down+0x541/0x5e3 [btrfs]
walk_down_tree+0xab/0xe7 [btrfs]
btrfs_drop_snapshot+0x356/0x71a [btrfs]
btrfs_clean_one_deleted_snapshot+0xb8/0xf0 [btrfs]
cleaner_kthread+0x12b/0x160 [btrfs]
kthread+0x112/0x130
ret_from_fork+0x27/0x50
When dropping snapshots with qgroup enabled, we will trigger backref
walk.
However such backref walk at that timing is pretty dangerous, as if one
of the parent nodes get WRITE locked by other thread, we could cause a
dead lock.
For example:
FS 260 FS 261 (Dropped)
node A node B
/ \ / \
node C node D node E
/ \ / \ / \
leaf F|leaf G|leaf H|leaf I|leaf J|leaf K
The lock sequence would be:
Thread A (cleaner) | Thread B (other writer)
-----------------------------------------------------------------------
write_lock(B) |
write_lock(D) |
^^^ called by walk_down_tree() |
| write_lock(A)
| write_lock(D) << Stall
read_lock(H) << for backref walk |
read_lock(D) << lock owner is |
the same thread A |
so read lock is OK |
read_lock(A) << Stall |
So thread A hold write lock D, and needs read lock A to unlock.
While thread B holds write lock A, while needs lock D to unlock.
This will cause a deadlock.
This is not only limited to snapshot dropping case. As the backref
walk, even only happens on commit trees, is breaking the normal top-down
locking order, makes it deadlock prone.
Fixes: fb235dc06fac ("btrfs: qgroup: Move half of the qgroup accounting time out of commit trans")
CC: stable@vger.kernel.org # 4.14+
Reported-and-tested-by: David Sterba <dsterba@suse.com>
Reported-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
[ rebase to latest branch and fix lock assert bug in btrfs/007 ]
Signed-off-by: Qu Wenruo <wqu@suse.com>
[ copy logs and deadlock analysis from Qu's patch ]
Signed-off-by: David Sterba <dsterba@suse.com>
2019-01-16 19:00:57 +03:00
|
|
|
if (lock)
|
|
|
|
btrfs_tree_read_lock(eb);
|
2012-05-15 19:55:51 +04:00
|
|
|
if (btrfs_header_level(eb) == 0)
|
|
|
|
btrfs_item_key_to_cpu(eb, &ref->key_for_search, 0);
|
|
|
|
else
|
|
|
|
btrfs_node_key_to_cpu(eb, &ref->key_for_search, 0);
|
btrfs: honor path->skip_locking in backref code
Qgroups will do the old roots lookup at delayed ref time, which could be
while walking down the extent root while running a delayed ref. This
should be fine, except we specifically lock eb's in the backref walking
code irrespective of path->skip_locking, which deadlocks the system.
Fix up the backref code to honor path->skip_locking, nobody will be
modifying the commit_root when we're searching so it's completely safe
to do.
This happens since fb235dc06fac ("btrfs: qgroup: Move half of the qgroup
accounting time out of commit trans"), kernel may lockup with quota
enabled.
There is one backref trace triggered by snapshot dropping along with
write operation in the source subvolume. The example can be reliably
reproduced:
btrfs-cleaner D 0 4062 2 0x80000000
Call Trace:
schedule+0x32/0x90
btrfs_tree_read_lock+0x93/0x130 [btrfs]
find_parent_nodes+0x29b/0x1170 [btrfs]
btrfs_find_all_roots_safe+0xa8/0x120 [btrfs]
btrfs_find_all_roots+0x57/0x70 [btrfs]
btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
btrfs_qgroup_trace_leaf_items+0x10b/0x140 [btrfs]
btrfs_qgroup_trace_subtree+0xc8/0xe0 [btrfs]
do_walk_down+0x541/0x5e3 [btrfs]
walk_down_tree+0xab/0xe7 [btrfs]
btrfs_drop_snapshot+0x356/0x71a [btrfs]
btrfs_clean_one_deleted_snapshot+0xb8/0xf0 [btrfs]
cleaner_kthread+0x12b/0x160 [btrfs]
kthread+0x112/0x130
ret_from_fork+0x27/0x50
When dropping snapshots with qgroup enabled, we will trigger backref
walk.
However such backref walk at that timing is pretty dangerous, as if one
of the parent nodes get WRITE locked by other thread, we could cause a
dead lock.
For example:
FS 260 FS 261 (Dropped)
node A node B
/ \ / \
node C node D node E
/ \ / \ / \
leaf F|leaf G|leaf H|leaf I|leaf J|leaf K
The lock sequence would be:
Thread A (cleaner) | Thread B (other writer)
-----------------------------------------------------------------------
write_lock(B) |
write_lock(D) |
^^^ called by walk_down_tree() |
| write_lock(A)
| write_lock(D) << Stall
read_lock(H) << for backref walk |
read_lock(D) << lock owner is |
the same thread A |
so read lock is OK |
read_lock(A) << Stall |
So thread A hold write lock D, and needs read lock A to unlock.
While thread B holds write lock A, while needs lock D to unlock.
This will cause a deadlock.
This is not only limited to snapshot dropping case. As the backref
walk, even only happens on commit trees, is breaking the normal top-down
locking order, makes it deadlock prone.
Fixes: fb235dc06fac ("btrfs: qgroup: Move half of the qgroup accounting time out of commit trans")
CC: stable@vger.kernel.org # 4.14+
Reported-and-tested-by: David Sterba <dsterba@suse.com>
Reported-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
[ rebase to latest branch and fix lock assert bug in btrfs/007 ]
Signed-off-by: Qu Wenruo <wqu@suse.com>
[ copy logs and deadlock analysis from Qu's patch ]
Signed-off-by: David Sterba <dsterba@suse.com>
2019-01-16 19:00:57 +03:00
|
|
|
if (lock)
|
|
|
|
btrfs_tree_read_unlock(eb);
|
2012-05-15 19:55:51 +04:00
|
|
|
free_extent_buffer(eb);
|
2017-07-13 01:20:10 +03:00
|
|
|
prelim_ref_insert(fs_info, &preftrees->indirect, ref, NULL);
|
2017-07-13 01:20:09 +03:00
|
|
|
cond_resched();
|
2012-05-15 19:55:51 +04:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
/*
|
|
|
|
* add all currently queued delayed refs from this head whose seq nr is
|
|
|
|
* smaller or equal that seq to the list
|
|
|
|
*/
|
2017-07-13 01:20:08 +03:00
|
|
|
static int add_delayed_refs(const struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_delayed_ref_head *head, u64 seq,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
struct preftrees *preftrees, struct share_check *sc)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
2015-03-30 12:03:00 +03:00
|
|
|
struct btrfs_delayed_ref_node *node;
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_delayed_extent_op *extent_op = head->extent_op;
|
2012-05-15 19:55:51 +04:00
|
|
|
struct btrfs_key key;
|
2017-07-13 01:20:06 +03:00
|
|
|
struct btrfs_key tmp_op_key;
|
2017-10-19 21:16:00 +03:00
|
|
|
struct rb_node *n;
|
2017-07-13 01:20:11 +03:00
|
|
|
int count;
|
2012-01-27 00:01:11 +04:00
|
|
|
int ret = 0;
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2018-03-15 15:36:22 +03:00
|
|
|
if (extent_op && extent_op->update_key)
|
2017-07-13 01:20:06 +03:00
|
|
|
btrfs_disk_key_to_cpu(&tmp_op_key, &extent_op->key);
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2014-01-23 18:21:38 +04:00
|
|
|
spin_lock(&head->lock);
|
2018-08-22 22:51:50 +03:00
|
|
|
for (n = rb_first_cached(&head->ref_tree); n; n = rb_next(n)) {
|
2017-10-19 21:16:00 +03:00
|
|
|
node = rb_entry(n, struct btrfs_delayed_ref_node,
|
|
|
|
ref_node);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (node->seq > seq)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (node->action) {
|
|
|
|
case BTRFS_ADD_DELAYED_EXTENT:
|
|
|
|
case BTRFS_UPDATE_DELAYED_HEAD:
|
|
|
|
WARN_ON(1);
|
|
|
|
continue;
|
|
|
|
case BTRFS_ADD_DELAYED_REF:
|
2017-07-13 01:20:11 +03:00
|
|
|
count = node->ref_mod;
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
case BTRFS_DROP_DELAYED_REF:
|
2017-07-13 01:20:11 +03:00
|
|
|
count = node->ref_mod * -1;
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
default:
|
btrfs: use BUG() instead of BUG_ON(1)
BUG_ON(1) leads to bogus warnings from clang when
CONFIG_PROFILE_ANNOTATED_BRANCHES is set:
fs/btrfs/volumes.c:5041:3: error: variable 'max_chunk_size' is used uninitialized whenever 'if' condition is false
[-Werror,-Wsometimes-uninitialized]
BUG_ON(1);
^~~~~~~~~
include/asm-generic/bug.h:61:36: note: expanded from macro 'BUG_ON'
#define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while (0)
^~~~~~~~~~~~~~~~~~~
include/linux/compiler.h:48:23: note: expanded from macro 'unlikely'
# define unlikely(x) (__branch_check__(x, 0, __builtin_constant_p(x)))
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/btrfs/volumes.c:5046:9: note: uninitialized use occurs here
max_chunk_size);
^~~~~~~~~~~~~~
include/linux/kernel.h:860:36: note: expanded from macro 'min'
#define min(x, y) __careful_cmp(x, y, <)
^
include/linux/kernel.h:853:17: note: expanded from macro '__careful_cmp'
__cmp_once(x, y, __UNIQUE_ID(__x), __UNIQUE_ID(__y), op))
^
include/linux/kernel.h:847:25: note: expanded from macro '__cmp_once'
typeof(y) unique_y = (y); \
^
fs/btrfs/volumes.c:5041:3: note: remove the 'if' if its condition is always true
BUG_ON(1);
^
include/asm-generic/bug.h:61:32: note: expanded from macro 'BUG_ON'
#define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while (0)
^
fs/btrfs/volumes.c:4993:20: note: initialize the variable 'max_chunk_size' to silence this warning
u64 max_chunk_size;
^
= 0
Change it to BUG() so clang can see that this code path can never
continue.
Reviewed-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-03-25 16:02:25 +03:00
|
|
|
BUG();
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
switch (node->type) {
|
|
|
|
case BTRFS_TREE_BLOCK_REF_KEY: {
|
2017-07-13 01:20:06 +03:00
|
|
|
/* NORMAL INDIRECT METADATA backref */
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_delayed_tree_ref *ref;
|
|
|
|
|
|
|
|
ref = btrfs_delayed_node_to_tree_ref(node);
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_indirect_ref(fs_info, preftrees, ref->root,
|
|
|
|
&tmp_op_key, ref->level + 1,
|
2017-07-13 01:20:11 +03:00
|
|
|
node->bytenr, count, sc,
|
|
|
|
GFP_ATOMIC);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_SHARED_BLOCK_REF_KEY: {
|
2017-07-13 01:20:06 +03:00
|
|
|
/* SHARED DIRECT METADATA backref */
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_delayed_tree_ref *ref;
|
|
|
|
|
|
|
|
ref = btrfs_delayed_node_to_tree_ref(node);
|
2017-07-13 01:20:06 +03:00
|
|
|
|
2017-07-13 01:20:11 +03:00
|
|
|
ret = add_direct_ref(fs_info, preftrees, ref->level + 1,
|
|
|
|
ref->parent, node->bytenr, count,
|
2017-07-13 01:20:10 +03:00
|
|
|
sc, GFP_ATOMIC);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_EXTENT_DATA_REF_KEY: {
|
2017-07-13 01:20:06 +03:00
|
|
|
/* NORMAL INDIRECT DATA backref */
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_delayed_data_ref *ref;
|
|
|
|
ref = btrfs_delayed_node_to_data_ref(node);
|
|
|
|
|
|
|
|
key.objectid = ref->objectid;
|
|
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
|
|
|
key.offset = ref->offset;
|
2014-09-11 00:20:45 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Found a inum that doesn't match our known inum, we
|
|
|
|
* know it's shared.
|
|
|
|
*/
|
2017-07-13 01:20:10 +03:00
|
|
|
if (sc && sc->inum && ref->objectid != sc->inum) {
|
2014-09-11 00:20:45 +04:00
|
|
|
ret = BACKREF_FOUND_SHARED;
|
2017-07-13 01:20:10 +03:00
|
|
|
goto out;
|
2014-09-11 00:20:45 +04:00
|
|
|
}
|
|
|
|
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_indirect_ref(fs_info, preftrees, ref->root,
|
2017-07-13 01:20:11 +03:00
|
|
|
&key, 0, node->bytenr, count, sc,
|
|
|
|
GFP_ATOMIC);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_SHARED_DATA_REF_KEY: {
|
2017-07-13 01:20:06 +03:00
|
|
|
/* SHARED DIRECT FULL backref */
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_delayed_data_ref *ref;
|
|
|
|
|
|
|
|
ref = btrfs_delayed_node_to_data_ref(node);
|
2017-07-13 01:20:06 +03:00
|
|
|
|
2017-07-13 01:20:11 +03:00
|
|
|
ret = add_direct_ref(fs_info, preftrees, 0, ref->parent,
|
|
|
|
node->bytenr, count, sc,
|
|
|
|
GFP_ATOMIC);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
2017-07-13 01:20:10 +03:00
|
|
|
/*
|
|
|
|
* We must ignore BACKREF_FOUND_SHARED until all delayed
|
|
|
|
* refs have been checked.
|
|
|
|
*/
|
|
|
|
if (ret && (ret != BACKREF_FOUND_SHARED))
|
2014-01-23 18:21:38 +04:00
|
|
|
break;
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
2017-07-13 01:20:10 +03:00
|
|
|
if (!ret)
|
|
|
|
ret = extent_is_shared(sc);
|
|
|
|
out:
|
2014-01-23 18:21:38 +04:00
|
|
|
spin_unlock(&head->lock);
|
|
|
|
return ret;
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* add all inline backrefs for bytenr to the list
|
2017-07-13 01:20:10 +03:00
|
|
|
*
|
|
|
|
* Returns 0 on success, <0 on error, or BACKREF_FOUND_SHARED.
|
2011-11-23 21:55:04 +04:00
|
|
|
*/
|
2017-07-13 01:20:08 +03:00
|
|
|
static int add_inline_refs(const struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_path *path, u64 bytenr,
|
2017-07-13 01:20:06 +03:00
|
|
|
int *info_level, struct preftrees *preftrees,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
struct share_check *sc)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
2012-01-27 00:01:11 +04:00
|
|
|
int ret = 0;
|
2011-11-23 21:55:04 +04:00
|
|
|
int slot;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key key;
|
2013-06-28 21:11:22 +04:00
|
|
|
struct btrfs_key found_key;
|
2011-11-23 21:55:04 +04:00
|
|
|
unsigned long ptr;
|
|
|
|
unsigned long end;
|
|
|
|
struct btrfs_extent_item *ei;
|
|
|
|
u64 flags;
|
|
|
|
u64 item_size;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* enumerate all inline refs
|
|
|
|
*/
|
|
|
|
leaf = path->nodes[0];
|
2012-05-22 15:43:25 +04:00
|
|
|
slot = path->slots[0];
|
2011-11-23 21:55:04 +04:00
|
|
|
|
|
|
|
item_size = btrfs_item_size_nr(leaf, slot);
|
|
|
|
BUG_ON(item_size < sizeof(*ei));
|
|
|
|
|
|
|
|
ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
|
|
|
|
flags = btrfs_extent_flags(leaf, ei);
|
2013-06-28 21:11:22 +04:00
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, slot);
|
2011-11-23 21:55:04 +04:00
|
|
|
|
|
|
|
ptr = (unsigned long)(ei + 1);
|
|
|
|
end = (unsigned long)ei + item_size;
|
|
|
|
|
2013-06-28 21:11:22 +04:00
|
|
|
if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
|
|
|
|
flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_tree_block_info *info;
|
|
|
|
|
|
|
|
info = (struct btrfs_tree_block_info *)ptr;
|
|
|
|
*info_level = btrfs_tree_block_level(leaf, info);
|
|
|
|
ptr += sizeof(struct btrfs_tree_block_info);
|
|
|
|
BUG_ON(ptr > end);
|
2013-06-28 21:11:22 +04:00
|
|
|
} else if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
|
|
|
|
*info_level = found_key.offset;
|
2011-11-23 21:55:04 +04:00
|
|
|
} else {
|
|
|
|
BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
|
|
|
|
}
|
|
|
|
|
|
|
|
while (ptr < end) {
|
|
|
|
struct btrfs_extent_inline_ref *iref;
|
|
|
|
u64 offset;
|
|
|
|
int type;
|
|
|
|
|
|
|
|
iref = (struct btrfs_extent_inline_ref *)ptr;
|
2017-08-19 00:15:19 +03:00
|
|
|
type = btrfs_get_extent_inline_ref_type(leaf, iref,
|
|
|
|
BTRFS_REF_TYPE_ANY);
|
|
|
|
if (type == BTRFS_REF_TYPE_INVALID)
|
2018-06-22 11:18:01 +03:00
|
|
|
return -EUCLEAN;
|
2017-08-19 00:15:19 +03:00
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
offset = btrfs_extent_inline_ref_offset(leaf, iref);
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case BTRFS_SHARED_BLOCK_REF_KEY:
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_direct_ref(fs_info, preftrees,
|
|
|
|
*info_level + 1, offset,
|
2017-07-13 01:20:10 +03:00
|
|
|
bytenr, 1, NULL, GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
case BTRFS_SHARED_DATA_REF_KEY: {
|
|
|
|
struct btrfs_shared_data_ref *sdref;
|
|
|
|
int count;
|
|
|
|
|
|
|
|
sdref = (struct btrfs_shared_data_ref *)(iref + 1);
|
|
|
|
count = btrfs_shared_data_ref_count(leaf, sdref);
|
2017-07-13 01:20:06 +03:00
|
|
|
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_direct_ref(fs_info, preftrees, 0, offset,
|
2017-07-13 01:20:10 +03:00
|
|
|
bytenr, count, sc, GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_TREE_BLOCK_REF_KEY:
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_indirect_ref(fs_info, preftrees, offset,
|
|
|
|
NULL, *info_level + 1,
|
2017-07-13 01:20:10 +03:00
|
|
|
bytenr, 1, NULL, GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
case BTRFS_EXTENT_DATA_REF_KEY: {
|
|
|
|
struct btrfs_extent_data_ref *dref;
|
|
|
|
int count;
|
|
|
|
u64 root;
|
|
|
|
|
|
|
|
dref = (struct btrfs_extent_data_ref *)(&iref->offset);
|
|
|
|
count = btrfs_extent_data_ref_count(leaf, dref);
|
|
|
|
key.objectid = btrfs_extent_data_ref_objectid(leaf,
|
|
|
|
dref);
|
|
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
|
|
|
key.offset = btrfs_extent_data_ref_offset(leaf, dref);
|
2014-09-11 00:20:45 +04:00
|
|
|
|
2017-07-13 01:20:10 +03:00
|
|
|
if (sc && sc->inum && key.objectid != sc->inum) {
|
2014-09-11 00:20:45 +04:00
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
root = btrfs_extent_data_ref_root(leaf, dref);
|
2017-07-13 01:20:06 +03:00
|
|
|
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_indirect_ref(fs_info, preftrees, root,
|
|
|
|
&key, 0, bytenr, count,
|
2017-07-13 01:20:10 +03:00
|
|
|
sc, GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
2013-04-10 15:22:50 +04:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-11-23 21:55:04 +04:00
|
|
|
ptr += btrfs_extent_inline_ref_size(type);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* add all non-inline backrefs for bytenr to the list
|
2017-07-13 01:20:10 +03:00
|
|
|
*
|
|
|
|
* Returns 0 on success, <0 on error, or BACKREF_FOUND_SHARED.
|
2011-11-23 21:55:04 +04:00
|
|
|
*/
|
2017-06-29 06:56:57 +03:00
|
|
|
static int add_keyed_refs(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_path *path, u64 bytenr,
|
2017-07-13 01:20:06 +03:00
|
|
|
int info_level, struct preftrees *preftrees,
|
2017-07-13 01:20:10 +03:00
|
|
|
struct share_check *sc)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
|
|
|
struct btrfs_root *extent_root = fs_info->extent_root;
|
|
|
|
int ret;
|
|
|
|
int slot;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
ret = btrfs_next_item(extent_root, path);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
if (ret) {
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
btrfs_item_key_to_cpu(leaf, &key, slot);
|
|
|
|
|
|
|
|
if (key.objectid != bytenr)
|
|
|
|
break;
|
|
|
|
if (key.type < BTRFS_TREE_BLOCK_REF_KEY)
|
|
|
|
continue;
|
|
|
|
if (key.type > BTRFS_SHARED_DATA_REF_KEY)
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch (key.type) {
|
|
|
|
case BTRFS_SHARED_BLOCK_REF_KEY:
|
2017-07-13 01:20:06 +03:00
|
|
|
/* SHARED DIRECT METADATA backref */
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_direct_ref(fs_info, preftrees,
|
|
|
|
info_level + 1, key.offset,
|
2017-07-13 01:20:10 +03:00
|
|
|
bytenr, 1, NULL, GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
case BTRFS_SHARED_DATA_REF_KEY: {
|
2017-07-13 01:20:06 +03:00
|
|
|
/* SHARED DIRECT FULL backref */
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_shared_data_ref *sdref;
|
|
|
|
int count;
|
|
|
|
|
|
|
|
sdref = btrfs_item_ptr(leaf, slot,
|
|
|
|
struct btrfs_shared_data_ref);
|
|
|
|
count = btrfs_shared_data_ref_count(leaf, sdref);
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_direct_ref(fs_info, preftrees, 0,
|
|
|
|
key.offset, bytenr, count,
|
2017-07-13 01:20:10 +03:00
|
|
|
sc, GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_TREE_BLOCK_REF_KEY:
|
2017-07-13 01:20:06 +03:00
|
|
|
/* NORMAL INDIRECT METADATA backref */
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_indirect_ref(fs_info, preftrees, key.offset,
|
|
|
|
NULL, info_level + 1, bytenr,
|
2017-07-13 01:20:10 +03:00
|
|
|
1, NULL, GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
case BTRFS_EXTENT_DATA_REF_KEY: {
|
2017-07-13 01:20:06 +03:00
|
|
|
/* NORMAL INDIRECT DATA backref */
|
2011-11-23 21:55:04 +04:00
|
|
|
struct btrfs_extent_data_ref *dref;
|
|
|
|
int count;
|
|
|
|
u64 root;
|
|
|
|
|
|
|
|
dref = btrfs_item_ptr(leaf, slot,
|
|
|
|
struct btrfs_extent_data_ref);
|
|
|
|
count = btrfs_extent_data_ref_count(leaf, dref);
|
|
|
|
key.objectid = btrfs_extent_data_ref_objectid(leaf,
|
|
|
|
dref);
|
|
|
|
key.type = BTRFS_EXTENT_DATA_KEY;
|
|
|
|
key.offset = btrfs_extent_data_ref_offset(leaf, dref);
|
2014-09-11 00:20:45 +04:00
|
|
|
|
2017-07-13 01:20:10 +03:00
|
|
|
if (sc && sc->inum && key.objectid != sc->inum) {
|
2014-09-11 00:20:45 +04:00
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
root = btrfs_extent_data_ref_root(leaf, dref);
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_indirect_ref(fs_info, preftrees, root,
|
|
|
|
&key, 0, bytenr, count,
|
2017-07-13 01:20:10 +03:00
|
|
|
sc, GFP_NOFS);
|
2011-11-23 21:55:04 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
2013-04-10 15:22:50 +04:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this adds all existing backrefs (inline backrefs, backrefs and delayed
|
|
|
|
* refs) for the given bytenr to the refs list, merges duplicates and resolves
|
|
|
|
* indirect refs to their parent bytenr.
|
|
|
|
* When roots are found, they're added to the roots list
|
|
|
|
*
|
2021-03-11 17:31:07 +03:00
|
|
|
* If time_seq is set to BTRFS_SEQ_LAST, it will not search delayed_refs, and
|
|
|
|
* behave much like trans == NULL case, the difference only lies in it will not
|
2015-04-16 09:54:50 +03:00
|
|
|
* commit root.
|
|
|
|
* The special case is for qgroup to search roots in commit_transaction().
|
|
|
|
*
|
2017-07-13 01:20:10 +03:00
|
|
|
* @sc - if !NULL, then immediately return BACKREF_FOUND_SHARED when a
|
|
|
|
* shared extent is detected.
|
|
|
|
*
|
|
|
|
* Otherwise this returns 0 for success and <0 for an error.
|
|
|
|
*
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
* If ignore_offset is set to false, only extent refs whose offsets match
|
|
|
|
* extent_item_pos are returned. If true, every extent ref is returned
|
|
|
|
* and extent_item_pos is ignored.
|
|
|
|
*
|
2011-11-23 21:55:04 +04:00
|
|
|
* FIXME some caching might speed things up
|
|
|
|
*/
|
|
|
|
static int find_parent_nodes(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 bytenr,
|
2012-06-21 13:08:04 +04:00
|
|
|
u64 time_seq, struct ulist *refs,
|
2014-09-11 00:20:45 +04:00
|
|
|
struct ulist *roots, const u64 *extent_item_pos,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
struct share_check *sc, bool ignore_offset)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_delayed_ref_root *delayed_refs = NULL;
|
2012-03-03 16:41:15 +04:00
|
|
|
struct btrfs_delayed_ref_head *head;
|
2011-11-23 21:55:04 +04:00
|
|
|
int info_level = 0;
|
|
|
|
int ret;
|
2017-06-29 06:56:57 +03:00
|
|
|
struct prelim_ref *ref;
|
2017-07-13 01:20:06 +03:00
|
|
|
struct rb_node *node;
|
2014-01-28 15:13:38 +04:00
|
|
|
struct extent_inode_elem *eie = NULL;
|
2017-07-13 01:20:06 +03:00
|
|
|
struct preftrees preftrees = {
|
|
|
|
.direct = PREFTREE_INIT,
|
|
|
|
.indirect = PREFTREE_INIT,
|
|
|
|
.indirect_missing_keys = PREFTREE_INIT
|
|
|
|
};
|
2011-11-23 21:55:04 +04:00
|
|
|
|
|
|
|
key.objectid = bytenr;
|
|
|
|
key.offset = (u64)-1;
|
2013-06-28 21:11:22 +04:00
|
|
|
if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))
|
|
|
|
key.type = BTRFS_METADATA_ITEM_KEY;
|
|
|
|
else
|
|
|
|
key.type = BTRFS_EXTENT_ITEM_KEY;
|
2011-11-23 21:55:04 +04:00
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2014-02-13 07:19:47 +04:00
|
|
|
if (!trans) {
|
2013-06-13 00:20:08 +04:00
|
|
|
path->search_commit_root = 1;
|
2014-02-13 07:19:47 +04:00
|
|
|
path->skip_locking = 1;
|
|
|
|
}
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2021-03-11 17:31:07 +03:00
|
|
|
if (time_seq == BTRFS_SEQ_LAST)
|
2015-04-16 09:54:50 +03:00
|
|
|
path->skip_locking = 1;
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
/*
|
|
|
|
* grab both a lock on the path and a lock on the delayed ref head.
|
|
|
|
* We need both to get a consistent picture of how the refs look
|
|
|
|
* at a specified point in time
|
|
|
|
*/
|
|
|
|
again:
|
2012-03-03 16:41:15 +04:00
|
|
|
head = NULL;
|
|
|
|
|
2021-07-20 21:02:47 +03:00
|
|
|
ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, path, 0, 0);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
BUG_ON(ret == 0);
|
|
|
|
|
2014-05-08 01:06:09 +04:00
|
|
|
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
|
2015-04-16 09:54:50 +03:00
|
|
|
if (trans && likely(trans->type != __TRANS_DUMMY) &&
|
2021-03-11 17:31:07 +03:00
|
|
|
time_seq != BTRFS_SEQ_LAST) {
|
2014-05-08 01:06:09 +04:00
|
|
|
#else
|
2021-03-11 17:31:07 +03:00
|
|
|
if (trans && time_seq != BTRFS_SEQ_LAST) {
|
2014-05-08 01:06:09 +04:00
|
|
|
#endif
|
2012-03-23 20:32:28 +04:00
|
|
|
/*
|
|
|
|
* look if there are updates for this ref queued and lock the
|
|
|
|
* head
|
|
|
|
*/
|
|
|
|
delayed_refs = &trans->transaction->delayed_refs;
|
|
|
|
spin_lock(&delayed_refs->lock);
|
2017-01-30 23:24:37 +03:00
|
|
|
head = btrfs_find_delayed_ref_head(delayed_refs, bytenr);
|
2012-03-23 20:32:28 +04:00
|
|
|
if (head) {
|
|
|
|
if (!mutex_trylock(&head->mutex)) {
|
2017-09-29 22:43:57 +03:00
|
|
|
refcount_inc(&head->refs);
|
2012-03-23 20:32:28 +04:00
|
|
|
spin_unlock(&delayed_refs->lock);
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mutex was contended, block until it's
|
|
|
|
* released and try again
|
|
|
|
*/
|
|
|
|
mutex_lock(&head->mutex);
|
|
|
|
mutex_unlock(&head->mutex);
|
2017-09-29 22:43:57 +03:00
|
|
|
btrfs_put_delayed_ref_head(head);
|
2012-03-23 20:32:28 +04:00
|
|
|
goto again;
|
|
|
|
}
|
2014-01-23 18:21:38 +04:00
|
|
|
spin_unlock(&delayed_refs->lock);
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_delayed_refs(fs_info, head, time_seq,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
&preftrees, sc);
|
2012-06-22 16:01:00 +04:00
|
|
|
mutex_unlock(&head->mutex);
|
2014-01-23 18:21:38 +04:00
|
|
|
if (ret)
|
2012-03-23 20:32:28 +04:00
|
|
|
goto out;
|
2014-01-23 18:21:38 +04:00
|
|
|
} else {
|
|
|
|
spin_unlock(&delayed_refs->lock);
|
2012-03-03 16:41:15 +04:00
|
|
|
}
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (path->slots[0]) {
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
int slot;
|
|
|
|
|
2012-05-22 15:43:25 +04:00
|
|
|
path->slots[0]--;
|
2011-11-23 21:55:04 +04:00
|
|
|
leaf = path->nodes[0];
|
2012-05-22 15:43:25 +04:00
|
|
|
slot = path->slots[0];
|
2011-11-23 21:55:04 +04:00
|
|
|
btrfs_item_key_to_cpu(leaf, &key, slot);
|
|
|
|
if (key.objectid == bytenr &&
|
2013-06-28 21:11:22 +04:00
|
|
|
(key.type == BTRFS_EXTENT_ITEM_KEY ||
|
|
|
|
key.type == BTRFS_METADATA_ITEM_KEY)) {
|
2017-07-13 01:20:08 +03:00
|
|
|
ret = add_inline_refs(fs_info, path, bytenr,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
&info_level, &preftrees, sc);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2017-06-29 06:56:57 +03:00
|
|
|
ret = add_keyed_refs(fs_info, path, bytenr, info_level,
|
2017-07-13 01:20:10 +03:00
|
|
|
&preftrees, sc);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-13 01:20:06 +03:00
|
|
|
btrfs_release_path(path);
|
2011-11-23 21:55:04 +04:00
|
|
|
|
btrfs: honor path->skip_locking in backref code
Qgroups will do the old roots lookup at delayed ref time, which could be
while walking down the extent root while running a delayed ref. This
should be fine, except we specifically lock eb's in the backref walking
code irrespective of path->skip_locking, which deadlocks the system.
Fix up the backref code to honor path->skip_locking, nobody will be
modifying the commit_root when we're searching so it's completely safe
to do.
This happens since fb235dc06fac ("btrfs: qgroup: Move half of the qgroup
accounting time out of commit trans"), kernel may lockup with quota
enabled.
There is one backref trace triggered by snapshot dropping along with
write operation in the source subvolume. The example can be reliably
reproduced:
btrfs-cleaner D 0 4062 2 0x80000000
Call Trace:
schedule+0x32/0x90
btrfs_tree_read_lock+0x93/0x130 [btrfs]
find_parent_nodes+0x29b/0x1170 [btrfs]
btrfs_find_all_roots_safe+0xa8/0x120 [btrfs]
btrfs_find_all_roots+0x57/0x70 [btrfs]
btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
btrfs_qgroup_trace_leaf_items+0x10b/0x140 [btrfs]
btrfs_qgroup_trace_subtree+0xc8/0xe0 [btrfs]
do_walk_down+0x541/0x5e3 [btrfs]
walk_down_tree+0xab/0xe7 [btrfs]
btrfs_drop_snapshot+0x356/0x71a [btrfs]
btrfs_clean_one_deleted_snapshot+0xb8/0xf0 [btrfs]
cleaner_kthread+0x12b/0x160 [btrfs]
kthread+0x112/0x130
ret_from_fork+0x27/0x50
When dropping snapshots with qgroup enabled, we will trigger backref
walk.
However such backref walk at that timing is pretty dangerous, as if one
of the parent nodes get WRITE locked by other thread, we could cause a
dead lock.
For example:
FS 260 FS 261 (Dropped)
node A node B
/ \ / \
node C node D node E
/ \ / \ / \
leaf F|leaf G|leaf H|leaf I|leaf J|leaf K
The lock sequence would be:
Thread A (cleaner) | Thread B (other writer)
-----------------------------------------------------------------------
write_lock(B) |
write_lock(D) |
^^^ called by walk_down_tree() |
| write_lock(A)
| write_lock(D) << Stall
read_lock(H) << for backref walk |
read_lock(D) << lock owner is |
the same thread A |
so read lock is OK |
read_lock(A) << Stall |
So thread A hold write lock D, and needs read lock A to unlock.
While thread B holds write lock A, while needs lock D to unlock.
This will cause a deadlock.
This is not only limited to snapshot dropping case. As the backref
walk, even only happens on commit trees, is breaking the normal top-down
locking order, makes it deadlock prone.
Fixes: fb235dc06fac ("btrfs: qgroup: Move half of the qgroup accounting time out of commit trans")
CC: stable@vger.kernel.org # 4.14+
Reported-and-tested-by: David Sterba <dsterba@suse.com>
Reported-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
[ rebase to latest branch and fix lock assert bug in btrfs/007 ]
Signed-off-by: Qu Wenruo <wqu@suse.com>
[ copy logs and deadlock analysis from Qu's patch ]
Signed-off-by: David Sterba <dsterba@suse.com>
2019-01-16 19:00:57 +03:00
|
|
|
ret = add_missing_keys(fs_info, &preftrees, path->skip_locking == 0);
|
2012-05-15 19:55:51 +04:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2018-08-22 22:51:53 +03:00
|
|
|
WARN_ON(!RB_EMPTY_ROOT(&preftrees.indirect_missing_keys.root.rb_root));
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2017-07-13 01:20:06 +03:00
|
|
|
ret = resolve_indirect_refs(fs_info, path, time_seq, &preftrees,
|
btrfs: backref, use correct count to resolve normal data refs
With the following patches:
- btrfs: backref, only collect file extent items matching backref offset
- btrfs: backref, not adding refs from shared block when resolving normal backref
- btrfs: backref, only search backref entries from leaves of the same root
we only collect the normal data refs we want, so the imprecise upper
bound total_refs of that EXTENT_ITEM could now be changed to the count
of the normal backref entry we want to search.
Background and how the patches fit together:
Btrfs has two types of data backref.
For BTRFS_EXTENT_DATA_REF_KEY type of backref, we don't have the
exact block number. Therefore, we need to call resolve_indirect_refs.
It uses btrfs_search_slot to locate the leaf block. Then
we need to walk through the leaves to search for the EXTENT_DATA items
that have disk bytenr matching the extent item (add_all_parents).
When resolving indirect refs, we could take entries that don't
belong to the backref entry we are searching for right now.
For that reason when searching backref entry, we always use total
refs of that EXTENT_ITEM rather than individual count.
For example:
item 11 key (40831553536 EXTENT_ITEM 4194304) itemoff 15460 itemsize
extent refs 24 gen 7302 flags DATA
shared data backref parent 394985472 count 10 #1
extent data backref root 257 objectid 260 offset 1048576 count 3 #2
extent data backref root 256 objectid 260 offset 65536 count 6 #3
extent data backref root 257 objectid 260 offset 65536 count 5 #4
For example, when searching backref entry #4, we'll use total_refs
24, a very loose loop ending condition, instead of total_refs = 5.
But using total_refs = 24 is not accurate. Sometimes, we'll never find
all the refs from specific root. As a result, the loop keeps on going
until we reach the end of that inode.
The first 3 patches, handle 3 different types refs we might encounter.
These refs do not belong to the normal backref we are searching, and
hence need to be skipped.
This patch changes the total_refs to correct number so that we could
end loop as soon as we find all the refs we want.
btrfs send uses backref to find possible clone sources, the following
is a simple test to compare the results with and without this patch:
$ btrfs subvolume create /sub1
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=64K count=1 seek=$((i-1)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot /sub1 /sub2
$ for i in `seq 1 163840`; do
dd if=/dev/zero of=/sub1/file bs=4K count=1 seek=$(((i-1)*16+10)) conv=notrunc oflag=direct
done
$ btrfs subvolume snapshot -r /sub1 /snap1
$ time btrfs send /snap1 | btrfs receive /volume2
Without this patch:
real 69m48.124s
user 0m50.199s
sys 70m15.600s
With this patch:
real 1m59.683s
user 0m35.421s
sys 2m42.684s
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: ethanwu <ethanwu@synology.com>
[ add patchset cover letter with background and numbers ]
Signed-off-by: David Sterba <dsterba@suse.com>
2020-02-07 12:38:18 +03:00
|
|
|
extent_item_pos, sc, ignore_offset);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2018-08-22 22:51:53 +03:00
|
|
|
WARN_ON(!RB_EMPTY_ROOT(&preftrees.indirect.root.rb_root));
|
2011-11-23 21:55:04 +04:00
|
|
|
|
2017-07-13 01:20:06 +03:00
|
|
|
/*
|
|
|
|
* This walks the tree of merged and resolved refs. Tree blocks are
|
|
|
|
* read in as needed. Unique entries are added to the ulist, and
|
|
|
|
* the list of found roots is updated.
|
|
|
|
*
|
|
|
|
* We release the entire tree in one go before returning.
|
|
|
|
*/
|
2018-08-22 22:51:53 +03:00
|
|
|
node = rb_first_cached(&preftrees.direct.root);
|
2017-07-13 01:20:06 +03:00
|
|
|
while (node) {
|
|
|
|
ref = rb_entry(node, struct prelim_ref, rbnode);
|
|
|
|
node = rb_next(&ref->rbnode);
|
2018-01-24 06:22:09 +03:00
|
|
|
/*
|
|
|
|
* ref->count < 0 can happen here if there are delayed
|
|
|
|
* refs with a node->action of BTRFS_DROP_DELAYED_REF.
|
|
|
|
* prelim_ref_insert() relies on this when merging
|
|
|
|
* identical refs to keep the overall count correct.
|
|
|
|
* prelim_ref_insert() will merge only those refs
|
|
|
|
* which compare identically. Any refs having
|
|
|
|
* e.g. different offsets would not be merged,
|
|
|
|
* and would retain their original ref->count < 0.
|
|
|
|
*/
|
2014-01-31 20:42:05 +04:00
|
|
|
if (roots && ref->count && ref->root_id && ref->parent == 0) {
|
2017-07-13 01:20:10 +03:00
|
|
|
if (sc && sc->root_objectid &&
|
|
|
|
ref->root_id != sc->root_objectid) {
|
2014-09-11 00:20:45 +04:00
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
/* no parent == root of tree */
|
|
|
|
ret = ulist_add(roots, ref->root_id, 0, GFP_NOFS);
|
2013-03-30 03:03:21 +04:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
if (ref->count && ref->parent) {
|
2014-06-06 00:08:45 +04:00
|
|
|
if (extent_item_pos && !ref->inode_list &&
|
|
|
|
ref->level == 0) {
|
2012-05-17 18:43:03 +04:00
|
|
|
struct extent_buffer *eb;
|
2014-06-04 21:22:26 +04:00
|
|
|
|
2018-03-29 04:08:11 +03:00
|
|
|
eb = read_tree_block(fs_info, ref->parent, 0,
|
2020-11-05 18:45:18 +03:00
|
|
|
0, ref->level, NULL);
|
2015-05-25 12:30:15 +03:00
|
|
|
if (IS_ERR(eb)) {
|
|
|
|
ret = PTR_ERR(eb);
|
|
|
|
goto out;
|
|
|
|
} else if (!extent_buffer_uptodate(eb)) {
|
2013-04-23 22:17:42 +04:00
|
|
|
free_extent_buffer(eb);
|
2013-05-08 12:10:25 +04:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2013-04-23 22:17:42 +04:00
|
|
|
}
|
btrfs: honor path->skip_locking in backref code
Qgroups will do the old roots lookup at delayed ref time, which could be
while walking down the extent root while running a delayed ref. This
should be fine, except we specifically lock eb's in the backref walking
code irrespective of path->skip_locking, which deadlocks the system.
Fix up the backref code to honor path->skip_locking, nobody will be
modifying the commit_root when we're searching so it's completely safe
to do.
This happens since fb235dc06fac ("btrfs: qgroup: Move half of the qgroup
accounting time out of commit trans"), kernel may lockup with quota
enabled.
There is one backref trace triggered by snapshot dropping along with
write operation in the source subvolume. The example can be reliably
reproduced:
btrfs-cleaner D 0 4062 2 0x80000000
Call Trace:
schedule+0x32/0x90
btrfs_tree_read_lock+0x93/0x130 [btrfs]
find_parent_nodes+0x29b/0x1170 [btrfs]
btrfs_find_all_roots_safe+0xa8/0x120 [btrfs]
btrfs_find_all_roots+0x57/0x70 [btrfs]
btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
btrfs_qgroup_trace_leaf_items+0x10b/0x140 [btrfs]
btrfs_qgroup_trace_subtree+0xc8/0xe0 [btrfs]
do_walk_down+0x541/0x5e3 [btrfs]
walk_down_tree+0xab/0xe7 [btrfs]
btrfs_drop_snapshot+0x356/0x71a [btrfs]
btrfs_clean_one_deleted_snapshot+0xb8/0xf0 [btrfs]
cleaner_kthread+0x12b/0x160 [btrfs]
kthread+0x112/0x130
ret_from_fork+0x27/0x50
When dropping snapshots with qgroup enabled, we will trigger backref
walk.
However such backref walk at that timing is pretty dangerous, as if one
of the parent nodes get WRITE locked by other thread, we could cause a
dead lock.
For example:
FS 260 FS 261 (Dropped)
node A node B
/ \ / \
node C node D node E
/ \ / \ / \
leaf F|leaf G|leaf H|leaf I|leaf J|leaf K
The lock sequence would be:
Thread A (cleaner) | Thread B (other writer)
-----------------------------------------------------------------------
write_lock(B) |
write_lock(D) |
^^^ called by walk_down_tree() |
| write_lock(A)
| write_lock(D) << Stall
read_lock(H) << for backref walk |
read_lock(D) << lock owner is |
the same thread A |
so read lock is OK |
read_lock(A) << Stall |
So thread A hold write lock D, and needs read lock A to unlock.
While thread B holds write lock A, while needs lock D to unlock.
This will cause a deadlock.
This is not only limited to snapshot dropping case. As the backref
walk, even only happens on commit trees, is breaking the normal top-down
locking order, makes it deadlock prone.
Fixes: fb235dc06fac ("btrfs: qgroup: Move half of the qgroup accounting time out of commit trans")
CC: stable@vger.kernel.org # 4.14+
Reported-and-tested-by: David Sterba <dsterba@suse.com>
Reported-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
[ rebase to latest branch and fix lock assert bug in btrfs/007 ]
Signed-off-by: Qu Wenruo <wqu@suse.com>
[ copy logs and deadlock analysis from Qu's patch ]
Signed-off-by: David Sterba <dsterba@suse.com>
2019-01-16 19:00:57 +03:00
|
|
|
|
2020-08-20 18:46:10 +03:00
|
|
|
if (!path->skip_locking)
|
btrfs: honor path->skip_locking in backref code
Qgroups will do the old roots lookup at delayed ref time, which could be
while walking down the extent root while running a delayed ref. This
should be fine, except we specifically lock eb's in the backref walking
code irrespective of path->skip_locking, which deadlocks the system.
Fix up the backref code to honor path->skip_locking, nobody will be
modifying the commit_root when we're searching so it's completely safe
to do.
This happens since fb235dc06fac ("btrfs: qgroup: Move half of the qgroup
accounting time out of commit trans"), kernel may lockup with quota
enabled.
There is one backref trace triggered by snapshot dropping along with
write operation in the source subvolume. The example can be reliably
reproduced:
btrfs-cleaner D 0 4062 2 0x80000000
Call Trace:
schedule+0x32/0x90
btrfs_tree_read_lock+0x93/0x130 [btrfs]
find_parent_nodes+0x29b/0x1170 [btrfs]
btrfs_find_all_roots_safe+0xa8/0x120 [btrfs]
btrfs_find_all_roots+0x57/0x70 [btrfs]
btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
btrfs_qgroup_trace_leaf_items+0x10b/0x140 [btrfs]
btrfs_qgroup_trace_subtree+0xc8/0xe0 [btrfs]
do_walk_down+0x541/0x5e3 [btrfs]
walk_down_tree+0xab/0xe7 [btrfs]
btrfs_drop_snapshot+0x356/0x71a [btrfs]
btrfs_clean_one_deleted_snapshot+0xb8/0xf0 [btrfs]
cleaner_kthread+0x12b/0x160 [btrfs]
kthread+0x112/0x130
ret_from_fork+0x27/0x50
When dropping snapshots with qgroup enabled, we will trigger backref
walk.
However such backref walk at that timing is pretty dangerous, as if one
of the parent nodes get WRITE locked by other thread, we could cause a
dead lock.
For example:
FS 260 FS 261 (Dropped)
node A node B
/ \ / \
node C node D node E
/ \ / \ / \
leaf F|leaf G|leaf H|leaf I|leaf J|leaf K
The lock sequence would be:
Thread A (cleaner) | Thread B (other writer)
-----------------------------------------------------------------------
write_lock(B) |
write_lock(D) |
^^^ called by walk_down_tree() |
| write_lock(A)
| write_lock(D) << Stall
read_lock(H) << for backref walk |
read_lock(D) << lock owner is |
the same thread A |
so read lock is OK |
read_lock(A) << Stall |
So thread A hold write lock D, and needs read lock A to unlock.
While thread B holds write lock A, while needs lock D to unlock.
This will cause a deadlock.
This is not only limited to snapshot dropping case. As the backref
walk, even only happens on commit trees, is breaking the normal top-down
locking order, makes it deadlock prone.
Fixes: fb235dc06fac ("btrfs: qgroup: Move half of the qgroup accounting time out of commit trans")
CC: stable@vger.kernel.org # 4.14+
Reported-and-tested-by: David Sterba <dsterba@suse.com>
Reported-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
[ rebase to latest branch and fix lock assert bug in btrfs/007 ]
Signed-off-by: Qu Wenruo <wqu@suse.com>
[ copy logs and deadlock analysis from Qu's patch ]
Signed-off-by: David Sterba <dsterba@suse.com>
2019-01-16 19:00:57 +03:00
|
|
|
btrfs_tree_read_lock(eb);
|
2012-05-17 18:43:03 +04:00
|
|
|
ret = find_extent_in_eb(eb, bytenr,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
*extent_item_pos, &eie, ignore_offset);
|
btrfs: honor path->skip_locking in backref code
Qgroups will do the old roots lookup at delayed ref time, which could be
while walking down the extent root while running a delayed ref. This
should be fine, except we specifically lock eb's in the backref walking
code irrespective of path->skip_locking, which deadlocks the system.
Fix up the backref code to honor path->skip_locking, nobody will be
modifying the commit_root when we're searching so it's completely safe
to do.
This happens since fb235dc06fac ("btrfs: qgroup: Move half of the qgroup
accounting time out of commit trans"), kernel may lockup with quota
enabled.
There is one backref trace triggered by snapshot dropping along with
write operation in the source subvolume. The example can be reliably
reproduced:
btrfs-cleaner D 0 4062 2 0x80000000
Call Trace:
schedule+0x32/0x90
btrfs_tree_read_lock+0x93/0x130 [btrfs]
find_parent_nodes+0x29b/0x1170 [btrfs]
btrfs_find_all_roots_safe+0xa8/0x120 [btrfs]
btrfs_find_all_roots+0x57/0x70 [btrfs]
btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
btrfs_qgroup_trace_leaf_items+0x10b/0x140 [btrfs]
btrfs_qgroup_trace_subtree+0xc8/0xe0 [btrfs]
do_walk_down+0x541/0x5e3 [btrfs]
walk_down_tree+0xab/0xe7 [btrfs]
btrfs_drop_snapshot+0x356/0x71a [btrfs]
btrfs_clean_one_deleted_snapshot+0xb8/0xf0 [btrfs]
cleaner_kthread+0x12b/0x160 [btrfs]
kthread+0x112/0x130
ret_from_fork+0x27/0x50
When dropping snapshots with qgroup enabled, we will trigger backref
walk.
However such backref walk at that timing is pretty dangerous, as if one
of the parent nodes get WRITE locked by other thread, we could cause a
dead lock.
For example:
FS 260 FS 261 (Dropped)
node A node B
/ \ / \
node C node D node E
/ \ / \ / \
leaf F|leaf G|leaf H|leaf I|leaf J|leaf K
The lock sequence would be:
Thread A (cleaner) | Thread B (other writer)
-----------------------------------------------------------------------
write_lock(B) |
write_lock(D) |
^^^ called by walk_down_tree() |
| write_lock(A)
| write_lock(D) << Stall
read_lock(H) << for backref walk |
read_lock(D) << lock owner is |
the same thread A |
so read lock is OK |
read_lock(A) << Stall |
So thread A hold write lock D, and needs read lock A to unlock.
While thread B holds write lock A, while needs lock D to unlock.
This will cause a deadlock.
This is not only limited to snapshot dropping case. As the backref
walk, even only happens on commit trees, is breaking the normal top-down
locking order, makes it deadlock prone.
Fixes: fb235dc06fac ("btrfs: qgroup: Move half of the qgroup accounting time out of commit trans")
CC: stable@vger.kernel.org # 4.14+
Reported-and-tested-by: David Sterba <dsterba@suse.com>
Reported-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
[ rebase to latest branch and fix lock assert bug in btrfs/007 ]
Signed-off-by: Qu Wenruo <wqu@suse.com>
[ copy logs and deadlock analysis from Qu's patch ]
Signed-off-by: David Sterba <dsterba@suse.com>
2019-01-16 19:00:57 +03:00
|
|
|
if (!path->skip_locking)
|
2020-08-20 18:46:10 +03:00
|
|
|
btrfs_tree_read_unlock(eb);
|
2012-05-17 18:43:03 +04:00
|
|
|
free_extent_buffer(eb);
|
2013-07-31 03:26:35 +04:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
ref->inode_list = eie;
|
2012-05-17 18:43:03 +04:00
|
|
|
}
|
2014-07-28 12:57:04 +04:00
|
|
|
ret = ulist_add_merge_ptr(refs, ref->parent,
|
|
|
|
ref->inode_list,
|
|
|
|
(void **)&eie, GFP_NOFS);
|
2013-03-30 03:03:21 +04:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2012-05-30 20:05:21 +04:00
|
|
|
if (!ret && extent_item_pos) {
|
|
|
|
/*
|
|
|
|
* we've recorded that parent, so we must extend
|
|
|
|
* its inode list here
|
|
|
|
*/
|
|
|
|
BUG_ON(!eie);
|
|
|
|
while (eie->next)
|
|
|
|
eie = eie->next;
|
|
|
|
eie->next = ref->inode_list;
|
|
|
|
}
|
2014-01-28 15:13:38 +04:00
|
|
|
eie = NULL;
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
2017-07-13 01:20:09 +03:00
|
|
|
cond_resched();
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
2017-07-13 01:20:06 +03:00
|
|
|
|
|
|
|
prelim_release(&preftrees.direct);
|
|
|
|
prelim_release(&preftrees.indirect);
|
|
|
|
prelim_release(&preftrees.indirect_missing_keys);
|
|
|
|
|
2014-01-28 15:13:38 +04:00
|
|
|
if (ret < 0)
|
|
|
|
free_inode_elem_list(eie);
|
2011-11-23 21:55:04 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-17 18:43:03 +04:00
|
|
|
static void free_leaf_list(struct ulist *blocks)
|
|
|
|
{
|
|
|
|
struct ulist_node *node = NULL;
|
|
|
|
struct extent_inode_elem *eie;
|
|
|
|
struct ulist_iterator uiter;
|
|
|
|
|
|
|
|
ULIST_ITER_INIT(&uiter);
|
|
|
|
while ((node = ulist_next(blocks, &uiter))) {
|
|
|
|
if (!node->aux)
|
|
|
|
continue;
|
2017-06-29 06:56:56 +03:00
|
|
|
eie = unode_aux_to_inode_list(node);
|
2014-01-28 15:13:38 +04:00
|
|
|
free_inode_elem_list(eie);
|
2012-05-17 18:43:03 +04:00
|
|
|
node->aux = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ulist_free(blocks);
|
|
|
|
}
|
|
|
|
|
2011-11-23 21:55:04 +04:00
|
|
|
/*
|
|
|
|
* Finds all leafs with a reference to the specified combination of bytenr and
|
|
|
|
* offset. key_list_head will point to a list of corresponding keys (caller must
|
|
|
|
* free each list element). The leafs will be stored in the leafs ulist, which
|
|
|
|
* must be freed with ulist_free.
|
|
|
|
*
|
|
|
|
* returns 0 on success, <0 on error
|
|
|
|
*/
|
2020-03-10 11:14:15 +03:00
|
|
|
int btrfs_find_all_leafs(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 bytenr,
|
|
|
|
u64 time_seq, struct ulist **leafs,
|
|
|
|
const u64 *extent_item_pos, bool ignore_offset)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
*leafs = ulist_alloc(GFP_NOFS);
|
2014-01-31 20:42:05 +04:00
|
|
|
if (!*leafs)
|
2011-11-23 21:55:04 +04:00
|
|
|
return -ENOMEM;
|
|
|
|
|
btrfs: fix check_shared for fiemap ioctl
Only in the case of different root_id or different object_id, check_shared
identified extent as the shared. However, If a extent was referred by
different offset of same file, it should also be identified as shared.
In addition, check_shared's loop scale is at least n^3, so if a extent
has too many references, even causes soft hang up.
First, add all delayed_ref to the ref_tree and calculate the unqiue_refs,
if the unique_refs is greater than one, return BACKREF_FOUND_SHARED.
Then individually add the on-disk reference(inline/keyed) to the ref_tree
and calculate the unique_refs of the ref_tree to check if the unique_refs
is greater than one.Because once there are two references to return
SHARED, so the time complexity is close to the constant.
Reported-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: Lu Fengqi <lufq.fnst@cn.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-06-13 04:36:46 +03:00
|
|
|
ret = find_parent_nodes(trans, fs_info, bytenr, time_seq,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
*leafs, NULL, extent_item_pos, NULL, ignore_offset);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (ret < 0 && ret != -ENOENT) {
|
2012-05-17 18:43:03 +04:00
|
|
|
free_leaf_list(*leafs);
|
2011-11-23 21:55:04 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* walk all backrefs for a given extent to find all roots that reference this
|
|
|
|
* extent. Walking a backref means finding all extents that reference this
|
|
|
|
* extent and in turn walk the backrefs of those, too. Naturally this is a
|
|
|
|
* recursive process, but here it is implemented in an iterative fashion: We
|
|
|
|
* find all referencing extents for the extent in question and put them on a
|
|
|
|
* list. In turn, we find all referencing extents for those, further appending
|
|
|
|
* to the list. The way we iterate the list allows adding more elements after
|
|
|
|
* the current while iterating. The process stops when we reach the end of the
|
|
|
|
* list. Found roots are added to the roots list.
|
|
|
|
*
|
|
|
|
* returns 0 on success, < 0 on error.
|
|
|
|
*/
|
2017-06-29 06:56:57 +03:00
|
|
|
static int btrfs_find_all_roots_safe(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 bytenr,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
u64 time_seq, struct ulist **roots,
|
|
|
|
bool ignore_offset)
|
2011-11-23 21:55:04 +04:00
|
|
|
{
|
|
|
|
struct ulist *tmp;
|
|
|
|
struct ulist_node *node = NULL;
|
2012-05-22 16:56:50 +04:00
|
|
|
struct ulist_iterator uiter;
|
2011-11-23 21:55:04 +04:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
tmp = ulist_alloc(GFP_NOFS);
|
|
|
|
if (!tmp)
|
|
|
|
return -ENOMEM;
|
|
|
|
*roots = ulist_alloc(GFP_NOFS);
|
|
|
|
if (!*roots) {
|
|
|
|
ulist_free(tmp);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2012-05-22 16:56:50 +04:00
|
|
|
ULIST_ITER_INIT(&uiter);
|
2011-11-23 21:55:04 +04:00
|
|
|
while (1) {
|
btrfs: fix check_shared for fiemap ioctl
Only in the case of different root_id or different object_id, check_shared
identified extent as the shared. However, If a extent was referred by
different offset of same file, it should also be identified as shared.
In addition, check_shared's loop scale is at least n^3, so if a extent
has too many references, even causes soft hang up.
First, add all delayed_ref to the ref_tree and calculate the unqiue_refs,
if the unique_refs is greater than one, return BACKREF_FOUND_SHARED.
Then individually add the on-disk reference(inline/keyed) to the ref_tree
and calculate the unique_refs of the ref_tree to check if the unique_refs
is greater than one.Because once there are two references to return
SHARED, so the time complexity is close to the constant.
Reported-by: Tsutomu Itoh <t-itoh@jp.fujitsu.com>
Signed-off-by: Lu Fengqi <lufq.fnst@cn.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2016-06-13 04:36:46 +03:00
|
|
|
ret = find_parent_nodes(trans, fs_info, bytenr, time_seq,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
tmp, *roots, NULL, NULL, ignore_offset);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (ret < 0 && ret != -ENOENT) {
|
|
|
|
ulist_free(tmp);
|
|
|
|
ulist_free(*roots);
|
btrfs: fix double free on ulist after backref resolution failure
At btrfs_find_all_roots_safe() we allocate a ulist and set the **roots
argument to point to it. However if later we fail due to an error returned
by find_parent_nodes(), we free that ulist but leave a dangling pointer in
the **roots argument. Upon receiving the error, a caller of this function
can attempt to free the same ulist again, resulting in an invalid memory
access.
One such scenario is during qgroup accounting:
btrfs_qgroup_account_extents()
--> calls btrfs_find_all_roots() passes &new_roots (a stack allocated
pointer) to btrfs_find_all_roots()
--> btrfs_find_all_roots() just calls btrfs_find_all_roots_safe()
passing &new_roots to it
--> allocates ulist and assigns its address to **roots (which
points to new_roots from btrfs_qgroup_account_extents())
--> find_parent_nodes() returns an error, so we free the ulist
and leave **roots pointing to it after returning
--> btrfs_qgroup_account_extents() sees btrfs_find_all_roots() returned
an error and jumps to the label 'cleanup', which just tries to
free again the same ulist
Stack trace example:
------------[ cut here ]------------
BTRFS: tree first key check failed
WARNING: CPU: 1 PID: 1763215 at fs/btrfs/disk-io.c:422 btrfs_verify_level_key+0xe0/0x180 [btrfs]
Modules linked in: dm_snapshot dm_thin_pool (...)
CPU: 1 PID: 1763215 Comm: fsstress Tainted: G W 5.8.0-rc3-btrfs-next-64 #1
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014
RIP: 0010:btrfs_verify_level_key+0xe0/0x180 [btrfs]
Code: 28 5b 5d (...)
RSP: 0018:ffffb89b473779a0 EFLAGS: 00010286
RAX: 0000000000000000 RBX: ffff90397759bf08 RCX: 0000000000000000
RDX: 0000000000000001 RSI: 0000000000000027 RDI: 00000000ffffffff
RBP: ffff9039a419c000 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000000 R11: ffffb89b43301000 R12: 000000000000005e
R13: ffffb89b47377a2e R14: ffffb89b473779af R15: 0000000000000000
FS: 00007fc47e1e1000(0000) GS:ffff9039ac200000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007fc47e1df000 CR3: 00000003d9e4e001 CR4: 00000000003606e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
read_block_for_search+0xf6/0x350 [btrfs]
btrfs_next_old_leaf+0x242/0x650 [btrfs]
resolve_indirect_refs+0x7cf/0x9e0 [btrfs]
find_parent_nodes+0x4ea/0x12c0 [btrfs]
btrfs_find_all_roots_safe+0xbf/0x130 [btrfs]
btrfs_qgroup_account_extents+0x9d/0x390 [btrfs]
btrfs_commit_transaction+0x4f7/0xb20 [btrfs]
btrfs_sync_file+0x3d4/0x4d0 [btrfs]
do_fsync+0x38/0x70
__x64_sys_fdatasync+0x13/0x20
do_syscall_64+0x5c/0xe0
entry_SYSCALL_64_after_hwframe+0x44/0xa9
RIP: 0033:0x7fc47e2d72e3
Code: Bad RIP value.
RSP: 002b:00007fffa32098c8 EFLAGS: 00000246 ORIG_RAX: 000000000000004b
RAX: ffffffffffffffda RBX: 0000000000000003 RCX: 00007fc47e2d72e3
RDX: 00007fffa3209830 RSI: 00007fffa3209830 RDI: 0000000000000003
RBP: 000000000000072e R08: 0000000000000001 R09: 0000000000000003
R10: 0000000000000000 R11: 0000000000000246 R12: 00000000000003e8
R13: 0000000051eb851f R14: 00007fffa3209970 R15: 00005607c4ac8b50
irq event stamp: 0
hardirqs last enabled at (0): [<0000000000000000>] 0x0
hardirqs last disabled at (0): [<ffffffffb8eb5e85>] copy_process+0x755/0x1eb0
softirqs last enabled at (0): [<ffffffffb8eb5e85>] copy_process+0x755/0x1eb0
softirqs last disabled at (0): [<0000000000000000>] 0x0
---[ end trace 8639237550317b48 ]---
BTRFS error (device sdc): tree first key mismatch detected, bytenr=62324736 parent_transid=94 key expected=(262,108,1351680) has=(259,108,1921024)
general protection fault, probably for non-canonical address 0x6b6b6b6b6b6b6b6b: 0000 [#1] PREEMPT SMP DEBUG_PAGEALLOC PTI
CPU: 2 PID: 1763215 Comm: fsstress Tainted: G W 5.8.0-rc3-btrfs-next-64 #1
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014
RIP: 0010:ulist_release+0x14/0x60 [btrfs]
Code: c7 07 00 (...)
RSP: 0018:ffffb89b47377d60 EFLAGS: 00010282
RAX: 6b6b6b6b6b6b6b6b RBX: ffff903959b56b90 RCX: 0000000000000000
RDX: 0000000000000001 RSI: 0000000000270024 RDI: ffff9036e2adc840
RBP: ffff9036e2adc848 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000000 R11: 0000000000000000 R12: ffff9036e2adc840
R13: 0000000000000015 R14: ffff9039a419ccf8 R15: ffff90395d605840
FS: 00007fc47e1e1000(0000) GS:ffff9039ac600000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f8c1c0a51c8 CR3: 00000003d9e4e004 CR4: 00000000003606e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
ulist_free+0x13/0x20 [btrfs]
btrfs_qgroup_account_extents+0xf3/0x390 [btrfs]
btrfs_commit_transaction+0x4f7/0xb20 [btrfs]
btrfs_sync_file+0x3d4/0x4d0 [btrfs]
do_fsync+0x38/0x70
__x64_sys_fdatasync+0x13/0x20
do_syscall_64+0x5c/0xe0
entry_SYSCALL_64_after_hwframe+0x44/0xa9
RIP: 0033:0x7fc47e2d72e3
Code: Bad RIP value.
RSP: 002b:00007fffa32098c8 EFLAGS: 00000246 ORIG_RAX: 000000000000004b
RAX: ffffffffffffffda RBX: 0000000000000003 RCX: 00007fc47e2d72e3
RDX: 00007fffa3209830 RSI: 00007fffa3209830 RDI: 0000000000000003
RBP: 000000000000072e R08: 0000000000000001 R09: 0000000000000003
R10: 0000000000000000 R11: 0000000000000246 R12: 00000000000003e8
R13: 0000000051eb851f R14: 00007fffa3209970 R15: 00005607c4ac8b50
Modules linked in: dm_snapshot dm_thin_pool (...)
---[ end trace 8639237550317b49 ]---
RIP: 0010:ulist_release+0x14/0x60 [btrfs]
Code: c7 07 00 (...)
RSP: 0018:ffffb89b47377d60 EFLAGS: 00010282
RAX: 6b6b6b6b6b6b6b6b RBX: ffff903959b56b90 RCX: 0000000000000000
RDX: 0000000000000001 RSI: 0000000000270024 RDI: ffff9036e2adc840
RBP: ffff9036e2adc848 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000000 R11: 0000000000000000 R12: ffff9036e2adc840
R13: 0000000000000015 R14: ffff9039a419ccf8 R15: ffff90395d605840
FS: 00007fc47e1e1000(0000) GS:ffff9039ad200000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f6a776f7d40 CR3: 00000003d9e4e002 CR4: 00000000003606e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Fix this by making btrfs_find_all_roots_safe() set *roots to NULL after
it frees the ulist.
Fixes: 8da6d5815c592b ("Btrfs: added btrfs_find_all_roots()")
CC: stable@vger.kernel.org # 4.4+
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2020-07-13 17:11:56 +03:00
|
|
|
*roots = NULL;
|
2011-11-23 21:55:04 +04:00
|
|
|
return ret;
|
|
|
|
}
|
2012-05-22 16:56:50 +04:00
|
|
|
node = ulist_next(tmp, &uiter);
|
2011-11-23 21:55:04 +04:00
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
bytenr = node->val;
|
2014-01-26 18:32:18 +04:00
|
|
|
cond_resched();
|
2011-11-23 21:55:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
ulist_free(tmp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-13 23:42:13 +04:00
|
|
|
int btrfs_find_all_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 bytenr,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
u64 time_seq, struct ulist **roots,
|
2021-07-22 17:58:10 +03:00
|
|
|
bool skip_commit_root_sem)
|
2014-03-13 23:42:13 +04:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
btrfs: fix lock inversion problem when doing qgroup extent tracing
At btrfs_qgroup_trace_extent_post() we call btrfs_find_all_roots() with a
NULL value as the transaction handle argument, which makes that function
take the commit_root_sem semaphore, which is necessary when we don't hold
a transaction handle or any other mechanism to prevent a transaction
commit from wiping out commit roots.
However btrfs_qgroup_trace_extent_post() can be called in a context where
we are holding a write lock on an extent buffer from a subvolume tree,
namely from btrfs_truncate_inode_items(), called either during truncate
or unlink operations. In this case we end up with a lock inversion problem
because the commit_root_sem is a higher level lock, always supposed to be
acquired before locking any extent buffer.
Lockdep detects this lock inversion problem since we switched the extent
buffer locks from custom locks to semaphores, and when running btrfs/158
from fstests, it reported the following trace:
[ 9057.626435] ======================================================
[ 9057.627541] WARNING: possible circular locking dependency detected
[ 9057.628334] 5.14.0-rc2-btrfs-next-93 #1 Not tainted
[ 9057.628961] ------------------------------------------------------
[ 9057.629867] kworker/u16:4/30781 is trying to acquire lock:
[ 9057.630824] ffff8e2590f58760 (btrfs-tree-00){++++}-{3:3}, at: __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.632542]
but task is already holding lock:
[ 9057.633551] ffff8e25582d4b70 (&fs_info->commit_root_sem){++++}-{3:3}, at: iterate_extent_inodes+0x10b/0x280 [btrfs]
[ 9057.635255]
which lock already depends on the new lock.
[ 9057.636292]
the existing dependency chain (in reverse order) is:
[ 9057.637240]
-> #1 (&fs_info->commit_root_sem){++++}-{3:3}:
[ 9057.638138] down_read+0x46/0x140
[ 9057.638648] btrfs_find_all_roots+0x41/0x80 [btrfs]
[ 9057.639398] btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
[ 9057.640283] btrfs_add_delayed_data_ref+0x418/0x490 [btrfs]
[ 9057.641114] btrfs_free_extent+0x35/0xb0 [btrfs]
[ 9057.641819] btrfs_truncate_inode_items+0x424/0xf70 [btrfs]
[ 9057.642643] btrfs_evict_inode+0x454/0x4f0 [btrfs]
[ 9057.643418] evict+0xcf/0x1d0
[ 9057.643895] do_unlinkat+0x1e9/0x300
[ 9057.644525] do_syscall_64+0x3b/0xc0
[ 9057.645110] entry_SYSCALL_64_after_hwframe+0x44/0xae
[ 9057.645835]
-> #0 (btrfs-tree-00){++++}-{3:3}:
[ 9057.646600] __lock_acquire+0x130e/0x2210
[ 9057.647248] lock_acquire+0xd7/0x310
[ 9057.647773] down_read_nested+0x4b/0x140
[ 9057.648350] __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.649175] btrfs_read_lock_root_node+0x31/0x40 [btrfs]
[ 9057.650010] btrfs_search_slot+0x537/0xc00 [btrfs]
[ 9057.650849] scrub_print_warning_inode+0x89/0x370 [btrfs]
[ 9057.651733] iterate_extent_inodes+0x1e3/0x280 [btrfs]
[ 9057.652501] scrub_print_warning+0x15d/0x2f0 [btrfs]
[ 9057.653264] scrub_handle_errored_block.isra.0+0x135f/0x1640 [btrfs]
[ 9057.654295] scrub_bio_end_io_worker+0x101/0x2e0 [btrfs]
[ 9057.655111] btrfs_work_helper+0xf8/0x400 [btrfs]
[ 9057.655831] process_one_work+0x247/0x5a0
[ 9057.656425] worker_thread+0x55/0x3c0
[ 9057.656993] kthread+0x155/0x180
[ 9057.657494] ret_from_fork+0x22/0x30
[ 9057.658030]
other info that might help us debug this:
[ 9057.659064] Possible unsafe locking scenario:
[ 9057.659824] CPU0 CPU1
[ 9057.660402] ---- ----
[ 9057.660988] lock(&fs_info->commit_root_sem);
[ 9057.661581] lock(btrfs-tree-00);
[ 9057.662348] lock(&fs_info->commit_root_sem);
[ 9057.663254] lock(btrfs-tree-00);
[ 9057.663690]
*** DEADLOCK ***
[ 9057.664437] 4 locks held by kworker/u16:4/30781:
[ 9057.665023] #0: ffff8e25922a1148 ((wq_completion)btrfs-scrub){+.+.}-{0:0}, at: process_one_work+0x1c7/0x5a0
[ 9057.666260] #1: ffffabb3451ffe70 ((work_completion)(&work->normal_work)){+.+.}-{0:0}, at: process_one_work+0x1c7/0x5a0
[ 9057.667639] #2: ffff8e25922da198 (&ret->mutex){+.+.}-{3:3}, at: scrub_handle_errored_block.isra.0+0x5d2/0x1640 [btrfs]
[ 9057.669017] #3: ffff8e25582d4b70 (&fs_info->commit_root_sem){++++}-{3:3}, at: iterate_extent_inodes+0x10b/0x280 [btrfs]
[ 9057.670408]
stack backtrace:
[ 9057.670976] CPU: 7 PID: 30781 Comm: kworker/u16:4 Not tainted 5.14.0-rc2-btrfs-next-93 #1
[ 9057.672030] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.14.0-0-g155821a1990b-prebuilt.qemu.org 04/01/2014
[ 9057.673492] Workqueue: btrfs-scrub btrfs_work_helper [btrfs]
[ 9057.674258] Call Trace:
[ 9057.674588] dump_stack_lvl+0x57/0x72
[ 9057.675083] check_noncircular+0xf3/0x110
[ 9057.675611] __lock_acquire+0x130e/0x2210
[ 9057.676132] lock_acquire+0xd7/0x310
[ 9057.676605] ? __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.677313] ? lock_is_held_type+0xe8/0x140
[ 9057.677849] down_read_nested+0x4b/0x140
[ 9057.678349] ? __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.679068] __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.679760] btrfs_read_lock_root_node+0x31/0x40 [btrfs]
[ 9057.680458] btrfs_search_slot+0x537/0xc00 [btrfs]
[ 9057.681083] ? _raw_spin_unlock+0x29/0x40
[ 9057.681594] ? btrfs_find_all_roots_safe+0x11f/0x140 [btrfs]
[ 9057.682336] scrub_print_warning_inode+0x89/0x370 [btrfs]
[ 9057.683058] ? btrfs_find_all_roots_safe+0x11f/0x140 [btrfs]
[ 9057.683834] ? scrub_write_block_to_dev_replace+0xb0/0xb0 [btrfs]
[ 9057.684632] iterate_extent_inodes+0x1e3/0x280 [btrfs]
[ 9057.685316] scrub_print_warning+0x15d/0x2f0 [btrfs]
[ 9057.685977] ? ___ratelimit+0xa4/0x110
[ 9057.686460] scrub_handle_errored_block.isra.0+0x135f/0x1640 [btrfs]
[ 9057.687316] scrub_bio_end_io_worker+0x101/0x2e0 [btrfs]
[ 9057.688021] btrfs_work_helper+0xf8/0x400 [btrfs]
[ 9057.688649] ? lock_is_held_type+0xe8/0x140
[ 9057.689180] process_one_work+0x247/0x5a0
[ 9057.689696] worker_thread+0x55/0x3c0
[ 9057.690175] ? process_one_work+0x5a0/0x5a0
[ 9057.690731] kthread+0x155/0x180
[ 9057.691158] ? set_kthread_struct+0x40/0x40
[ 9057.691697] ret_from_fork+0x22/0x30
Fix this by making btrfs_find_all_roots() never attempt to lock the
commit_root_sem when it is called from btrfs_qgroup_trace_extent_post().
We can't just pass a non-NULL transaction handle to btrfs_find_all_roots()
from btrfs_qgroup_trace_extent_post(), because that would make backref
lookup not use commit roots and acquire read locks on extent buffers, and
therefore could deadlock when btrfs_qgroup_trace_extent_post() is called
from the btrfs_truncate_inode_items() code path which has acquired a write
lock on an extent buffer of the subvolume btree.
CC: stable@vger.kernel.org # 4.19+
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2021-07-21 19:31:48 +03:00
|
|
|
if (!trans && !skip_commit_root_sem)
|
2014-03-13 23:42:13 +04:00
|
|
|
down_read(&fs_info->commit_root_sem);
|
2017-06-29 06:56:57 +03:00
|
|
|
ret = btrfs_find_all_roots_safe(trans, fs_info, bytenr,
|
2021-07-22 17:58:10 +03:00
|
|
|
time_seq, roots, false);
|
btrfs: fix lock inversion problem when doing qgroup extent tracing
At btrfs_qgroup_trace_extent_post() we call btrfs_find_all_roots() with a
NULL value as the transaction handle argument, which makes that function
take the commit_root_sem semaphore, which is necessary when we don't hold
a transaction handle or any other mechanism to prevent a transaction
commit from wiping out commit roots.
However btrfs_qgroup_trace_extent_post() can be called in a context where
we are holding a write lock on an extent buffer from a subvolume tree,
namely from btrfs_truncate_inode_items(), called either during truncate
or unlink operations. In this case we end up with a lock inversion problem
because the commit_root_sem is a higher level lock, always supposed to be
acquired before locking any extent buffer.
Lockdep detects this lock inversion problem since we switched the extent
buffer locks from custom locks to semaphores, and when running btrfs/158
from fstests, it reported the following trace:
[ 9057.626435] ======================================================
[ 9057.627541] WARNING: possible circular locking dependency detected
[ 9057.628334] 5.14.0-rc2-btrfs-next-93 #1 Not tainted
[ 9057.628961] ------------------------------------------------------
[ 9057.629867] kworker/u16:4/30781 is trying to acquire lock:
[ 9057.630824] ffff8e2590f58760 (btrfs-tree-00){++++}-{3:3}, at: __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.632542]
but task is already holding lock:
[ 9057.633551] ffff8e25582d4b70 (&fs_info->commit_root_sem){++++}-{3:3}, at: iterate_extent_inodes+0x10b/0x280 [btrfs]
[ 9057.635255]
which lock already depends on the new lock.
[ 9057.636292]
the existing dependency chain (in reverse order) is:
[ 9057.637240]
-> #1 (&fs_info->commit_root_sem){++++}-{3:3}:
[ 9057.638138] down_read+0x46/0x140
[ 9057.638648] btrfs_find_all_roots+0x41/0x80 [btrfs]
[ 9057.639398] btrfs_qgroup_trace_extent_post+0x37/0x70 [btrfs]
[ 9057.640283] btrfs_add_delayed_data_ref+0x418/0x490 [btrfs]
[ 9057.641114] btrfs_free_extent+0x35/0xb0 [btrfs]
[ 9057.641819] btrfs_truncate_inode_items+0x424/0xf70 [btrfs]
[ 9057.642643] btrfs_evict_inode+0x454/0x4f0 [btrfs]
[ 9057.643418] evict+0xcf/0x1d0
[ 9057.643895] do_unlinkat+0x1e9/0x300
[ 9057.644525] do_syscall_64+0x3b/0xc0
[ 9057.645110] entry_SYSCALL_64_after_hwframe+0x44/0xae
[ 9057.645835]
-> #0 (btrfs-tree-00){++++}-{3:3}:
[ 9057.646600] __lock_acquire+0x130e/0x2210
[ 9057.647248] lock_acquire+0xd7/0x310
[ 9057.647773] down_read_nested+0x4b/0x140
[ 9057.648350] __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.649175] btrfs_read_lock_root_node+0x31/0x40 [btrfs]
[ 9057.650010] btrfs_search_slot+0x537/0xc00 [btrfs]
[ 9057.650849] scrub_print_warning_inode+0x89/0x370 [btrfs]
[ 9057.651733] iterate_extent_inodes+0x1e3/0x280 [btrfs]
[ 9057.652501] scrub_print_warning+0x15d/0x2f0 [btrfs]
[ 9057.653264] scrub_handle_errored_block.isra.0+0x135f/0x1640 [btrfs]
[ 9057.654295] scrub_bio_end_io_worker+0x101/0x2e0 [btrfs]
[ 9057.655111] btrfs_work_helper+0xf8/0x400 [btrfs]
[ 9057.655831] process_one_work+0x247/0x5a0
[ 9057.656425] worker_thread+0x55/0x3c0
[ 9057.656993] kthread+0x155/0x180
[ 9057.657494] ret_from_fork+0x22/0x30
[ 9057.658030]
other info that might help us debug this:
[ 9057.659064] Possible unsafe locking scenario:
[ 9057.659824] CPU0 CPU1
[ 9057.660402] ---- ----
[ 9057.660988] lock(&fs_info->commit_root_sem);
[ 9057.661581] lock(btrfs-tree-00);
[ 9057.662348] lock(&fs_info->commit_root_sem);
[ 9057.663254] lock(btrfs-tree-00);
[ 9057.663690]
*** DEADLOCK ***
[ 9057.664437] 4 locks held by kworker/u16:4/30781:
[ 9057.665023] #0: ffff8e25922a1148 ((wq_completion)btrfs-scrub){+.+.}-{0:0}, at: process_one_work+0x1c7/0x5a0
[ 9057.666260] #1: ffffabb3451ffe70 ((work_completion)(&work->normal_work)){+.+.}-{0:0}, at: process_one_work+0x1c7/0x5a0
[ 9057.667639] #2: ffff8e25922da198 (&ret->mutex){+.+.}-{3:3}, at: scrub_handle_errored_block.isra.0+0x5d2/0x1640 [btrfs]
[ 9057.669017] #3: ffff8e25582d4b70 (&fs_info->commit_root_sem){++++}-{3:3}, at: iterate_extent_inodes+0x10b/0x280 [btrfs]
[ 9057.670408]
stack backtrace:
[ 9057.670976] CPU: 7 PID: 30781 Comm: kworker/u16:4 Not tainted 5.14.0-rc2-btrfs-next-93 #1
[ 9057.672030] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.14.0-0-g155821a1990b-prebuilt.qemu.org 04/01/2014
[ 9057.673492] Workqueue: btrfs-scrub btrfs_work_helper [btrfs]
[ 9057.674258] Call Trace:
[ 9057.674588] dump_stack_lvl+0x57/0x72
[ 9057.675083] check_noncircular+0xf3/0x110
[ 9057.675611] __lock_acquire+0x130e/0x2210
[ 9057.676132] lock_acquire+0xd7/0x310
[ 9057.676605] ? __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.677313] ? lock_is_held_type+0xe8/0x140
[ 9057.677849] down_read_nested+0x4b/0x140
[ 9057.678349] ? __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.679068] __btrfs_tree_read_lock+0x24/0x110 [btrfs]
[ 9057.679760] btrfs_read_lock_root_node+0x31/0x40 [btrfs]
[ 9057.680458] btrfs_search_slot+0x537/0xc00 [btrfs]
[ 9057.681083] ? _raw_spin_unlock+0x29/0x40
[ 9057.681594] ? btrfs_find_all_roots_safe+0x11f/0x140 [btrfs]
[ 9057.682336] scrub_print_warning_inode+0x89/0x370 [btrfs]
[ 9057.683058] ? btrfs_find_all_roots_safe+0x11f/0x140 [btrfs]
[ 9057.683834] ? scrub_write_block_to_dev_replace+0xb0/0xb0 [btrfs]
[ 9057.684632] iterate_extent_inodes+0x1e3/0x280 [btrfs]
[ 9057.685316] scrub_print_warning+0x15d/0x2f0 [btrfs]
[ 9057.685977] ? ___ratelimit+0xa4/0x110
[ 9057.686460] scrub_handle_errored_block.isra.0+0x135f/0x1640 [btrfs]
[ 9057.687316] scrub_bio_end_io_worker+0x101/0x2e0 [btrfs]
[ 9057.688021] btrfs_work_helper+0xf8/0x400 [btrfs]
[ 9057.688649] ? lock_is_held_type+0xe8/0x140
[ 9057.689180] process_one_work+0x247/0x5a0
[ 9057.689696] worker_thread+0x55/0x3c0
[ 9057.690175] ? process_one_work+0x5a0/0x5a0
[ 9057.690731] kthread+0x155/0x180
[ 9057.691158] ? set_kthread_struct+0x40/0x40
[ 9057.691697] ret_from_fork+0x22/0x30
Fix this by making btrfs_find_all_roots() never attempt to lock the
commit_root_sem when it is called from btrfs_qgroup_trace_extent_post().
We can't just pass a non-NULL transaction handle to btrfs_find_all_roots()
from btrfs_qgroup_trace_extent_post(), because that would make backref
lookup not use commit roots and acquire read locks on extent buffers, and
therefore could deadlock when btrfs_qgroup_trace_extent_post() is called
from the btrfs_truncate_inode_items() code path which has acquired a write
lock on an extent buffer of the subvolume btree.
CC: stable@vger.kernel.org # 4.19+
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2021-07-21 19:31:48 +03:00
|
|
|
if (!trans && !skip_commit_root_sem)
|
2014-03-13 23:42:13 +04:00
|
|
|
up_read(&fs_info->commit_root_sem);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-05-19 22:49:50 +03:00
|
|
|
/**
|
2021-01-22 12:58:00 +03:00
|
|
|
* Check if an extent is shared or not
|
|
|
|
*
|
|
|
|
* @root: root inode belongs to
|
|
|
|
* @inum: inode number of the inode whose extent we are checking
|
|
|
|
* @bytenr: logical bytenr of the extent we are checking
|
|
|
|
* @roots: list of roots this extent is shared among
|
|
|
|
* @tmp: temporary list used for iteration
|
2015-05-19 22:49:50 +03:00
|
|
|
*
|
|
|
|
* btrfs_check_shared uses the backref walking code but will short
|
|
|
|
* circuit as soon as it finds a root or inode that doesn't match the
|
|
|
|
* one passed in. This provides a significant performance benefit for
|
|
|
|
* callers (such as fiemap) which want to know whether the extent is
|
|
|
|
* shared but do not need a ref count.
|
|
|
|
*
|
Btrfs: do not start a transaction during fiemap
During fiemap, for regular extents (non inline) we need to check if they
are shared and if they are, set the shared bit. Checking if an extent is
shared requires checking the delayed references of the currently running
transaction, since some reference might have not yet hit the extent tree
and be only in the in-memory delayed references.
However we were using a transaction join for this, which creates a new
transaction when there is no transaction currently running. That means
that two more potential failures can happen: creating the transaction and
committing it. Further, if no write activity is currently happening in the
system, and fiemap calls keep being done, we end up creating and
committing transactions that do nothing.
In some extreme cases this can result in the commit of the transaction
created by fiemap to fail with ENOSPC when updating the root item of a
subvolume tree because a join does not reserve any space, leading to a
trace like the following:
heisenberg kernel: ------------[ cut here ]------------
heisenberg kernel: BTRFS: Transaction aborted (error -28)
heisenberg kernel: WARNING: CPU: 0 PID: 7137 at fs/btrfs/root-tree.c:136 btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: CPU: 0 PID: 7137 Comm: btrfs-transacti Not tainted 4.19.0-4-amd64 #1 Debian 4.19.28-2
heisenberg kernel: Hardware name: FUJITSU LIFEBOOK U757/FJNB2A5, BIOS Version 1.21 03/19/2018
heisenberg kernel: RIP: 0010:btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: RSP: 0018:ffffb5448828bd40 EFLAGS: 00010286
heisenberg kernel: RAX: 0000000000000000 RBX: ffff8ed56bccef50 RCX: 0000000000000006
heisenberg kernel: RDX: 0000000000000007 RSI: 0000000000000092 RDI: ffff8ed6bda166a0
heisenberg kernel: RBP: 00000000ffffffe4 R08: 00000000000003df R09: 0000000000000007
heisenberg kernel: R10: 0000000000000000 R11: 0000000000000001 R12: ffff8ed63396a078
heisenberg kernel: R13: ffff8ed092d7c800 R14: ffff8ed64f5db028 R15: ffff8ed6bd03d068
heisenberg kernel: FS: 0000000000000000(0000) GS:ffff8ed6bda00000(0000) knlGS:0000000000000000
heisenberg kernel: CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
heisenberg kernel: CR2: 00007f46f75f8000 CR3: 0000000310a0a002 CR4: 00000000003606f0
heisenberg kernel: DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
heisenberg kernel: DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
heisenberg kernel: Call Trace:
heisenberg kernel: commit_fs_roots+0x166/0x1d0 [btrfs]
heisenberg kernel: ? _cond_resched+0x15/0x30
heisenberg kernel: ? btrfs_run_delayed_refs+0xac/0x180 [btrfs]
heisenberg kernel: btrfs_commit_transaction+0x2bd/0x870 [btrfs]
heisenberg kernel: ? start_transaction+0x9d/0x3f0 [btrfs]
heisenberg kernel: transaction_kthread+0x147/0x180 [btrfs]
heisenberg kernel: ? btrfs_cleanup_transaction+0x530/0x530 [btrfs]
heisenberg kernel: kthread+0x112/0x130
heisenberg kernel: ? kthread_bind+0x30/0x30
heisenberg kernel: ret_from_fork+0x35/0x40
heisenberg kernel: ---[ end trace 05de912e30e012d9 ]---
Since fiemap (and btrfs_check_shared()) is a read-only operation, do not do
a transaction join to avoid the overhead of creating a new transaction (if
there is currently no running transaction) and introducing a potential
point of failure when the new transaction gets committed, instead use a
transaction attach to grab a handle for the currently running transaction
if any.
Reported-by: Christoph Anton Mitterer <calestyo@scientia.net>
Link: https://lore.kernel.org/linux-btrfs/b2a668d7124f1d3e410367f587926f622b3f03a4.camel@scientia.net/
Fixes: afce772e87c36c ("btrfs: fix check_shared for fiemap ioctl")
CC: stable@vger.kernel.org # 4.14+
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-04-15 16:50:51 +03:00
|
|
|
* This attempts to attach to the running transaction in order to account for
|
|
|
|
* delayed refs, but continues on even when no running transaction exists.
|
2017-06-29 06:56:58 +03:00
|
|
|
*
|
2015-05-19 22:49:50 +03:00
|
|
|
* Return: 0 if extent is not shared, 1 if it is shared, < 0 on error.
|
|
|
|
*/
|
2019-05-15 16:31:04 +03:00
|
|
|
int btrfs_check_shared(struct btrfs_root *root, u64 inum, u64 bytenr,
|
|
|
|
struct ulist *roots, struct ulist *tmp)
|
2014-09-11 00:20:45 +04:00
|
|
|
{
|
2017-06-29 06:56:58 +03:00
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
struct btrfs_trans_handle *trans;
|
2014-09-11 00:20:45 +04:00
|
|
|
struct ulist_iterator uiter;
|
|
|
|
struct ulist_node *node;
|
2021-03-11 17:31:07 +03:00
|
|
|
struct btrfs_seq_list elem = BTRFS_SEQ_LIST_INIT(elem);
|
2014-09-11 00:20:45 +04:00
|
|
|
int ret = 0;
|
2017-07-13 01:20:10 +03:00
|
|
|
struct share_check shared = {
|
2018-08-06 08:25:24 +03:00
|
|
|
.root_objectid = root->root_key.objectid,
|
2017-07-13 01:20:10 +03:00
|
|
|
.inum = inum,
|
|
|
|
.share_count = 0,
|
|
|
|
};
|
2014-09-11 00:20:45 +04:00
|
|
|
|
2019-05-15 16:31:04 +03:00
|
|
|
ulist_init(roots);
|
|
|
|
ulist_init(tmp);
|
2014-09-11 00:20:45 +04:00
|
|
|
|
Btrfs: fix deadlock between fiemap and transaction commits
The fiemap handler locks a file range that can have unflushed delalloc,
and after locking the range, it tries to attach to a running transaction.
If the running transaction started its commit, that is, it is in state
TRANS_STATE_COMMIT_START, and either the filesystem was mounted with the
flushoncommit option or the transaction is creating a snapshot for the
subvolume that contains the file that fiemap is operating on, we end up
deadlocking. This happens because fiemap is blocked on the transaction,
waiting for it to complete, and the transaction is waiting for the flushed
dealloc to complete, which requires locking the file range that the fiemap
task already locked. The following stack traces serve as an example of
when this deadlock happens:
(...)
[404571.515510] Workqueue: btrfs-endio-write btrfs_endio_write_helper [btrfs]
[404571.515956] Call Trace:
[404571.516360] ? __schedule+0x3ae/0x7b0
[404571.516730] schedule+0x3a/0xb0
[404571.517104] lock_extent_bits+0x1ec/0x2a0 [btrfs]
[404571.517465] ? remove_wait_queue+0x60/0x60
[404571.517832] btrfs_finish_ordered_io+0x292/0x800 [btrfs]
[404571.518202] normal_work_helper+0xea/0x530 [btrfs]
[404571.518566] process_one_work+0x21e/0x5c0
[404571.518990] worker_thread+0x4f/0x3b0
[404571.519413] ? process_one_work+0x5c0/0x5c0
[404571.519829] kthread+0x103/0x140
[404571.520191] ? kthread_create_worker_on_cpu+0x70/0x70
[404571.520565] ret_from_fork+0x3a/0x50
[404571.520915] kworker/u8:6 D 0 31651 2 0x80004000
[404571.521290] Workqueue: btrfs-flush_delalloc btrfs_flush_delalloc_helper [btrfs]
(...)
[404571.537000] fsstress D 0 13117 13115 0x00004000
[404571.537263] Call Trace:
[404571.537524] ? __schedule+0x3ae/0x7b0
[404571.537788] schedule+0x3a/0xb0
[404571.538066] wait_current_trans+0xc8/0x100 [btrfs]
[404571.538349] ? remove_wait_queue+0x60/0x60
[404571.538680] start_transaction+0x33c/0x500 [btrfs]
[404571.539076] btrfs_check_shared+0xa3/0x1f0 [btrfs]
[404571.539513] ? extent_fiemap+0x2ce/0x650 [btrfs]
[404571.539866] extent_fiemap+0x2ce/0x650 [btrfs]
[404571.540170] do_vfs_ioctl+0x526/0x6f0
[404571.540436] ksys_ioctl+0x70/0x80
[404571.540734] __x64_sys_ioctl+0x16/0x20
[404571.540997] do_syscall_64+0x60/0x1d0
[404571.541279] entry_SYSCALL_64_after_hwframe+0x49/0xbe
(...)
[404571.543729] btrfs D 0 14210 14208 0x00004000
[404571.544023] Call Trace:
[404571.544275] ? __schedule+0x3ae/0x7b0
[404571.544526] ? wait_for_completion+0x112/0x1a0
[404571.544795] schedule+0x3a/0xb0
[404571.545064] schedule_timeout+0x1ff/0x390
[404571.545351] ? lock_acquire+0xa6/0x190
[404571.545638] ? wait_for_completion+0x49/0x1a0
[404571.545890] ? wait_for_completion+0x112/0x1a0
[404571.546228] wait_for_completion+0x131/0x1a0
[404571.546503] ? wake_up_q+0x70/0x70
[404571.546775] btrfs_wait_ordered_extents+0x27c/0x400 [btrfs]
[404571.547159] btrfs_commit_transaction+0x3b0/0xae0 [btrfs]
[404571.547449] ? btrfs_mksubvol+0x4a4/0x640 [btrfs]
[404571.547703] ? remove_wait_queue+0x60/0x60
[404571.547969] btrfs_mksubvol+0x605/0x640 [btrfs]
[404571.548226] ? __sb_start_write+0xd4/0x1c0
[404571.548512] ? mnt_want_write_file+0x24/0x50
[404571.548789] btrfs_ioctl_snap_create_transid+0x169/0x1a0 [btrfs]
[404571.549048] btrfs_ioctl_snap_create_v2+0x11d/0x170 [btrfs]
[404571.549307] btrfs_ioctl+0x133f/0x3150 [btrfs]
[404571.549549] ? mem_cgroup_charge_statistics+0x4c/0xd0
[404571.549792] ? mem_cgroup_commit_charge+0x84/0x4b0
[404571.550064] ? __handle_mm_fault+0xe3e/0x11f0
[404571.550306] ? do_raw_spin_unlock+0x49/0xc0
[404571.550608] ? _raw_spin_unlock+0x24/0x30
[404571.550976] ? __handle_mm_fault+0xedf/0x11f0
[404571.551319] ? do_vfs_ioctl+0xa2/0x6f0
[404571.551659] ? btrfs_ioctl_get_supported_features+0x30/0x30 [btrfs]
[404571.552087] do_vfs_ioctl+0xa2/0x6f0
[404571.552355] ksys_ioctl+0x70/0x80
[404571.552621] __x64_sys_ioctl+0x16/0x20
[404571.552864] do_syscall_64+0x60/0x1d0
[404571.553104] entry_SYSCALL_64_after_hwframe+0x49/0xbe
(...)
If we were joining the transaction instead of attaching to it, we would
not risk a deadlock because a join only blocks if the transaction is in a
state greater then or equals to TRANS_STATE_COMMIT_DOING, and the delalloc
flush performed by a transaction is done before it reaches that state,
when it is in the state TRANS_STATE_COMMIT_START. However a transaction
join is intended for use cases where we do modify the filesystem, and
fiemap only needs to peek at delayed references from the current
transaction in order to determine if extents are shared, and, besides
that, when there is no current transaction or when it blocks to wait for
a current committing transaction to complete, it creates a new transaction
without reserving any space. Such unnecessary transactions, besides doing
unnecessary IO, can cause transaction aborts (-ENOSPC) and unnecessary
rotation of the precious backup roots.
So fix this by adding a new transaction join variant, named join_nostart,
which behaves like the regular join, but it does not create a transaction
when none currently exists or after waiting for a committing transaction
to complete.
Fixes: 03628cdbc64db6 ("Btrfs: do not start a transaction during fiemap")
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-07-29 11:37:10 +03:00
|
|
|
trans = btrfs_join_transaction_nostart(root);
|
2017-06-29 06:56:58 +03:00
|
|
|
if (IS_ERR(trans)) {
|
Btrfs: do not start a transaction during fiemap
During fiemap, for regular extents (non inline) we need to check if they
are shared and if they are, set the shared bit. Checking if an extent is
shared requires checking the delayed references of the currently running
transaction, since some reference might have not yet hit the extent tree
and be only in the in-memory delayed references.
However we were using a transaction join for this, which creates a new
transaction when there is no transaction currently running. That means
that two more potential failures can happen: creating the transaction and
committing it. Further, if no write activity is currently happening in the
system, and fiemap calls keep being done, we end up creating and
committing transactions that do nothing.
In some extreme cases this can result in the commit of the transaction
created by fiemap to fail with ENOSPC when updating the root item of a
subvolume tree because a join does not reserve any space, leading to a
trace like the following:
heisenberg kernel: ------------[ cut here ]------------
heisenberg kernel: BTRFS: Transaction aborted (error -28)
heisenberg kernel: WARNING: CPU: 0 PID: 7137 at fs/btrfs/root-tree.c:136 btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: CPU: 0 PID: 7137 Comm: btrfs-transacti Not tainted 4.19.0-4-amd64 #1 Debian 4.19.28-2
heisenberg kernel: Hardware name: FUJITSU LIFEBOOK U757/FJNB2A5, BIOS Version 1.21 03/19/2018
heisenberg kernel: RIP: 0010:btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: RSP: 0018:ffffb5448828bd40 EFLAGS: 00010286
heisenberg kernel: RAX: 0000000000000000 RBX: ffff8ed56bccef50 RCX: 0000000000000006
heisenberg kernel: RDX: 0000000000000007 RSI: 0000000000000092 RDI: ffff8ed6bda166a0
heisenberg kernel: RBP: 00000000ffffffe4 R08: 00000000000003df R09: 0000000000000007
heisenberg kernel: R10: 0000000000000000 R11: 0000000000000001 R12: ffff8ed63396a078
heisenberg kernel: R13: ffff8ed092d7c800 R14: ffff8ed64f5db028 R15: ffff8ed6bd03d068
heisenberg kernel: FS: 0000000000000000(0000) GS:ffff8ed6bda00000(0000) knlGS:0000000000000000
heisenberg kernel: CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
heisenberg kernel: CR2: 00007f46f75f8000 CR3: 0000000310a0a002 CR4: 00000000003606f0
heisenberg kernel: DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
heisenberg kernel: DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
heisenberg kernel: Call Trace:
heisenberg kernel: commit_fs_roots+0x166/0x1d0 [btrfs]
heisenberg kernel: ? _cond_resched+0x15/0x30
heisenberg kernel: ? btrfs_run_delayed_refs+0xac/0x180 [btrfs]
heisenberg kernel: btrfs_commit_transaction+0x2bd/0x870 [btrfs]
heisenberg kernel: ? start_transaction+0x9d/0x3f0 [btrfs]
heisenberg kernel: transaction_kthread+0x147/0x180 [btrfs]
heisenberg kernel: ? btrfs_cleanup_transaction+0x530/0x530 [btrfs]
heisenberg kernel: kthread+0x112/0x130
heisenberg kernel: ? kthread_bind+0x30/0x30
heisenberg kernel: ret_from_fork+0x35/0x40
heisenberg kernel: ---[ end trace 05de912e30e012d9 ]---
Since fiemap (and btrfs_check_shared()) is a read-only operation, do not do
a transaction join to avoid the overhead of creating a new transaction (if
there is currently no running transaction) and introducing a potential
point of failure when the new transaction gets committed, instead use a
transaction attach to grab a handle for the currently running transaction
if any.
Reported-by: Christoph Anton Mitterer <calestyo@scientia.net>
Link: https://lore.kernel.org/linux-btrfs/b2a668d7124f1d3e410367f587926f622b3f03a4.camel@scientia.net/
Fixes: afce772e87c36c ("btrfs: fix check_shared for fiemap ioctl")
CC: stable@vger.kernel.org # 4.14+
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-04-15 16:50:51 +03:00
|
|
|
if (PTR_ERR(trans) != -ENOENT && PTR_ERR(trans) != -EROFS) {
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
goto out;
|
|
|
|
}
|
2017-06-29 06:56:58 +03:00
|
|
|
trans = NULL;
|
2014-09-11 00:20:45 +04:00
|
|
|
down_read(&fs_info->commit_root_sem);
|
2017-06-29 06:56:58 +03:00
|
|
|
} else {
|
|
|
|
btrfs_get_tree_mod_seq(fs_info, &elem);
|
|
|
|
}
|
|
|
|
|
2014-09-11 00:20:45 +04:00
|
|
|
ULIST_ITER_INIT(&uiter);
|
|
|
|
while (1) {
|
|
|
|
ret = find_parent_nodes(trans, fs_info, bytenr, elem.seq, tmp,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
roots, NULL, &shared, false);
|
2014-09-11 00:20:45 +04:00
|
|
|
if (ret == BACKREF_FOUND_SHARED) {
|
2015-05-19 22:49:50 +03:00
|
|
|
/* this is the only condition under which we return 1 */
|
2014-09-11 00:20:45 +04:00
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ret < 0 && ret != -ENOENT)
|
|
|
|
break;
|
2015-05-19 22:49:50 +03:00
|
|
|
ret = 0;
|
2014-09-11 00:20:45 +04:00
|
|
|
node = ulist_next(tmp, &uiter);
|
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
bytenr = node->val;
|
2018-03-14 18:03:11 +03:00
|
|
|
shared.share_count = 0;
|
2014-09-11 00:20:45 +04:00
|
|
|
cond_resched();
|
|
|
|
}
|
2017-06-29 06:56:58 +03:00
|
|
|
|
|
|
|
if (trans) {
|
2014-09-11 00:20:45 +04:00
|
|
|
btrfs_put_tree_mod_seq(fs_info, &elem);
|
2017-06-29 06:56:58 +03:00
|
|
|
btrfs_end_transaction(trans);
|
|
|
|
} else {
|
2014-09-11 00:20:45 +04:00
|
|
|
up_read(&fs_info->commit_root_sem);
|
2017-06-29 06:56:58 +03:00
|
|
|
}
|
Btrfs: do not start a transaction during fiemap
During fiemap, for regular extents (non inline) we need to check if they
are shared and if they are, set the shared bit. Checking if an extent is
shared requires checking the delayed references of the currently running
transaction, since some reference might have not yet hit the extent tree
and be only in the in-memory delayed references.
However we were using a transaction join for this, which creates a new
transaction when there is no transaction currently running. That means
that two more potential failures can happen: creating the transaction and
committing it. Further, if no write activity is currently happening in the
system, and fiemap calls keep being done, we end up creating and
committing transactions that do nothing.
In some extreme cases this can result in the commit of the transaction
created by fiemap to fail with ENOSPC when updating the root item of a
subvolume tree because a join does not reserve any space, leading to a
trace like the following:
heisenberg kernel: ------------[ cut here ]------------
heisenberg kernel: BTRFS: Transaction aborted (error -28)
heisenberg kernel: WARNING: CPU: 0 PID: 7137 at fs/btrfs/root-tree.c:136 btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: CPU: 0 PID: 7137 Comm: btrfs-transacti Not tainted 4.19.0-4-amd64 #1 Debian 4.19.28-2
heisenberg kernel: Hardware name: FUJITSU LIFEBOOK U757/FJNB2A5, BIOS Version 1.21 03/19/2018
heisenberg kernel: RIP: 0010:btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: RSP: 0018:ffffb5448828bd40 EFLAGS: 00010286
heisenberg kernel: RAX: 0000000000000000 RBX: ffff8ed56bccef50 RCX: 0000000000000006
heisenberg kernel: RDX: 0000000000000007 RSI: 0000000000000092 RDI: ffff8ed6bda166a0
heisenberg kernel: RBP: 00000000ffffffe4 R08: 00000000000003df R09: 0000000000000007
heisenberg kernel: R10: 0000000000000000 R11: 0000000000000001 R12: ffff8ed63396a078
heisenberg kernel: R13: ffff8ed092d7c800 R14: ffff8ed64f5db028 R15: ffff8ed6bd03d068
heisenberg kernel: FS: 0000000000000000(0000) GS:ffff8ed6bda00000(0000) knlGS:0000000000000000
heisenberg kernel: CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
heisenberg kernel: CR2: 00007f46f75f8000 CR3: 0000000310a0a002 CR4: 00000000003606f0
heisenberg kernel: DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
heisenberg kernel: DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
heisenberg kernel: Call Trace:
heisenberg kernel: commit_fs_roots+0x166/0x1d0 [btrfs]
heisenberg kernel: ? _cond_resched+0x15/0x30
heisenberg kernel: ? btrfs_run_delayed_refs+0xac/0x180 [btrfs]
heisenberg kernel: btrfs_commit_transaction+0x2bd/0x870 [btrfs]
heisenberg kernel: ? start_transaction+0x9d/0x3f0 [btrfs]
heisenberg kernel: transaction_kthread+0x147/0x180 [btrfs]
heisenberg kernel: ? btrfs_cleanup_transaction+0x530/0x530 [btrfs]
heisenberg kernel: kthread+0x112/0x130
heisenberg kernel: ? kthread_bind+0x30/0x30
heisenberg kernel: ret_from_fork+0x35/0x40
heisenberg kernel: ---[ end trace 05de912e30e012d9 ]---
Since fiemap (and btrfs_check_shared()) is a read-only operation, do not do
a transaction join to avoid the overhead of creating a new transaction (if
there is currently no running transaction) and introducing a potential
point of failure when the new transaction gets committed, instead use a
transaction attach to grab a handle for the currently running transaction
if any.
Reported-by: Christoph Anton Mitterer <calestyo@scientia.net>
Link: https://lore.kernel.org/linux-btrfs/b2a668d7124f1d3e410367f587926f622b3f03a4.camel@scientia.net/
Fixes: afce772e87c36c ("btrfs: fix check_shared for fiemap ioctl")
CC: stable@vger.kernel.org # 4.14+
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-04-15 16:50:51 +03:00
|
|
|
out:
|
2019-05-15 16:31:04 +03:00
|
|
|
ulist_release(roots);
|
|
|
|
ulist_release(tmp);
|
2014-09-11 00:20:45 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-08 22:32:27 +04:00
|
|
|
int btrfs_find_one_extref(struct btrfs_root *root, u64 inode_objectid,
|
|
|
|
u64 start_off, struct btrfs_path *path,
|
|
|
|
struct btrfs_inode_extref **ret_extref,
|
|
|
|
u64 *found_off)
|
|
|
|
{
|
|
|
|
int ret, slot;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
struct btrfs_inode_extref *extref;
|
2017-06-29 06:56:55 +03:00
|
|
|
const struct extent_buffer *leaf;
|
2012-08-08 22:32:27 +04:00
|
|
|
unsigned long ptr;
|
|
|
|
|
|
|
|
key.objectid = inode_objectid;
|
2014-06-04 20:41:45 +04:00
|
|
|
key.type = BTRFS_INODE_EXTREF_KEY;
|
2012-08-08 22:32:27 +04:00
|
|
|
key.offset = start_off;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
slot = path->slots[0];
|
|
|
|
if (slot >= btrfs_header_nritems(leaf)) {
|
|
|
|
/*
|
|
|
|
* If the item at offset is not found,
|
|
|
|
* btrfs_search_slot will point us to the slot
|
|
|
|
* where it should be inserted. In our case
|
|
|
|
* that will be the slot directly before the
|
|
|
|
* next INODE_REF_KEY_V2 item. In the case
|
|
|
|
* that we're pointing to the last slot in a
|
|
|
|
* leaf, we must move one leaf over.
|
|
|
|
*/
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret) {
|
|
|
|
if (ret >= 1)
|
|
|
|
ret = -ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, slot);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check that we're still looking at an extended ref key for
|
|
|
|
* this particular objectid. If we have different
|
|
|
|
* objectid or type then there are no more to be found
|
|
|
|
* in the tree and we can exit.
|
|
|
|
*/
|
|
|
|
ret = -ENOENT;
|
|
|
|
if (found_key.objectid != inode_objectid)
|
|
|
|
break;
|
2014-06-04 20:41:45 +04:00
|
|
|
if (found_key.type != BTRFS_INODE_EXTREF_KEY)
|
2012-08-08 22:32:27 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
|
|
|
|
extref = (struct btrfs_inode_extref *)ptr;
|
|
|
|
*ret_extref = extref;
|
|
|
|
if (found_off)
|
|
|
|
*found_off = found_key.offset;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-04-26 00:41:01 +04:00
|
|
|
/*
|
|
|
|
* this iterates to turn a name (from iref/extref) into a full filesystem path.
|
|
|
|
* Elements of the path are separated by '/' and the path is guaranteed to be
|
|
|
|
* 0-terminated. the path is only given within the current file system.
|
|
|
|
* Therefore, it never starts with a '/'. the caller is responsible to provide
|
|
|
|
* "size" bytes in "dest". the dest buffer will be filled backwards. finally,
|
|
|
|
* the start point of the resulting string is returned. this pointer is within
|
|
|
|
* dest, normally.
|
|
|
|
* in case the path buffer would overflow, the pointer is decremented further
|
|
|
|
* as if output was written to the buffer, though no more output is actually
|
|
|
|
* generated. that way, the caller can determine how much space would be
|
|
|
|
* required for the path to fit into the buffer. in that case, the returned
|
|
|
|
* value will be smaller than dest. callers must check this!
|
|
|
|
*/
|
2012-10-15 12:30:45 +04:00
|
|
|
char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
|
|
|
|
u32 name_len, unsigned long name_off,
|
|
|
|
struct extent_buffer *eb_in, u64 parent,
|
|
|
|
char *dest, u32 size)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
|
|
|
int slot;
|
|
|
|
u64 next_inum;
|
|
|
|
int ret;
|
2012-10-10 18:50:47 +04:00
|
|
|
s64 bytes_left = ((s64)size) - 1;
|
2011-06-13 21:52:59 +04:00
|
|
|
struct extent_buffer *eb = eb_in;
|
|
|
|
struct btrfs_key found_key;
|
2012-08-08 22:33:54 +04:00
|
|
|
struct btrfs_inode_ref *iref;
|
2011-06-13 21:52:59 +04:00
|
|
|
|
|
|
|
if (bytes_left >= 0)
|
|
|
|
dest[bytes_left] = '\0';
|
|
|
|
|
|
|
|
while (1) {
|
2012-08-08 22:33:54 +04:00
|
|
|
bytes_left -= name_len;
|
2011-06-13 21:52:59 +04:00
|
|
|
if (bytes_left >= 0)
|
|
|
|
read_extent_buffer(eb, dest + bytes_left,
|
2012-08-08 22:33:54 +04:00
|
|
|
name_off, name_len);
|
2012-04-13 14:28:08 +04:00
|
|
|
if (eb != eb_in) {
|
2016-02-03 22:17:27 +03:00
|
|
|
if (!path->skip_locking)
|
2020-08-20 18:46:10 +03:00
|
|
|
btrfs_tree_read_unlock(eb);
|
2011-06-13 21:52:59 +04:00
|
|
|
free_extent_buffer(eb);
|
2012-04-13 14:28:08 +04:00
|
|
|
}
|
2015-01-02 21:03:17 +03:00
|
|
|
ret = btrfs_find_item(fs_root, path, parent, 0,
|
|
|
|
BTRFS_INODE_REF_KEY, &found_key);
|
2012-02-08 19:01:01 +04:00
|
|
|
if (ret > 0)
|
|
|
|
ret = -ENOENT;
|
2011-06-13 21:52:59 +04:00
|
|
|
if (ret)
|
|
|
|
break;
|
2012-08-08 22:33:54 +04:00
|
|
|
|
2011-06-13 21:52:59 +04:00
|
|
|
next_inum = found_key.offset;
|
|
|
|
|
|
|
|
/* regular exit ahead */
|
|
|
|
if (parent == next_inum)
|
|
|
|
break;
|
|
|
|
|
|
|
|
slot = path->slots[0];
|
|
|
|
eb = path->nodes[0];
|
|
|
|
/* make sure we can use eb after releasing the path */
|
2012-04-13 14:28:08 +04:00
|
|
|
if (eb != eb_in) {
|
2016-02-03 22:17:27 +03:00
|
|
|
path->nodes[0] = NULL;
|
|
|
|
path->locks[0] = 0;
|
2012-04-13 14:28:08 +04:00
|
|
|
}
|
2011-06-13 21:52:59 +04:00
|
|
|
btrfs_release_path(path);
|
|
|
|
iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
|
2012-08-08 22:33:54 +04:00
|
|
|
|
|
|
|
name_len = btrfs_inode_ref_name_len(eb, iref);
|
|
|
|
name_off = (unsigned long)(iref + 1);
|
|
|
|
|
2011-06-13 21:52:59 +04:00
|
|
|
parent = next_inum;
|
|
|
|
--bytes_left;
|
|
|
|
if (bytes_left >= 0)
|
|
|
|
dest[bytes_left] = '/';
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
|
|
|
|
return dest + bytes_left;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this makes the path point to (logical EXTENT_ITEM *)
|
|
|
|
* returns BTRFS_EXTENT_FLAG_DATA for data, BTRFS_EXTENT_FLAG_TREE_BLOCK for
|
|
|
|
* tree blocks and <0 on error.
|
|
|
|
*/
|
|
|
|
int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
|
2012-09-08 06:01:28 +04:00
|
|
|
struct btrfs_path *path, struct btrfs_key *found_key,
|
|
|
|
u64 *flags_ret)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u64 flags;
|
2013-06-28 21:11:22 +04:00
|
|
|
u64 size = 0;
|
2011-06-13 21:52:59 +04:00
|
|
|
u32 item_size;
|
2017-06-29 06:56:55 +03:00
|
|
|
const struct extent_buffer *eb;
|
2011-06-13 21:52:59 +04:00
|
|
|
struct btrfs_extent_item *ei;
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
2013-06-28 21:11:22 +04:00
|
|
|
if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))
|
|
|
|
key.type = BTRFS_METADATA_ITEM_KEY;
|
|
|
|
else
|
|
|
|
key.type = BTRFS_EXTENT_ITEM_KEY;
|
2011-06-13 21:52:59 +04:00
|
|
|
key.objectid = logical;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2014-02-06 16:02:29 +04:00
|
|
|
ret = btrfs_previous_extent_item(fs_info->extent_root, path, 0);
|
|
|
|
if (ret) {
|
|
|
|
if (ret > 0)
|
|
|
|
ret = -ENOENT;
|
|
|
|
return ret;
|
2014-01-24 01:03:45 +04:00
|
|
|
}
|
2014-02-06 16:02:29 +04:00
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], found_key, path->slots[0]);
|
2013-06-28 21:11:22 +04:00
|
|
|
if (found_key->type == BTRFS_METADATA_ITEM_KEY)
|
2016-06-15 16:22:56 +03:00
|
|
|
size = fs_info->nodesize;
|
2013-06-28 21:11:22 +04:00
|
|
|
else if (found_key->type == BTRFS_EXTENT_ITEM_KEY)
|
|
|
|
size = found_key->offset;
|
|
|
|
|
2014-01-24 01:03:45 +04:00
|
|
|
if (found_key->objectid > logical ||
|
2013-06-28 21:11:22 +04:00
|
|
|
found_key->objectid + size <= logical) {
|
2016-09-20 17:05:02 +03:00
|
|
|
btrfs_debug(fs_info,
|
|
|
|
"logical %llu is not within any extent", logical);
|
2011-06-13 21:52:59 +04:00
|
|
|
return -ENOENT;
|
2011-12-02 17:56:41 +04:00
|
|
|
}
|
2011-06-13 21:52:59 +04:00
|
|
|
|
|
|
|
eb = path->nodes[0];
|
|
|
|
item_size = btrfs_item_size_nr(eb, path->slots[0]);
|
|
|
|
BUG_ON(item_size < sizeof(*ei));
|
|
|
|
|
|
|
|
ei = btrfs_item_ptr(eb, path->slots[0], struct btrfs_extent_item);
|
|
|
|
flags = btrfs_extent_flags(eb, ei);
|
|
|
|
|
2016-09-20 17:05:02 +03:00
|
|
|
btrfs_debug(fs_info,
|
|
|
|
"logical %llu is at position %llu within the extent (%llu EXTENT_ITEM %llu) flags %#llx size %u",
|
2013-08-20 15:20:07 +04:00
|
|
|
logical, logical - found_key->objectid, found_key->objectid,
|
|
|
|
found_key->offset, flags, item_size);
|
2012-09-08 06:01:28 +04:00
|
|
|
|
|
|
|
WARN_ON(!flags_ret);
|
|
|
|
if (flags_ret) {
|
|
|
|
if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
|
|
|
|
*flags_ret = BTRFS_EXTENT_FLAG_TREE_BLOCK;
|
|
|
|
else if (flags & BTRFS_EXTENT_FLAG_DATA)
|
|
|
|
*flags_ret = BTRFS_EXTENT_FLAG_DATA;
|
|
|
|
else
|
btrfs: use BUG() instead of BUG_ON(1)
BUG_ON(1) leads to bogus warnings from clang when
CONFIG_PROFILE_ANNOTATED_BRANCHES is set:
fs/btrfs/volumes.c:5041:3: error: variable 'max_chunk_size' is used uninitialized whenever 'if' condition is false
[-Werror,-Wsometimes-uninitialized]
BUG_ON(1);
^~~~~~~~~
include/asm-generic/bug.h:61:36: note: expanded from macro 'BUG_ON'
#define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while (0)
^~~~~~~~~~~~~~~~~~~
include/linux/compiler.h:48:23: note: expanded from macro 'unlikely'
# define unlikely(x) (__branch_check__(x, 0, __builtin_constant_p(x)))
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/btrfs/volumes.c:5046:9: note: uninitialized use occurs here
max_chunk_size);
^~~~~~~~~~~~~~
include/linux/kernel.h:860:36: note: expanded from macro 'min'
#define min(x, y) __careful_cmp(x, y, <)
^
include/linux/kernel.h:853:17: note: expanded from macro '__careful_cmp'
__cmp_once(x, y, __UNIQUE_ID(__x), __UNIQUE_ID(__y), op))
^
include/linux/kernel.h:847:25: note: expanded from macro '__cmp_once'
typeof(y) unique_y = (y); \
^
fs/btrfs/volumes.c:5041:3: note: remove the 'if' if its condition is always true
BUG_ON(1);
^
include/asm-generic/bug.h:61:32: note: expanded from macro 'BUG_ON'
#define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while (0)
^
fs/btrfs/volumes.c:4993:20: note: initialize the variable 'max_chunk_size' to silence this warning
u64 max_chunk_size;
^
= 0
Change it to BUG() so clang can see that this code path can never
continue.
Reviewed-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-03-25 16:02:25 +03:00
|
|
|
BUG();
|
2012-09-08 06:01:28 +04:00
|
|
|
return 0;
|
|
|
|
}
|
2011-06-13 21:52:59 +04:00
|
|
|
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to iterate extent inline refs. ptr must point to a 0 value
|
|
|
|
* for the first call and may be modified. it is used to track state.
|
|
|
|
* if more refs exist, 0 is returned and the next call to
|
2017-06-29 06:56:57 +03:00
|
|
|
* get_extent_inline_ref must pass the modified ptr parameter to get the
|
2011-06-13 21:52:59 +04:00
|
|
|
* next ref. after the last ref was processed, 1 is returned.
|
|
|
|
* returns <0 on error
|
|
|
|
*/
|
2017-06-29 06:56:57 +03:00
|
|
|
static int get_extent_inline_ref(unsigned long *ptr,
|
|
|
|
const struct extent_buffer *eb,
|
|
|
|
const struct btrfs_key *key,
|
|
|
|
const struct btrfs_extent_item *ei,
|
|
|
|
u32 item_size,
|
|
|
|
struct btrfs_extent_inline_ref **out_eiref,
|
|
|
|
int *out_type)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
|
|
|
unsigned long end;
|
|
|
|
u64 flags;
|
|
|
|
struct btrfs_tree_block_info *info;
|
|
|
|
|
|
|
|
if (!*ptr) {
|
|
|
|
/* first call */
|
|
|
|
flags = btrfs_extent_flags(eb, ei);
|
|
|
|
if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
|
2014-06-09 06:54:07 +04:00
|
|
|
if (key->type == BTRFS_METADATA_ITEM_KEY) {
|
|
|
|
/* a skinny metadata extent */
|
|
|
|
*out_eiref =
|
|
|
|
(struct btrfs_extent_inline_ref *)(ei + 1);
|
|
|
|
} else {
|
|
|
|
WARN_ON(key->type != BTRFS_EXTENT_ITEM_KEY);
|
|
|
|
info = (struct btrfs_tree_block_info *)(ei + 1);
|
|
|
|
*out_eiref =
|
|
|
|
(struct btrfs_extent_inline_ref *)(info + 1);
|
|
|
|
}
|
2011-06-13 21:52:59 +04:00
|
|
|
} else {
|
|
|
|
*out_eiref = (struct btrfs_extent_inline_ref *)(ei + 1);
|
|
|
|
}
|
|
|
|
*ptr = (unsigned long)*out_eiref;
|
2014-06-08 15:04:13 +04:00
|
|
|
if ((unsigned long)(*ptr) >= (unsigned long)ei + item_size)
|
2011-06-13 21:52:59 +04:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
end = (unsigned long)ei + item_size;
|
2014-06-09 06:54:07 +04:00
|
|
|
*out_eiref = (struct btrfs_extent_inline_ref *)(*ptr);
|
2017-08-19 00:15:19 +03:00
|
|
|
*out_type = btrfs_get_extent_inline_ref_type(eb, *out_eiref,
|
|
|
|
BTRFS_REF_TYPE_ANY);
|
|
|
|
if (*out_type == BTRFS_REF_TYPE_INVALID)
|
2018-06-22 11:18:01 +03:00
|
|
|
return -EUCLEAN;
|
2011-06-13 21:52:59 +04:00
|
|
|
|
|
|
|
*ptr += btrfs_extent_inline_ref_size(*out_type);
|
|
|
|
WARN_ON(*ptr > end);
|
|
|
|
if (*ptr == end)
|
|
|
|
return 1; /* last */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* reads the tree block backref for an extent. tree level and root are returned
|
|
|
|
* through out_level and out_root. ptr must point to a 0 value for the first
|
2017-06-29 06:56:57 +03:00
|
|
|
* call and may be modified (see get_extent_inline_ref comment).
|
2011-06-13 21:52:59 +04:00
|
|
|
* returns 0 if data was provided, 1 if there was no more data to provide or
|
|
|
|
* <0 on error.
|
|
|
|
*/
|
|
|
|
int tree_backref_for_extent(unsigned long *ptr, struct extent_buffer *eb,
|
2014-06-09 06:54:07 +04:00
|
|
|
struct btrfs_key *key, struct btrfs_extent_item *ei,
|
|
|
|
u32 item_size, u64 *out_root, u8 *out_level)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int type;
|
|
|
|
struct btrfs_extent_inline_ref *eiref;
|
|
|
|
|
|
|
|
if (*ptr == (unsigned long)-1)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
while (1) {
|
2017-06-29 06:56:57 +03:00
|
|
|
ret = get_extent_inline_ref(ptr, eb, key, ei, item_size,
|
2014-06-09 06:54:07 +04:00
|
|
|
&eiref, &type);
|
2011-06-13 21:52:59 +04:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (type == BTRFS_TREE_BLOCK_REF_KEY ||
|
|
|
|
type == BTRFS_SHARED_BLOCK_REF_KEY)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (ret == 1)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we can treat both ref types equally here */
|
|
|
|
*out_root = btrfs_extent_inline_ref_offset(eb, eiref);
|
2014-12-15 19:04:42 +03:00
|
|
|
|
|
|
|
if (key->type == BTRFS_EXTENT_ITEM_KEY) {
|
|
|
|
struct btrfs_tree_block_info *info;
|
|
|
|
|
|
|
|
info = (struct btrfs_tree_block_info *)(ei + 1);
|
|
|
|
*out_level = btrfs_tree_block_level(eb, info);
|
|
|
|
} else {
|
|
|
|
ASSERT(key->type == BTRFS_METADATA_ITEM_KEY);
|
|
|
|
*out_level = (u8)key->offset;
|
|
|
|
}
|
2011-06-13 21:52:59 +04:00
|
|
|
|
|
|
|
if (ret == 1)
|
|
|
|
*ptr = (unsigned long)-1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-20 17:05:02 +03:00
|
|
|
static int iterate_leaf_refs(struct btrfs_fs_info *fs_info,
|
|
|
|
struct extent_inode_elem *inode_list,
|
|
|
|
u64 root, u64 extent_item_objectid,
|
|
|
|
iterate_extent_inodes_t *iterate, void *ctx)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
2012-05-17 18:43:03 +04:00
|
|
|
struct extent_inode_elem *eie;
|
2011-12-02 17:56:41 +04:00
|
|
|
int ret = 0;
|
|
|
|
|
2012-05-17 18:43:03 +04:00
|
|
|
for (eie = inode_list; eie; eie = eie->next) {
|
2016-09-20 17:05:02 +03:00
|
|
|
btrfs_debug(fs_info,
|
|
|
|
"ref for %llu resolved, key (%llu EXTEND_DATA %llu), root %llu",
|
|
|
|
extent_item_objectid, eie->inum,
|
|
|
|
eie->offset, root);
|
2012-05-17 18:43:03 +04:00
|
|
|
ret = iterate(eie->inum, eie->offset, root, ctx);
|
2011-12-02 17:56:41 +04:00
|
|
|
if (ret) {
|
2016-09-20 17:05:02 +03:00
|
|
|
btrfs_debug(fs_info,
|
|
|
|
"stopping iteration for %llu due to ret=%d",
|
|
|
|
extent_item_objectid, ret);
|
2011-12-02 17:56:41 +04:00
|
|
|
break;
|
|
|
|
}
|
2011-06-13 21:52:59 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* calls iterate() for every inode that references the extent identified by
|
2011-12-02 17:56:41 +04:00
|
|
|
* the given parameters.
|
2011-06-13 21:52:59 +04:00
|
|
|
* when the iterator function returns a non-zero value, iteration stops.
|
|
|
|
*/
|
|
|
|
int iterate_extent_inodes(struct btrfs_fs_info *fs_info,
|
2011-12-02 17:56:41 +04:00
|
|
|
u64 extent_item_objectid, u64 extent_item_pos,
|
2012-03-23 20:32:28 +04:00
|
|
|
int search_commit_root,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
iterate_extent_inodes_t *iterate, void *ctx,
|
|
|
|
bool ignore_offset)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
|
|
|
int ret;
|
2013-06-13 00:20:08 +04:00
|
|
|
struct btrfs_trans_handle *trans = NULL;
|
2012-03-23 20:32:28 +04:00
|
|
|
struct ulist *refs = NULL;
|
|
|
|
struct ulist *roots = NULL;
|
2011-12-02 17:56:41 +04:00
|
|
|
struct ulist_node *ref_node = NULL;
|
|
|
|
struct ulist_node *root_node = NULL;
|
2021-03-11 17:31:07 +03:00
|
|
|
struct btrfs_seq_list seq_elem = BTRFS_SEQ_LIST_INIT(seq_elem);
|
2012-05-22 16:56:50 +04:00
|
|
|
struct ulist_iterator ref_uiter;
|
|
|
|
struct ulist_iterator root_uiter;
|
2011-06-13 21:52:59 +04:00
|
|
|
|
2016-09-20 17:05:02 +03:00
|
|
|
btrfs_debug(fs_info, "resolving all inodes for extent %llu",
|
2011-12-02 17:56:41 +04:00
|
|
|
extent_item_objectid);
|
2011-06-13 21:52:59 +04:00
|
|
|
|
2013-06-13 00:20:08 +04:00
|
|
|
if (!search_commit_root) {
|
Btrfs: do not start a transaction at iterate_extent_inodes()
When finding out which inodes have references on a particular extent, done
by backref.c:iterate_extent_inodes(), from the BTRFS_IOC_LOGICAL_INO (both
v1 and v2) ioctl and from scrub we use the transaction join API to grab a
reference on the currently running transaction, since in order to give
accurate results we need to inspect the delayed references of the currently
running transaction.
However, if there is currently no running transaction, the join operation
will create a new transaction. This is inefficient as the transaction will
eventually be committed, doing unnecessary IO and introducing a potential
point of failure that will lead to a transaction abort due to -ENOSPC, as
recently reported [1].
That's because the join, creates the transaction but does not reserve any
space, so when attempting to update the root item of the root passed to
btrfs_join_transaction(), during the transaction commit, we can end up
failling with -ENOSPC. Users of a join operation are supposed to actually
do some filesystem changes and reserve space by some means, which is not
the case of iterate_extent_inodes(), it is a read-only operation for all
contextes from which it is called.
The reported [1] -ENOSPC failure stack trace is the following:
heisenberg kernel: ------------[ cut here ]------------
heisenberg kernel: BTRFS: Transaction aborted (error -28)
heisenberg kernel: WARNING: CPU: 0 PID: 7137 at fs/btrfs/root-tree.c:136 btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: CPU: 0 PID: 7137 Comm: btrfs-transacti Not tainted 4.19.0-4-amd64 #1 Debian 4.19.28-2
heisenberg kernel: Hardware name: FUJITSU LIFEBOOK U757/FJNB2A5, BIOS Version 1.21 03/19/2018
heisenberg kernel: RIP: 0010:btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: RSP: 0018:ffffb5448828bd40 EFLAGS: 00010286
heisenberg kernel: RAX: 0000000000000000 RBX: ffff8ed56bccef50 RCX: 0000000000000006
heisenberg kernel: RDX: 0000000000000007 RSI: 0000000000000092 RDI: ffff8ed6bda166a0
heisenberg kernel: RBP: 00000000ffffffe4 R08: 00000000000003df R09: 0000000000000007
heisenberg kernel: R10: 0000000000000000 R11: 0000000000000001 R12: ffff8ed63396a078
heisenberg kernel: R13: ffff8ed092d7c800 R14: ffff8ed64f5db028 R15: ffff8ed6bd03d068
heisenberg kernel: FS: 0000000000000000(0000) GS:ffff8ed6bda00000(0000) knlGS:0000000000000000
heisenberg kernel: CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
heisenberg kernel: CR2: 00007f46f75f8000 CR3: 0000000310a0a002 CR4: 00000000003606f0
heisenberg kernel: DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
heisenberg kernel: DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
heisenberg kernel: Call Trace:
heisenberg kernel: commit_fs_roots+0x166/0x1d0 [btrfs]
heisenberg kernel: ? _cond_resched+0x15/0x30
heisenberg kernel: ? btrfs_run_delayed_refs+0xac/0x180 [btrfs]
heisenberg kernel: btrfs_commit_transaction+0x2bd/0x870 [btrfs]
heisenberg kernel: ? start_transaction+0x9d/0x3f0 [btrfs]
heisenberg kernel: transaction_kthread+0x147/0x180 [btrfs]
heisenberg kernel: ? btrfs_cleanup_transaction+0x530/0x530 [btrfs]
heisenberg kernel: kthread+0x112/0x130
heisenberg kernel: ? kthread_bind+0x30/0x30
heisenberg kernel: ret_from_fork+0x35/0x40
heisenberg kernel: ---[ end trace 05de912e30e012d9 ]---
So fix that by using the attach API, which does not create a transaction
when there is currently no running transaction.
[1] https://lore.kernel.org/linux-btrfs/b2a668d7124f1d3e410367f587926f622b3f03a4.camel@scientia.net/
Reported-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
CC: stable@vger.kernel.org # 4.4+
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-04-17 13:30:30 +03:00
|
|
|
trans = btrfs_attach_transaction(fs_info->extent_root);
|
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
if (PTR_ERR(trans) != -ENOENT &&
|
|
|
|
PTR_ERR(trans) != -EROFS)
|
|
|
|
return PTR_ERR(trans);
|
|
|
|
trans = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (trans)
|
2021-03-11 17:31:07 +03:00
|
|
|
btrfs_get_tree_mod_seq(fs_info, &seq_elem);
|
Btrfs: do not start a transaction at iterate_extent_inodes()
When finding out which inodes have references on a particular extent, done
by backref.c:iterate_extent_inodes(), from the BTRFS_IOC_LOGICAL_INO (both
v1 and v2) ioctl and from scrub we use the transaction join API to grab a
reference on the currently running transaction, since in order to give
accurate results we need to inspect the delayed references of the currently
running transaction.
However, if there is currently no running transaction, the join operation
will create a new transaction. This is inefficient as the transaction will
eventually be committed, doing unnecessary IO and introducing a potential
point of failure that will lead to a transaction abort due to -ENOSPC, as
recently reported [1].
That's because the join, creates the transaction but does not reserve any
space, so when attempting to update the root item of the root passed to
btrfs_join_transaction(), during the transaction commit, we can end up
failling with -ENOSPC. Users of a join operation are supposed to actually
do some filesystem changes and reserve space by some means, which is not
the case of iterate_extent_inodes(), it is a read-only operation for all
contextes from which it is called.
The reported [1] -ENOSPC failure stack trace is the following:
heisenberg kernel: ------------[ cut here ]------------
heisenberg kernel: BTRFS: Transaction aborted (error -28)
heisenberg kernel: WARNING: CPU: 0 PID: 7137 at fs/btrfs/root-tree.c:136 btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: CPU: 0 PID: 7137 Comm: btrfs-transacti Not tainted 4.19.0-4-amd64 #1 Debian 4.19.28-2
heisenberg kernel: Hardware name: FUJITSU LIFEBOOK U757/FJNB2A5, BIOS Version 1.21 03/19/2018
heisenberg kernel: RIP: 0010:btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: RSP: 0018:ffffb5448828bd40 EFLAGS: 00010286
heisenberg kernel: RAX: 0000000000000000 RBX: ffff8ed56bccef50 RCX: 0000000000000006
heisenberg kernel: RDX: 0000000000000007 RSI: 0000000000000092 RDI: ffff8ed6bda166a0
heisenberg kernel: RBP: 00000000ffffffe4 R08: 00000000000003df R09: 0000000000000007
heisenberg kernel: R10: 0000000000000000 R11: 0000000000000001 R12: ffff8ed63396a078
heisenberg kernel: R13: ffff8ed092d7c800 R14: ffff8ed64f5db028 R15: ffff8ed6bd03d068
heisenberg kernel: FS: 0000000000000000(0000) GS:ffff8ed6bda00000(0000) knlGS:0000000000000000
heisenberg kernel: CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
heisenberg kernel: CR2: 00007f46f75f8000 CR3: 0000000310a0a002 CR4: 00000000003606f0
heisenberg kernel: DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
heisenberg kernel: DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
heisenberg kernel: Call Trace:
heisenberg kernel: commit_fs_roots+0x166/0x1d0 [btrfs]
heisenberg kernel: ? _cond_resched+0x15/0x30
heisenberg kernel: ? btrfs_run_delayed_refs+0xac/0x180 [btrfs]
heisenberg kernel: btrfs_commit_transaction+0x2bd/0x870 [btrfs]
heisenberg kernel: ? start_transaction+0x9d/0x3f0 [btrfs]
heisenberg kernel: transaction_kthread+0x147/0x180 [btrfs]
heisenberg kernel: ? btrfs_cleanup_transaction+0x530/0x530 [btrfs]
heisenberg kernel: kthread+0x112/0x130
heisenberg kernel: ? kthread_bind+0x30/0x30
heisenberg kernel: ret_from_fork+0x35/0x40
heisenberg kernel: ---[ end trace 05de912e30e012d9 ]---
So fix that by using the attach API, which does not create a transaction
when there is currently no running transaction.
[1] https://lore.kernel.org/linux-btrfs/b2a668d7124f1d3e410367f587926f622b3f03a4.camel@scientia.net/
Reported-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
CC: stable@vger.kernel.org # 4.4+
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-04-17 13:30:30 +03:00
|
|
|
else
|
2014-03-13 23:42:13 +04:00
|
|
|
down_read(&fs_info->commit_root_sem);
|
2011-06-13 21:52:59 +04:00
|
|
|
|
2011-12-02 17:56:41 +04:00
|
|
|
ret = btrfs_find_all_leafs(trans, fs_info, extent_item_objectid,
|
2021-03-11 17:31:07 +03:00
|
|
|
seq_elem.seq, &refs,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
&extent_item_pos, ignore_offset);
|
2011-12-02 17:56:41 +04:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2011-06-13 21:52:59 +04:00
|
|
|
|
2012-05-22 16:56:50 +04:00
|
|
|
ULIST_ITER_INIT(&ref_uiter);
|
|
|
|
while (!ret && (ref_node = ulist_next(refs, &ref_uiter))) {
|
2017-06-29 06:56:57 +03:00
|
|
|
ret = btrfs_find_all_roots_safe(trans, fs_info, ref_node->val,
|
2021-03-11 17:31:07 +03:00
|
|
|
seq_elem.seq, &roots,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
ignore_offset);
|
2011-12-02 17:56:41 +04:00
|
|
|
if (ret)
|
|
|
|
break;
|
2012-05-22 16:56:50 +04:00
|
|
|
ULIST_ITER_INIT(&root_uiter);
|
|
|
|
while (!ret && (root_node = ulist_next(roots, &root_uiter))) {
|
2016-09-20 17:05:02 +03:00
|
|
|
btrfs_debug(fs_info,
|
|
|
|
"root %llu references leaf %llu, data list %#llx",
|
|
|
|
root_node->val, ref_node->val,
|
|
|
|
ref_node->aux);
|
|
|
|
ret = iterate_leaf_refs(fs_info,
|
|
|
|
(struct extent_inode_elem *)
|
2012-08-13 12:52:38 +04:00
|
|
|
(uintptr_t)ref_node->aux,
|
|
|
|
root_node->val,
|
|
|
|
extent_item_objectid,
|
|
|
|
iterate, ctx);
|
2011-12-02 17:56:41 +04:00
|
|
|
}
|
2012-05-17 18:43:03 +04:00
|
|
|
ulist_free(roots);
|
2011-06-13 21:52:59 +04:00
|
|
|
}
|
|
|
|
|
2012-05-17 18:43:03 +04:00
|
|
|
free_leaf_list(refs);
|
2011-12-02 17:56:41 +04:00
|
|
|
out:
|
Btrfs: do not start a transaction at iterate_extent_inodes()
When finding out which inodes have references on a particular extent, done
by backref.c:iterate_extent_inodes(), from the BTRFS_IOC_LOGICAL_INO (both
v1 and v2) ioctl and from scrub we use the transaction join API to grab a
reference on the currently running transaction, since in order to give
accurate results we need to inspect the delayed references of the currently
running transaction.
However, if there is currently no running transaction, the join operation
will create a new transaction. This is inefficient as the transaction will
eventually be committed, doing unnecessary IO and introducing a potential
point of failure that will lead to a transaction abort due to -ENOSPC, as
recently reported [1].
That's because the join, creates the transaction but does not reserve any
space, so when attempting to update the root item of the root passed to
btrfs_join_transaction(), during the transaction commit, we can end up
failling with -ENOSPC. Users of a join operation are supposed to actually
do some filesystem changes and reserve space by some means, which is not
the case of iterate_extent_inodes(), it is a read-only operation for all
contextes from which it is called.
The reported [1] -ENOSPC failure stack trace is the following:
heisenberg kernel: ------------[ cut here ]------------
heisenberg kernel: BTRFS: Transaction aborted (error -28)
heisenberg kernel: WARNING: CPU: 0 PID: 7137 at fs/btrfs/root-tree.c:136 btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: CPU: 0 PID: 7137 Comm: btrfs-transacti Not tainted 4.19.0-4-amd64 #1 Debian 4.19.28-2
heisenberg kernel: Hardware name: FUJITSU LIFEBOOK U757/FJNB2A5, BIOS Version 1.21 03/19/2018
heisenberg kernel: RIP: 0010:btrfs_update_root+0x22b/0x320 [btrfs]
(...)
heisenberg kernel: RSP: 0018:ffffb5448828bd40 EFLAGS: 00010286
heisenberg kernel: RAX: 0000000000000000 RBX: ffff8ed56bccef50 RCX: 0000000000000006
heisenberg kernel: RDX: 0000000000000007 RSI: 0000000000000092 RDI: ffff8ed6bda166a0
heisenberg kernel: RBP: 00000000ffffffe4 R08: 00000000000003df R09: 0000000000000007
heisenberg kernel: R10: 0000000000000000 R11: 0000000000000001 R12: ffff8ed63396a078
heisenberg kernel: R13: ffff8ed092d7c800 R14: ffff8ed64f5db028 R15: ffff8ed6bd03d068
heisenberg kernel: FS: 0000000000000000(0000) GS:ffff8ed6bda00000(0000) knlGS:0000000000000000
heisenberg kernel: CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
heisenberg kernel: CR2: 00007f46f75f8000 CR3: 0000000310a0a002 CR4: 00000000003606f0
heisenberg kernel: DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
heisenberg kernel: DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
heisenberg kernel: Call Trace:
heisenberg kernel: commit_fs_roots+0x166/0x1d0 [btrfs]
heisenberg kernel: ? _cond_resched+0x15/0x30
heisenberg kernel: ? btrfs_run_delayed_refs+0xac/0x180 [btrfs]
heisenberg kernel: btrfs_commit_transaction+0x2bd/0x870 [btrfs]
heisenberg kernel: ? start_transaction+0x9d/0x3f0 [btrfs]
heisenberg kernel: transaction_kthread+0x147/0x180 [btrfs]
heisenberg kernel: ? btrfs_cleanup_transaction+0x530/0x530 [btrfs]
heisenberg kernel: kthread+0x112/0x130
heisenberg kernel: ? kthread_bind+0x30/0x30
heisenberg kernel: ret_from_fork+0x35/0x40
heisenberg kernel: ---[ end trace 05de912e30e012d9 ]---
So fix that by using the attach API, which does not create a transaction
when there is currently no running transaction.
[1] https://lore.kernel.org/linux-btrfs/b2a668d7124f1d3e410367f587926f622b3f03a4.camel@scientia.net/
Reported-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
CC: stable@vger.kernel.org # 4.4+
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-04-17 13:30:30 +03:00
|
|
|
if (trans) {
|
2021-03-11 17:31:07 +03:00
|
|
|
btrfs_put_tree_mod_seq(fs_info, &seq_elem);
|
2016-09-10 04:39:03 +03:00
|
|
|
btrfs_end_transaction(trans);
|
2014-03-13 23:42:13 +04:00
|
|
|
} else {
|
|
|
|
up_read(&fs_info->commit_root_sem);
|
2012-03-23 20:32:28 +04:00
|
|
|
}
|
|
|
|
|
2011-06-13 21:52:59 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_path *path,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
iterate_extent_inodes_t *iterate, void *ctx,
|
|
|
|
bool ignore_offset)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
|
|
|
int ret;
|
2011-12-02 17:56:41 +04:00
|
|
|
u64 extent_item_pos;
|
2012-09-08 06:01:28 +04:00
|
|
|
u64 flags = 0;
|
2011-06-13 21:52:59 +04:00
|
|
|
struct btrfs_key found_key;
|
2012-03-23 20:32:28 +04:00
|
|
|
int search_commit_root = path->search_commit_root;
|
2011-06-13 21:52:59 +04:00
|
|
|
|
2012-09-08 06:01:28 +04:00
|
|
|
ret = extent_from_logical(fs_info, logical, path, &found_key, &flags);
|
2011-12-02 17:56:41 +04:00
|
|
|
btrfs_release_path(path);
|
2011-06-13 21:52:59 +04:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2012-09-08 06:01:28 +04:00
|
|
|
if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
|
2012-08-01 14:28:01 +04:00
|
|
|
return -EINVAL;
|
2011-06-13 21:52:59 +04:00
|
|
|
|
2011-12-02 17:56:41 +04:00
|
|
|
extent_item_pos = logical - found_key.objectid;
|
2012-03-23 20:32:28 +04:00
|
|
|
ret = iterate_extent_inodes(fs_info, found_key.objectid,
|
|
|
|
extent_item_pos, search_commit_root,
|
btrfs: add a flag to iterate_inodes_from_logical to find all extent refs for uncompressed extents
The LOGICAL_INO ioctl provides a backward mapping from extent bytenr and
offset (encoded as a single logical address) to a list of extent refs.
LOGICAL_INO complements TREE_SEARCH, which provides the forward mapping
(extent ref -> extent bytenr and offset, or logical address). These are
useful capabilities for programs that manipulate extents and extent
references from userspace (e.g. dedup and defrag utilities).
When the extents are uncompressed (and not encrypted and not other),
check_extent_in_eb performs filtering of the extent refs to remove any
extent refs which do not contain the same extent offset as the 'logical'
parameter's extent offset. This prevents LOGICAL_INO from returning
references to more than a single block.
To find the set of extent references to an uncompressed extent from [a, b),
userspace has to run a loop like this pseudocode:
for (i = a; i < b; ++i)
extent_ref_set += LOGICAL_INO(i);
At each iteration of the loop (up to 32768 iterations for a 128M extent),
data we are interested in is collected in the kernel, then deleted by
the filter in check_extent_in_eb.
When the extents are compressed (or encrypted or other), the 'logical'
parameter must be an extent bytenr (the 'a' parameter in the loop).
No filtering by extent offset is done (or possible?) so the result is
the complete set of extent refs for the entire extent. This removes
the need for the loop, since we get all the extent refs in one call.
Add an 'ignore_offset' argument to iterate_inodes_from_logical,
[...several levels of function call graph...], and check_extent_in_eb, so
that we can disable the extent offset filtering for uncompressed extents.
This flag can be set by an improved version of the LOGICAL_INO ioctl to
get either behavior as desired.
There is no functional change in this patch. The new flag is always
false.
Signed-off-by: Zygo Blaxell <ce3g8jdj@umail.furryterror.org>
Reviewed-by: David Sterba <dsterba@suse.com>
[ minor coding style fixes ]
Signed-off-by: David Sterba <dsterba@suse.com>
2017-09-22 20:58:45 +03:00
|
|
|
iterate, ctx, ignore_offset);
|
2011-06-13 21:52:59 +04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-08 22:33:54 +04:00
|
|
|
typedef int (iterate_irefs_t)(u64 parent, u32 name_len, unsigned long name_off,
|
|
|
|
struct extent_buffer *eb, void *ctx);
|
|
|
|
|
|
|
|
static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
iterate_irefs_t *iterate, void *ctx)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
2012-04-13 14:28:00 +04:00
|
|
|
int ret = 0;
|
2011-06-13 21:52:59 +04:00
|
|
|
int slot;
|
|
|
|
u32 cur;
|
|
|
|
u32 len;
|
|
|
|
u32 name_len;
|
|
|
|
u64 parent = 0;
|
|
|
|
int found = 0;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
struct btrfs_item *item;
|
|
|
|
struct btrfs_inode_ref *iref;
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
|
2012-04-13 14:28:00 +04:00
|
|
|
while (!ret) {
|
2015-01-02 21:03:17 +03:00
|
|
|
ret = btrfs_find_item(fs_root, path, inum,
|
|
|
|
parent ? parent + 1 : 0, BTRFS_INODE_REF_KEY,
|
|
|
|
&found_key);
|
|
|
|
|
2011-06-13 21:52:59 +04:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
if (ret) {
|
|
|
|
ret = found ? 0 : -ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++found;
|
|
|
|
|
|
|
|
parent = found_key.offset;
|
|
|
|
slot = path->slots[0];
|
2013-12-15 16:43:58 +04:00
|
|
|
eb = btrfs_clone_extent_buffer(path->nodes[0]);
|
|
|
|
if (!eb) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
2011-06-13 21:52:59 +04:00
|
|
|
btrfs_release_path(path);
|
|
|
|
|
2013-09-16 18:58:09 +04:00
|
|
|
item = btrfs_item_nr(slot);
|
2011-06-13 21:52:59 +04:00
|
|
|
iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
|
|
|
|
|
|
|
|
for (cur = 0; cur < btrfs_item_size(eb, item); cur += len) {
|
|
|
|
name_len = btrfs_inode_ref_name_len(eb, iref);
|
|
|
|
/* path must be released before calling iterate()! */
|
2016-09-20 17:05:02 +03:00
|
|
|
btrfs_debug(fs_root->fs_info,
|
|
|
|
"following ref at offset %u for inode %llu in tree %llu",
|
2018-08-06 08:25:24 +03:00
|
|
|
cur, found_key.objectid,
|
|
|
|
fs_root->root_key.objectid);
|
2012-08-08 22:33:54 +04:00
|
|
|
ret = iterate(parent, name_len,
|
|
|
|
(unsigned long)(iref + 1), eb, ctx);
|
2012-04-13 14:28:00 +04:00
|
|
|
if (ret)
|
2011-06-13 21:52:59 +04:00
|
|
|
break;
|
|
|
|
len = sizeof(*iref) + name_len;
|
|
|
|
iref = (struct btrfs_inode_ref *)((char *)iref + len);
|
|
|
|
}
|
|
|
|
free_extent_buffer(eb);
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-08 22:33:54 +04:00
|
|
|
static int iterate_inode_extrefs(u64 inum, struct btrfs_root *fs_root,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
iterate_irefs_t *iterate, void *ctx)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int slot;
|
|
|
|
u64 offset = 0;
|
|
|
|
u64 parent;
|
|
|
|
int found = 0;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
struct btrfs_inode_extref *extref;
|
|
|
|
u32 item_size;
|
|
|
|
u32 cur_offset;
|
|
|
|
unsigned long ptr;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
ret = btrfs_find_one_extref(fs_root, inum, offset, path, &extref,
|
|
|
|
&offset);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
if (ret) {
|
|
|
|
ret = found ? 0 : -ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++found;
|
|
|
|
|
|
|
|
slot = path->slots[0];
|
2013-12-15 16:43:58 +04:00
|
|
|
eb = btrfs_clone_extent_buffer(path->nodes[0]);
|
|
|
|
if (!eb) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
2012-08-08 22:33:54 +04:00
|
|
|
btrfs_release_path(path);
|
|
|
|
|
2015-10-13 21:06:48 +03:00
|
|
|
item_size = btrfs_item_size_nr(eb, slot);
|
|
|
|
ptr = btrfs_item_ptr_offset(eb, slot);
|
2012-08-08 22:33:54 +04:00
|
|
|
cur_offset = 0;
|
|
|
|
|
|
|
|
while (cur_offset < item_size) {
|
|
|
|
u32 name_len;
|
|
|
|
|
|
|
|
extref = (struct btrfs_inode_extref *)(ptr + cur_offset);
|
|
|
|
parent = btrfs_inode_extref_parent(eb, extref);
|
|
|
|
name_len = btrfs_inode_extref_name_len(eb, extref);
|
|
|
|
ret = iterate(parent, name_len,
|
|
|
|
(unsigned long)&extref->name, eb, ctx);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
|
2015-10-13 21:06:48 +03:00
|
|
|
cur_offset += btrfs_inode_extref_name_len(eb, extref);
|
2012-08-08 22:33:54 +04:00
|
|
|
cur_offset += sizeof(*extref);
|
|
|
|
}
|
|
|
|
free_extent_buffer(eb);
|
|
|
|
|
|
|
|
offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
|
|
|
|
struct btrfs_path *path, iterate_irefs_t *iterate,
|
|
|
|
void *ctx)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int found_refs = 0;
|
|
|
|
|
|
|
|
ret = iterate_inode_refs(inum, fs_root, path, iterate, ctx);
|
|
|
|
if (!ret)
|
|
|
|
++found_refs;
|
|
|
|
else if (ret != -ENOENT)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = iterate_inode_extrefs(inum, fs_root, path, iterate, ctx);
|
|
|
|
if (ret == -ENOENT && found_refs)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-13 21:52:59 +04:00
|
|
|
/*
|
|
|
|
* returns 0 if the path could be dumped (probably truncated)
|
|
|
|
* returns <0 in case of an error
|
|
|
|
*/
|
2012-08-08 22:33:54 +04:00
|
|
|
static int inode_to_path(u64 inum, u32 name_len, unsigned long name_off,
|
|
|
|
struct extent_buffer *eb, void *ctx)
|
2011-06-13 21:52:59 +04:00
|
|
|
{
|
|
|
|
struct inode_fs_paths *ipath = ctx;
|
|
|
|
char *fspath;
|
|
|
|
char *fspath_min;
|
|
|
|
int i = ipath->fspath->elem_cnt;
|
|
|
|
const int s_ptr = sizeof(char *);
|
|
|
|
u32 bytes_left;
|
|
|
|
|
|
|
|
bytes_left = ipath->fspath->bytes_left > s_ptr ?
|
|
|
|
ipath->fspath->bytes_left - s_ptr : 0;
|
|
|
|
|
2011-11-02 23:48:34 +04:00
|
|
|
fspath_min = (char *)ipath->fspath->val + (i + 1) * s_ptr;
|
2012-10-15 12:30:45 +04:00
|
|
|
fspath = btrfs_ref_to_path(ipath->fs_root, ipath->btrfs_path, name_len,
|
|
|
|
name_off, eb, inum, fspath_min, bytes_left);
|
2011-06-13 21:52:59 +04:00
|
|
|
if (IS_ERR(fspath))
|
|
|
|
return PTR_ERR(fspath);
|
|
|
|
|
|
|
|
if (fspath > fspath_min) {
|
2011-11-20 16:31:57 +04:00
|
|
|
ipath->fspath->val[i] = (u64)(unsigned long)fspath;
|
2011-06-13 21:52:59 +04:00
|
|
|
++ipath->fspath->elem_cnt;
|
|
|
|
ipath->fspath->bytes_left = fspath - fspath_min;
|
|
|
|
} else {
|
|
|
|
++ipath->fspath->elem_missed;
|
|
|
|
ipath->fspath->bytes_missing += fspath_min - fspath;
|
|
|
|
ipath->fspath->bytes_left = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this dumps all file system paths to the inode into the ipath struct, provided
|
|
|
|
* is has been created large enough. each path is zero-terminated and accessed
|
2011-11-02 23:48:34 +04:00
|
|
|
* from ipath->fspath->val[i].
|
2011-06-13 21:52:59 +04:00
|
|
|
* when it returns, there are ipath->fspath->elem_cnt number of paths available
|
2011-11-02 23:48:34 +04:00
|
|
|
* in ipath->fspath->val[]. when the allocated space wasn't sufficient, the
|
2016-05-20 04:18:45 +03:00
|
|
|
* number of missed paths is recorded in ipath->fspath->elem_missed, otherwise,
|
2011-06-13 21:52:59 +04:00
|
|
|
* it's zero. ipath->fspath->bytes_missing holds the number of bytes that would
|
|
|
|
* have been needed to return all paths.
|
|
|
|
*/
|
|
|
|
int paths_from_inode(u64 inum, struct inode_fs_paths *ipath)
|
|
|
|
{
|
|
|
|
return iterate_irefs(inum, ipath->fs_root, ipath->btrfs_path,
|
2012-08-08 22:33:54 +04:00
|
|
|
inode_to_path, ipath);
|
2011-06-13 21:52:59 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
struct btrfs_data_container *init_data_container(u32 total_bytes)
|
|
|
|
{
|
|
|
|
struct btrfs_data_container *data;
|
|
|
|
size_t alloc_bytes;
|
|
|
|
|
|
|
|
alloc_bytes = max_t(size_t, total_bytes, sizeof(*data));
|
2017-05-31 20:32:09 +03:00
|
|
|
data = kvmalloc(alloc_bytes, GFP_KERNEL);
|
2011-06-13 21:52:59 +04:00
|
|
|
if (!data)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
if (total_bytes >= sizeof(*data)) {
|
|
|
|
data->bytes_left = total_bytes - sizeof(*data);
|
|
|
|
data->bytes_missing = 0;
|
|
|
|
} else {
|
|
|
|
data->bytes_missing = sizeof(*data) - total_bytes;
|
|
|
|
data->bytes_left = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
data->elem_cnt = 0;
|
|
|
|
data->elem_missed = 0;
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* allocates space to return multiple file system paths for an inode.
|
|
|
|
* total_bytes to allocate are passed, note that space usable for actual path
|
|
|
|
* information will be total_bytes - sizeof(struct inode_fs_paths).
|
|
|
|
* the returned pointer must be freed with free_ipath() in the end.
|
|
|
|
*/
|
|
|
|
struct inode_fs_paths *init_ipath(s32 total_bytes, struct btrfs_root *fs_root,
|
|
|
|
struct btrfs_path *path)
|
|
|
|
{
|
|
|
|
struct inode_fs_paths *ifp;
|
|
|
|
struct btrfs_data_container *fspath;
|
|
|
|
|
|
|
|
fspath = init_data_container(total_bytes);
|
|
|
|
if (IS_ERR(fspath))
|
2018-07-26 04:22:58 +03:00
|
|
|
return ERR_CAST(fspath);
|
2011-06-13 21:52:59 +04:00
|
|
|
|
2017-05-31 20:32:09 +03:00
|
|
|
ifp = kmalloc(sizeof(*ifp), GFP_KERNEL);
|
2011-06-13 21:52:59 +04:00
|
|
|
if (!ifp) {
|
2017-05-31 20:32:09 +03:00
|
|
|
kvfree(fspath);
|
2011-06-13 21:52:59 +04:00
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->btrfs_path = path;
|
|
|
|
ifp->fspath = fspath;
|
|
|
|
ifp->fs_root = fs_root;
|
|
|
|
|
|
|
|
return ifp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_ipath(struct inode_fs_paths *ipath)
|
|
|
|
{
|
2012-04-13 00:47:52 +04:00
|
|
|
if (!ipath)
|
|
|
|
return;
|
2017-05-31 20:32:09 +03:00
|
|
|
kvfree(ipath->fspath);
|
2011-06-13 21:52:59 +04:00
|
|
|
kfree(ipath);
|
|
|
|
}
|
2020-02-13 09:11:04 +03:00
|
|
|
|
|
|
|
struct btrfs_backref_iter *btrfs_backref_iter_alloc(
|
|
|
|
struct btrfs_fs_info *fs_info, gfp_t gfp_flag)
|
|
|
|
{
|
|
|
|
struct btrfs_backref_iter *ret;
|
|
|
|
|
|
|
|
ret = kzalloc(sizeof(*ret), gfp_flag);
|
|
|
|
if (!ret)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ret->path = btrfs_alloc_path();
|
2020-08-06 09:31:44 +03:00
|
|
|
if (!ret->path) {
|
2020-02-13 09:11:04 +03:00
|
|
|
kfree(ret);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Current backref iterator only supports iteration in commit root */
|
|
|
|
ret->path->search_commit_root = 1;
|
|
|
|
ret->path->skip_locking = 1;
|
|
|
|
ret->fs_info = fs_info;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_backref_iter_start(struct btrfs_backref_iter *iter, u64 bytenr)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = iter->fs_info;
|
|
|
|
struct btrfs_path *path = iter->path;
|
|
|
|
struct btrfs_extent_item *ei;
|
|
|
|
struct btrfs_key key;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
key.objectid = bytenr;
|
|
|
|
key.type = BTRFS_METADATA_ITEM_KEY;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
iter->bytenr = bytenr;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (ret == 0) {
|
|
|
|
ret = -EUCLEAN;
|
|
|
|
goto release;
|
|
|
|
}
|
|
|
|
if (path->slots[0] == 0) {
|
|
|
|
WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
|
|
|
|
ret = -EUCLEAN;
|
|
|
|
goto release;
|
|
|
|
}
|
|
|
|
path->slots[0]--;
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
|
|
|
|
if ((key.type != BTRFS_EXTENT_ITEM_KEY &&
|
|
|
|
key.type != BTRFS_METADATA_ITEM_KEY) || key.objectid != bytenr) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto release;
|
|
|
|
}
|
|
|
|
memcpy(&iter->cur_key, &key, sizeof(key));
|
|
|
|
iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],
|
|
|
|
path->slots[0]);
|
|
|
|
iter->end_ptr = (u32)(iter->item_ptr +
|
|
|
|
btrfs_item_size_nr(path->nodes[0], path->slots[0]));
|
|
|
|
ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
|
|
|
|
struct btrfs_extent_item);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Only support iteration on tree backref yet.
|
|
|
|
*
|
|
|
|
* This is an extra precaution for non skinny-metadata, where
|
|
|
|
* EXTENT_ITEM is also used for tree blocks, that we can only use
|
|
|
|
* extent flags to determine if it's a tree block.
|
|
|
|
*/
|
|
|
|
if (btrfs_extent_flags(path->nodes[0], ei) & BTRFS_EXTENT_FLAG_DATA) {
|
|
|
|
ret = -ENOTSUPP;
|
|
|
|
goto release;
|
|
|
|
}
|
|
|
|
iter->cur_ptr = (u32)(iter->item_ptr + sizeof(*ei));
|
|
|
|
|
|
|
|
/* If there is no inline backref, go search for keyed backref */
|
|
|
|
if (iter->cur_ptr >= iter->end_ptr) {
|
|
|
|
ret = btrfs_next_item(fs_info->extent_root, path);
|
|
|
|
|
|
|
|
/* No inline nor keyed ref */
|
|
|
|
if (ret > 0) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto release;
|
|
|
|
}
|
|
|
|
if (ret < 0)
|
|
|
|
goto release;
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &iter->cur_key,
|
|
|
|
path->slots[0]);
|
|
|
|
if (iter->cur_key.objectid != bytenr ||
|
|
|
|
(iter->cur_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
|
|
|
|
iter->cur_key.type != BTRFS_TREE_BLOCK_REF_KEY)) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto release;
|
|
|
|
}
|
|
|
|
iter->cur_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],
|
|
|
|
path->slots[0]);
|
|
|
|
iter->item_ptr = iter->cur_ptr;
|
|
|
|
iter->end_ptr = (u32)(iter->item_ptr + btrfs_item_size_nr(
|
|
|
|
path->nodes[0], path->slots[0]));
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
release:
|
|
|
|
btrfs_backref_iter_release(iter);
|
|
|
|
return ret;
|
|
|
|
}
|
2020-02-13 10:04:04 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Go to the next backref item of current bytenr, can be either inlined or
|
|
|
|
* keyed.
|
|
|
|
*
|
|
|
|
* Caller needs to check whether it's inline ref or not by iter->cur_key.
|
|
|
|
*
|
|
|
|
* Return 0 if we get next backref without problem.
|
|
|
|
* Return >0 if there is no extra backref for this bytenr.
|
|
|
|
* Return <0 if there is something wrong happened.
|
|
|
|
*/
|
|
|
|
int btrfs_backref_iter_next(struct btrfs_backref_iter *iter)
|
|
|
|
{
|
|
|
|
struct extent_buffer *eb = btrfs_backref_get_eb(iter);
|
|
|
|
struct btrfs_path *path = iter->path;
|
|
|
|
struct btrfs_extent_inline_ref *iref;
|
|
|
|
int ret;
|
|
|
|
u32 size;
|
|
|
|
|
|
|
|
if (btrfs_backref_iter_is_inline_ref(iter)) {
|
|
|
|
/* We're still inside the inline refs */
|
|
|
|
ASSERT(iter->cur_ptr < iter->end_ptr);
|
|
|
|
|
|
|
|
if (btrfs_backref_has_tree_block_info(iter)) {
|
|
|
|
/* First tree block info */
|
|
|
|
size = sizeof(struct btrfs_tree_block_info);
|
|
|
|
} else {
|
|
|
|
/* Use inline ref type to determine the size */
|
|
|
|
int type;
|
|
|
|
|
|
|
|
iref = (struct btrfs_extent_inline_ref *)
|
|
|
|
((unsigned long)iter->cur_ptr);
|
|
|
|
type = btrfs_extent_inline_ref_type(eb, iref);
|
|
|
|
|
|
|
|
size = btrfs_extent_inline_ref_size(type);
|
|
|
|
}
|
|
|
|
iter->cur_ptr += size;
|
|
|
|
if (iter->cur_ptr < iter->end_ptr)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* All inline items iterated, fall through */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We're at keyed items, there is no inline item, go to the next one */
|
|
|
|
ret = btrfs_next_item(iter->fs_info->extent_root, iter->path);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &iter->cur_key, path->slots[0]);
|
|
|
|
if (iter->cur_key.objectid != iter->bytenr ||
|
|
|
|
(iter->cur_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
|
|
|
|
iter->cur_key.type != BTRFS_SHARED_BLOCK_REF_KEY))
|
|
|
|
return 1;
|
|
|
|
iter->item_ptr = (u32)btrfs_item_ptr_offset(path->nodes[0],
|
|
|
|
path->slots[0]);
|
|
|
|
iter->cur_ptr = iter->item_ptr;
|
|
|
|
iter->end_ptr = iter->item_ptr + (u32)btrfs_item_size_nr(path->nodes[0],
|
|
|
|
path->slots[0]);
|
|
|
|
return 0;
|
|
|
|
}
|
2020-03-03 08:14:41 +03:00
|
|
|
|
|
|
|
void btrfs_backref_init_cache(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_backref_cache *cache, int is_reloc)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
cache->rb_root = RB_ROOT;
|
|
|
|
for (i = 0; i < BTRFS_MAX_LEVEL; i++)
|
|
|
|
INIT_LIST_HEAD(&cache->pending[i]);
|
|
|
|
INIT_LIST_HEAD(&cache->changed);
|
|
|
|
INIT_LIST_HEAD(&cache->detached);
|
|
|
|
INIT_LIST_HEAD(&cache->leaves);
|
|
|
|
INIT_LIST_HEAD(&cache->pending_edge);
|
|
|
|
INIT_LIST_HEAD(&cache->useless_node);
|
|
|
|
cache->fs_info = fs_info;
|
|
|
|
cache->is_reloc = is_reloc;
|
|
|
|
}
|
2020-03-03 08:21:30 +03:00
|
|
|
|
|
|
|
struct btrfs_backref_node *btrfs_backref_alloc_node(
|
|
|
|
struct btrfs_backref_cache *cache, u64 bytenr, int level)
|
|
|
|
{
|
|
|
|
struct btrfs_backref_node *node;
|
|
|
|
|
|
|
|
ASSERT(level >= 0 && level < BTRFS_MAX_LEVEL);
|
|
|
|
node = kzalloc(sizeof(*node), GFP_NOFS);
|
|
|
|
if (!node)
|
|
|
|
return node;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&node->list);
|
|
|
|
INIT_LIST_HEAD(&node->upper);
|
|
|
|
INIT_LIST_HEAD(&node->lower);
|
|
|
|
RB_CLEAR_NODE(&node->rb_node);
|
|
|
|
cache->nr_nodes++;
|
|
|
|
node->level = level;
|
|
|
|
node->bytenr = bytenr;
|
|
|
|
|
|
|
|
return node;
|
|
|
|
}
|
2020-03-03 08:22:57 +03:00
|
|
|
|
|
|
|
struct btrfs_backref_edge *btrfs_backref_alloc_edge(
|
|
|
|
struct btrfs_backref_cache *cache)
|
|
|
|
{
|
|
|
|
struct btrfs_backref_edge *edge;
|
|
|
|
|
|
|
|
edge = kzalloc(sizeof(*edge), GFP_NOFS);
|
|
|
|
if (edge)
|
|
|
|
cache->nr_edges++;
|
|
|
|
return edge;
|
|
|
|
}
|
2020-03-23 10:42:25 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Drop the backref node from cache, also cleaning up all its
|
|
|
|
* upper edges and any uncached nodes in the path.
|
|
|
|
*
|
|
|
|
* This cleanup happens bottom up, thus the node should either
|
|
|
|
* be the lowest node in the cache or a detached node.
|
|
|
|
*/
|
|
|
|
void btrfs_backref_cleanup_node(struct btrfs_backref_cache *cache,
|
|
|
|
struct btrfs_backref_node *node)
|
|
|
|
{
|
|
|
|
struct btrfs_backref_node *upper;
|
|
|
|
struct btrfs_backref_edge *edge;
|
|
|
|
|
|
|
|
if (!node)
|
|
|
|
return;
|
|
|
|
|
|
|
|
BUG_ON(!node->lowest && !node->detached);
|
|
|
|
while (!list_empty(&node->upper)) {
|
|
|
|
edge = list_entry(node->upper.next, struct btrfs_backref_edge,
|
|
|
|
list[LOWER]);
|
|
|
|
upper = edge->node[UPPER];
|
|
|
|
list_del(&edge->list[LOWER]);
|
|
|
|
list_del(&edge->list[UPPER]);
|
|
|
|
btrfs_backref_free_edge(cache, edge);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add the node to leaf node list if no other child block
|
|
|
|
* cached.
|
|
|
|
*/
|
|
|
|
if (list_empty(&upper->lower)) {
|
|
|
|
list_add_tail(&upper->lower, &cache->leaves);
|
|
|
|
upper->lowest = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_backref_drop_node(cache, node);
|
|
|
|
}
|
2020-03-03 08:55:12 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Release all nodes/edges from current cache
|
|
|
|
*/
|
|
|
|
void btrfs_backref_release_cache(struct btrfs_backref_cache *cache)
|
|
|
|
{
|
|
|
|
struct btrfs_backref_node *node;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
while (!list_empty(&cache->detached)) {
|
|
|
|
node = list_entry(cache->detached.next,
|
|
|
|
struct btrfs_backref_node, list);
|
|
|
|
btrfs_backref_cleanup_node(cache, node);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!list_empty(&cache->leaves)) {
|
|
|
|
node = list_entry(cache->leaves.next,
|
|
|
|
struct btrfs_backref_node, lower);
|
|
|
|
btrfs_backref_cleanup_node(cache, node);
|
|
|
|
}
|
|
|
|
|
|
|
|
cache->last_trans = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < BTRFS_MAX_LEVEL; i++)
|
|
|
|
ASSERT(list_empty(&cache->pending[i]));
|
|
|
|
ASSERT(list_empty(&cache->pending_edge));
|
|
|
|
ASSERT(list_empty(&cache->useless_node));
|
|
|
|
ASSERT(list_empty(&cache->changed));
|
|
|
|
ASSERT(list_empty(&cache->detached));
|
|
|
|
ASSERT(RB_EMPTY_ROOT(&cache->rb_root));
|
|
|
|
ASSERT(!cache->nr_nodes);
|
|
|
|
ASSERT(!cache->nr_edges);
|
|
|
|
}
|
2020-03-23 11:08:34 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle direct tree backref
|
|
|
|
*
|
|
|
|
* Direct tree backref means, the backref item shows its parent bytenr
|
|
|
|
* directly. This is for SHARED_BLOCK_REF backref (keyed or inlined).
|
|
|
|
*
|
|
|
|
* @ref_key: The converted backref key.
|
|
|
|
* For keyed backref, it's the item key.
|
|
|
|
* For inlined backref, objectid is the bytenr,
|
|
|
|
* type is btrfs_inline_ref_type, offset is
|
|
|
|
* btrfs_inline_ref_offset.
|
|
|
|
*/
|
|
|
|
static int handle_direct_tree_backref(struct btrfs_backref_cache *cache,
|
|
|
|
struct btrfs_key *ref_key,
|
|
|
|
struct btrfs_backref_node *cur)
|
|
|
|
{
|
|
|
|
struct btrfs_backref_edge *edge;
|
|
|
|
struct btrfs_backref_node *upper;
|
|
|
|
struct rb_node *rb_node;
|
|
|
|
|
|
|
|
ASSERT(ref_key->type == BTRFS_SHARED_BLOCK_REF_KEY);
|
|
|
|
|
|
|
|
/* Only reloc root uses backref pointing to itself */
|
|
|
|
if (ref_key->objectid == ref_key->offset) {
|
|
|
|
struct btrfs_root *root;
|
|
|
|
|
|
|
|
cur->is_reloc_root = 1;
|
|
|
|
/* Only reloc backref cache cares about a specific root */
|
|
|
|
if (cache->is_reloc) {
|
|
|
|
root = find_reloc_root(cache->fs_info, cur->bytenr);
|
2021-01-14 22:02:44 +03:00
|
|
|
if (!root)
|
2020-03-23 11:08:34 +03:00
|
|
|
return -ENOENT;
|
|
|
|
cur->root = root;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* For generic purpose backref cache, reloc root node
|
|
|
|
* is useless.
|
|
|
|
*/
|
|
|
|
list_add(&cur->list, &cache->useless_node);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
edge = btrfs_backref_alloc_edge(cache);
|
|
|
|
if (!edge)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
rb_node = rb_simple_search(&cache->rb_root, ref_key->offset);
|
|
|
|
if (!rb_node) {
|
|
|
|
/* Parent node not yet cached */
|
|
|
|
upper = btrfs_backref_alloc_node(cache, ref_key->offset,
|
|
|
|
cur->level + 1);
|
|
|
|
if (!upper) {
|
|
|
|
btrfs_backref_free_edge(cache, edge);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Backrefs for the upper level block isn't cached, add the
|
|
|
|
* block to pending list
|
|
|
|
*/
|
|
|
|
list_add_tail(&edge->list[UPPER], &cache->pending_edge);
|
|
|
|
} else {
|
|
|
|
/* Parent node already cached */
|
|
|
|
upper = rb_entry(rb_node, struct btrfs_backref_node, rb_node);
|
|
|
|
ASSERT(upper->checked);
|
|
|
|
INIT_LIST_HEAD(&edge->list[UPPER]);
|
|
|
|
}
|
|
|
|
btrfs_backref_link_edge(edge, cur, upper, LINK_LOWER);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle indirect tree backref
|
|
|
|
*
|
|
|
|
* Indirect tree backref means, we only know which tree the node belongs to.
|
|
|
|
* We still need to do a tree search to find out the parents. This is for
|
|
|
|
* TREE_BLOCK_REF backref (keyed or inlined).
|
|
|
|
*
|
|
|
|
* @ref_key: The same as @ref_key in handle_direct_tree_backref()
|
|
|
|
* @tree_key: The first key of this tree block.
|
2021-05-21 18:42:23 +03:00
|
|
|
* @path: A clean (released) path, to avoid allocating path every time
|
2020-03-23 11:08:34 +03:00
|
|
|
* the function get called.
|
|
|
|
*/
|
|
|
|
static int handle_indirect_tree_backref(struct btrfs_backref_cache *cache,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct btrfs_key *ref_key,
|
|
|
|
struct btrfs_key *tree_key,
|
|
|
|
struct btrfs_backref_node *cur)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = cache->fs_info;
|
|
|
|
struct btrfs_backref_node *upper;
|
|
|
|
struct btrfs_backref_node *lower;
|
|
|
|
struct btrfs_backref_edge *edge;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
struct btrfs_root *root;
|
|
|
|
struct rb_node *rb_node;
|
|
|
|
int level;
|
|
|
|
bool need_check = true;
|
|
|
|
int ret;
|
|
|
|
|
2020-05-15 20:35:55 +03:00
|
|
|
root = btrfs_get_fs_root(fs_info, ref_key->offset, false);
|
2020-03-23 11:08:34 +03:00
|
|
|
if (IS_ERR(root))
|
|
|
|
return PTR_ERR(root);
|
2020-05-15 09:01:40 +03:00
|
|
|
if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
|
2020-03-23 11:08:34 +03:00
|
|
|
cur->cowonly = 1;
|
|
|
|
|
|
|
|
if (btrfs_root_level(&root->root_item) == cur->level) {
|
|
|
|
/* Tree root */
|
|
|
|
ASSERT(btrfs_root_bytenr(&root->root_item) == cur->bytenr);
|
2020-03-16 09:10:01 +03:00
|
|
|
/*
|
|
|
|
* For reloc backref cache, we may ignore reloc root. But for
|
|
|
|
* general purpose backref cache, we can't rely on
|
|
|
|
* btrfs_should_ignore_reloc_root() as it may conflict with
|
|
|
|
* current running relocation and lead to missing root.
|
|
|
|
*
|
|
|
|
* For general purpose backref cache, reloc root detection is
|
|
|
|
* completely relying on direct backref (key->offset is parent
|
|
|
|
* bytenr), thus only do such check for reloc cache.
|
|
|
|
*/
|
|
|
|
if (btrfs_should_ignore_reloc_root(root) && cache->is_reloc) {
|
2020-03-23 11:08:34 +03:00
|
|
|
btrfs_put_root(root);
|
|
|
|
list_add(&cur->list, &cache->useless_node);
|
|
|
|
} else {
|
|
|
|
cur->root = root;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
level = cur->level + 1;
|
|
|
|
|
|
|
|
/* Search the tree to find parent blocks referring to the block */
|
|
|
|
path->search_commit_root = 1;
|
|
|
|
path->skip_locking = 1;
|
|
|
|
path->lowest_level = level;
|
|
|
|
ret = btrfs_search_slot(NULL, root, tree_key, path, 0, 0);
|
|
|
|
path->lowest_level = 0;
|
|
|
|
if (ret < 0) {
|
|
|
|
btrfs_put_root(root);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
if (ret > 0 && path->slots[level] > 0)
|
|
|
|
path->slots[level]--;
|
|
|
|
|
|
|
|
eb = path->nodes[level];
|
|
|
|
if (btrfs_node_blockptr(eb, path->slots[level]) != cur->bytenr) {
|
|
|
|
btrfs_err(fs_info,
|
|
|
|
"couldn't find block (%llu) (level %d) in tree (%llu) with key (%llu %u %llu)",
|
|
|
|
cur->bytenr, level - 1, root->root_key.objectid,
|
|
|
|
tree_key->objectid, tree_key->type, tree_key->offset);
|
|
|
|
btrfs_put_root(root);
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
lower = cur;
|
|
|
|
|
|
|
|
/* Add all nodes and edges in the path */
|
|
|
|
for (; level < BTRFS_MAX_LEVEL; level++) {
|
|
|
|
if (!path->nodes[level]) {
|
|
|
|
ASSERT(btrfs_root_bytenr(&root->root_item) ==
|
|
|
|
lower->bytenr);
|
2020-03-16 09:10:01 +03:00
|
|
|
/* Same as previous should_ignore_reloc_root() call */
|
|
|
|
if (btrfs_should_ignore_reloc_root(root) &&
|
|
|
|
cache->is_reloc) {
|
2020-03-23 11:08:34 +03:00
|
|
|
btrfs_put_root(root);
|
|
|
|
list_add(&lower->list, &cache->useless_node);
|
|
|
|
} else {
|
|
|
|
lower->root = root;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
edge = btrfs_backref_alloc_edge(cache);
|
|
|
|
if (!edge) {
|
|
|
|
btrfs_put_root(root);
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
eb = path->nodes[level];
|
|
|
|
rb_node = rb_simple_search(&cache->rb_root, eb->start);
|
|
|
|
if (!rb_node) {
|
|
|
|
upper = btrfs_backref_alloc_node(cache, eb->start,
|
|
|
|
lower->level + 1);
|
|
|
|
if (!upper) {
|
|
|
|
btrfs_put_root(root);
|
|
|
|
btrfs_backref_free_edge(cache, edge);
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
upper->owner = btrfs_header_owner(eb);
|
2020-05-15 09:01:40 +03:00
|
|
|
if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
|
2020-03-23 11:08:34 +03:00
|
|
|
upper->cowonly = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we know the block isn't shared we can avoid
|
|
|
|
* checking its backrefs.
|
|
|
|
*/
|
|
|
|
if (btrfs_block_can_be_shared(root, eb))
|
|
|
|
upper->checked = 0;
|
|
|
|
else
|
|
|
|
upper->checked = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add the block to pending list if we need to check its
|
|
|
|
* backrefs, we only do this once while walking up a
|
|
|
|
* tree as we will catch anything else later on.
|
|
|
|
*/
|
|
|
|
if (!upper->checked && need_check) {
|
|
|
|
need_check = false;
|
|
|
|
list_add_tail(&edge->list[UPPER],
|
|
|
|
&cache->pending_edge);
|
|
|
|
} else {
|
|
|
|
if (upper->checked)
|
|
|
|
need_check = true;
|
|
|
|
INIT_LIST_HEAD(&edge->list[UPPER]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
upper = rb_entry(rb_node, struct btrfs_backref_node,
|
|
|
|
rb_node);
|
|
|
|
ASSERT(upper->checked);
|
|
|
|
INIT_LIST_HEAD(&edge->list[UPPER]);
|
|
|
|
if (!upper->owner)
|
|
|
|
upper->owner = btrfs_header_owner(eb);
|
|
|
|
}
|
|
|
|
btrfs_backref_link_edge(edge, lower, upper, LINK_LOWER);
|
|
|
|
|
|
|
|
if (rb_node) {
|
|
|
|
btrfs_put_root(root);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
lower = upper;
|
|
|
|
upper = NULL;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
btrfs_release_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add backref node @cur into @cache.
|
|
|
|
*
|
|
|
|
* NOTE: Even if the function returned 0, @cur is not yet cached as its upper
|
|
|
|
* links aren't yet bi-directional. Needs to finish such links.
|
2020-03-23 11:14:08 +03:00
|
|
|
* Use btrfs_backref_finish_upper_links() to finish such linkage.
|
2020-03-23 11:08:34 +03:00
|
|
|
*
|
|
|
|
* @path: Released path for indirect tree backref lookup
|
|
|
|
* @iter: Released backref iter for extent tree search
|
|
|
|
* @node_key: The first key of the tree block
|
|
|
|
*/
|
|
|
|
int btrfs_backref_add_tree_node(struct btrfs_backref_cache *cache,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
struct btrfs_backref_iter *iter,
|
|
|
|
struct btrfs_key *node_key,
|
|
|
|
struct btrfs_backref_node *cur)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = cache->fs_info;
|
|
|
|
struct btrfs_backref_edge *edge;
|
|
|
|
struct btrfs_backref_node *exist;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = btrfs_backref_iter_start(iter, cur->bytenr);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
/*
|
|
|
|
* We skip the first btrfs_tree_block_info, as we don't use the key
|
|
|
|
* stored in it, but fetch it from the tree block
|
|
|
|
*/
|
|
|
|
if (btrfs_backref_has_tree_block_info(iter)) {
|
|
|
|
ret = btrfs_backref_iter_next(iter);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
/* No extra backref? This means the tree block is corrupted */
|
|
|
|
if (ret > 0) {
|
|
|
|
ret = -EUCLEAN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
WARN_ON(cur->checked);
|
|
|
|
if (!list_empty(&cur->upper)) {
|
|
|
|
/*
|
|
|
|
* The backref was added previously when processing backref of
|
|
|
|
* type BTRFS_TREE_BLOCK_REF_KEY
|
|
|
|
*/
|
|
|
|
ASSERT(list_is_singular(&cur->upper));
|
|
|
|
edge = list_entry(cur->upper.next, struct btrfs_backref_edge,
|
|
|
|
list[LOWER]);
|
|
|
|
ASSERT(list_empty(&edge->list[UPPER]));
|
|
|
|
exist = edge->node[UPPER];
|
|
|
|
/*
|
|
|
|
* Add the upper level block to pending list if we need check
|
|
|
|
* its backrefs
|
|
|
|
*/
|
|
|
|
if (!exist->checked)
|
|
|
|
list_add_tail(&edge->list[UPPER], &cache->pending_edge);
|
|
|
|
} else {
|
|
|
|
exist = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; ret == 0; ret = btrfs_backref_iter_next(iter)) {
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
struct btrfs_key key;
|
|
|
|
int type;
|
|
|
|
|
|
|
|
cond_resched();
|
|
|
|
eb = btrfs_backref_get_eb(iter);
|
|
|
|
|
|
|
|
key.objectid = iter->bytenr;
|
|
|
|
if (btrfs_backref_iter_is_inline_ref(iter)) {
|
|
|
|
struct btrfs_extent_inline_ref *iref;
|
|
|
|
|
|
|
|
/* Update key for inline backref */
|
|
|
|
iref = (struct btrfs_extent_inline_ref *)
|
|
|
|
((unsigned long)iter->cur_ptr);
|
|
|
|
type = btrfs_get_extent_inline_ref_type(eb, iref,
|
|
|
|
BTRFS_REF_TYPE_BLOCK);
|
|
|
|
if (type == BTRFS_REF_TYPE_INVALID) {
|
|
|
|
ret = -EUCLEAN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
key.type = type;
|
|
|
|
key.offset = btrfs_extent_inline_ref_offset(eb, iref);
|
|
|
|
} else {
|
|
|
|
key.type = iter->cur_key.type;
|
|
|
|
key.offset = iter->cur_key.offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parent node found and matches current inline ref, no need to
|
|
|
|
* rebuild this node for this inline ref
|
|
|
|
*/
|
|
|
|
if (exist &&
|
|
|
|
((key.type == BTRFS_TREE_BLOCK_REF_KEY &&
|
|
|
|
exist->owner == key.offset) ||
|
|
|
|
(key.type == BTRFS_SHARED_BLOCK_REF_KEY &&
|
|
|
|
exist->bytenr == key.offset))) {
|
|
|
|
exist = NULL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SHARED_BLOCK_REF means key.offset is the parent bytenr */
|
|
|
|
if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
|
|
|
|
ret = handle_direct_tree_backref(cache, &key, cur);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
continue;
|
|
|
|
} else if (unlikely(key.type == BTRFS_EXTENT_REF_V0_KEY)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
btrfs_print_v0_err(fs_info);
|
|
|
|
btrfs_handle_fs_error(fs_info, ret, NULL);
|
|
|
|
goto out;
|
|
|
|
} else if (key.type != BTRFS_TREE_BLOCK_REF_KEY) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* key.type == BTRFS_TREE_BLOCK_REF_KEY, inline ref offset
|
|
|
|
* means the root objectid. We need to search the tree to get
|
|
|
|
* its parent bytenr.
|
|
|
|
*/
|
|
|
|
ret = handle_indirect_tree_backref(cache, path, &key, node_key,
|
|
|
|
cur);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
cur->checked = 1;
|
|
|
|
WARN_ON(exist);
|
|
|
|
out:
|
|
|
|
btrfs_backref_iter_release(iter);
|
|
|
|
return ret;
|
|
|
|
}
|
2020-03-23 11:14:08 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Finish the upwards linkage created by btrfs_backref_add_tree_node()
|
|
|
|
*/
|
|
|
|
int btrfs_backref_finish_upper_links(struct btrfs_backref_cache *cache,
|
|
|
|
struct btrfs_backref_node *start)
|
|
|
|
{
|
|
|
|
struct list_head *useless_node = &cache->useless_node;
|
|
|
|
struct btrfs_backref_edge *edge;
|
|
|
|
struct rb_node *rb_node;
|
|
|
|
LIST_HEAD(pending_edge);
|
|
|
|
|
|
|
|
ASSERT(start->checked);
|
|
|
|
|
|
|
|
/* Insert this node to cache if it's not COW-only */
|
|
|
|
if (!start->cowonly) {
|
|
|
|
rb_node = rb_simple_insert(&cache->rb_root, start->bytenr,
|
|
|
|
&start->rb_node);
|
|
|
|
if (rb_node)
|
|
|
|
btrfs_backref_panic(cache->fs_info, start->bytenr,
|
|
|
|
-EEXIST);
|
|
|
|
list_add_tail(&start->lower, &cache->leaves);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use breadth first search to iterate all related edges.
|
|
|
|
*
|
|
|
|
* The starting points are all the edges of this node
|
|
|
|
*/
|
|
|
|
list_for_each_entry(edge, &start->upper, list[LOWER])
|
|
|
|
list_add_tail(&edge->list[UPPER], &pending_edge);
|
|
|
|
|
|
|
|
while (!list_empty(&pending_edge)) {
|
|
|
|
struct btrfs_backref_node *upper;
|
|
|
|
struct btrfs_backref_node *lower;
|
|
|
|
|
|
|
|
edge = list_first_entry(&pending_edge,
|
|
|
|
struct btrfs_backref_edge, list[UPPER]);
|
|
|
|
list_del_init(&edge->list[UPPER]);
|
|
|
|
upper = edge->node[UPPER];
|
|
|
|
lower = edge->node[LOWER];
|
|
|
|
|
|
|
|
/* Parent is detached, no need to keep any edges */
|
|
|
|
if (upper->detached) {
|
|
|
|
list_del(&edge->list[LOWER]);
|
|
|
|
btrfs_backref_free_edge(cache, edge);
|
|
|
|
|
|
|
|
/* Lower node is orphan, queue for cleanup */
|
|
|
|
if (list_empty(&lower->upper))
|
|
|
|
list_add(&lower->list, useless_node);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* All new nodes added in current build_backref_tree() haven't
|
|
|
|
* been linked to the cache rb tree.
|
|
|
|
* So if we have upper->rb_node populated, this means a cache
|
|
|
|
* hit. We only need to link the edge, as @upper and all its
|
|
|
|
* parents have already been linked.
|
|
|
|
*/
|
|
|
|
if (!RB_EMPTY_NODE(&upper->rb_node)) {
|
|
|
|
if (upper->lowest) {
|
|
|
|
list_del_init(&upper->lower);
|
|
|
|
upper->lowest = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&edge->list[UPPER], &upper->lower);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sanity check, we shouldn't have any unchecked nodes */
|
|
|
|
if (!upper->checked) {
|
|
|
|
ASSERT(0);
|
|
|
|
return -EUCLEAN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sanity check, COW-only node has non-COW-only parent */
|
|
|
|
if (start->cowonly != upper->cowonly) {
|
|
|
|
ASSERT(0);
|
|
|
|
return -EUCLEAN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only cache non-COW-only (subvolume trees) tree blocks */
|
|
|
|
if (!upper->cowonly) {
|
|
|
|
rb_node = rb_simple_insert(&cache->rb_root, upper->bytenr,
|
|
|
|
&upper->rb_node);
|
|
|
|
if (rb_node) {
|
|
|
|
btrfs_backref_panic(cache->fs_info,
|
|
|
|
upper->bytenr, -EEXIST);
|
|
|
|
return -EUCLEAN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&edge->list[UPPER], &upper->lower);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Also queue all the parent edges of this uncached node
|
|
|
|
* to finish the upper linkage
|
|
|
|
*/
|
|
|
|
list_for_each_entry(edge, &upper->upper, list[LOWER])
|
|
|
|
list_add_tail(&edge->list[UPPER], &pending_edge);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2020-03-23 11:57:15 +03:00
|
|
|
|
|
|
|
void btrfs_backref_error_cleanup(struct btrfs_backref_cache *cache,
|
|
|
|
struct btrfs_backref_node *node)
|
|
|
|
{
|
|
|
|
struct btrfs_backref_node *lower;
|
|
|
|
struct btrfs_backref_node *upper;
|
|
|
|
struct btrfs_backref_edge *edge;
|
|
|
|
|
|
|
|
while (!list_empty(&cache->useless_node)) {
|
|
|
|
lower = list_first_entry(&cache->useless_node,
|
|
|
|
struct btrfs_backref_node, list);
|
|
|
|
list_del_init(&lower->list);
|
|
|
|
}
|
|
|
|
while (!list_empty(&cache->pending_edge)) {
|
|
|
|
edge = list_first_entry(&cache->pending_edge,
|
|
|
|
struct btrfs_backref_edge, list[UPPER]);
|
|
|
|
list_del(&edge->list[UPPER]);
|
|
|
|
list_del(&edge->list[LOWER]);
|
|
|
|
lower = edge->node[LOWER];
|
|
|
|
upper = edge->node[UPPER];
|
|
|
|
btrfs_backref_free_edge(cache, edge);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lower is no longer linked to any upper backref nodes and
|
|
|
|
* isn't in the cache, we can free it ourselves.
|
|
|
|
*/
|
|
|
|
if (list_empty(&lower->upper) &&
|
|
|
|
RB_EMPTY_NODE(&lower->rb_node))
|
|
|
|
list_add(&lower->list, &cache->useless_node);
|
|
|
|
|
|
|
|
if (!RB_EMPTY_NODE(&upper->rb_node))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Add this guy's upper edges to the list to process */
|
|
|
|
list_for_each_entry(edge, &upper->upper, list[LOWER])
|
|
|
|
list_add_tail(&edge->list[UPPER],
|
|
|
|
&cache->pending_edge);
|
|
|
|
if (list_empty(&upper->upper))
|
|
|
|
list_add(&upper->list, &cache->useless_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!list_empty(&cache->useless_node)) {
|
|
|
|
lower = list_first_entry(&cache->useless_node,
|
|
|
|
struct btrfs_backref_node, list);
|
|
|
|
list_del_init(&lower->list);
|
|
|
|
if (lower == node)
|
|
|
|
node = NULL;
|
2020-12-16 19:22:11 +03:00
|
|
|
btrfs_backref_drop_node(cache, lower);
|
2020-03-23 11:57:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_backref_cleanup_node(cache, node);
|
|
|
|
ASSERT(list_empty(&cache->useless_node) &&
|
|
|
|
list_empty(&cache->pending_edge));
|
|
|
|
}
|