2011-06-14 00:52:59 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2011 STRATO. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2012-09-08 09:01:30 +07:00
|
|
|
#include <linux/vmalloc.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 08:36:46 +07:00
|
|
|
#include <linux/rbtree.h>
|
2011-06-14 00:52:59 +07:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "disk-io.h"
|
|
|
|
#include "backref.h"
|
2011-11-24 00:55:04 +07:00
|
|
|
#include "ulist.h"
|
|
|
|
#include "transaction.h"
|
|
|
|
#include "delayed-ref.h"
|
2012-04-13 17:28:08 +07:00
|
|
|
#include "locking.h"
|
2011-06-14 00:52:59 +07:00
|
|
|
|
2014-09-11 03:20:45 +07:00
|
|
|
/* Just an arbitrary number so we can be sure this happened */
|
|
|
|
#define BACKREF_FOUND_SHARED 6
|
|
|
|
|
2012-05-17 21:43:03 +07:00
|
|
|
struct extent_inode_elem {
|
|
|
|
u64 inum;
|
|
|
|
u64 offset;
|
|
|
|
struct extent_inode_elem *next;
|
|
|
|
};
|
|
|
|
|
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 08:36:46 +07:00
|
|
|
/*
|
|
|
|
* ref_root is used as the root of the ref tree that hold a collection
|
|
|
|
* of unique references.
|
|
|
|
*/
|
|
|
|
struct ref_root {
|
|
|
|
struct rb_root rb_root;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The unique_refs represents the number of ref_nodes with a positive
|
|
|
|
* count stored in the tree. Even if a ref_node (the count is greater
|
|
|
|
* than one) is added, the unique_refs will only increase by one.
|
|
|
|
*/
|
|
|
|
unsigned int unique_refs;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* ref_node is used to store a unique reference to the ref tree. */
|
|
|
|
struct ref_node {
|
|
|
|
struct rb_node rb_node;
|
|
|
|
|
|
|
|
/* For NORMAL_REF, otherwise all these fields should be set to 0 */
|
|
|
|
u64 root_id;
|
|
|
|
u64 object_id;
|
|
|
|
u64 offset;
|
|
|
|
|
|
|
|
/* For SHARED_REF, otherwise parent field should be set to 0 */
|
|
|
|
u64 parent;
|
|
|
|
|
|
|
|
/* Ref to the ref_mod of btrfs_delayed_ref_node */
|
|
|
|
int ref_mod;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Dynamically allocate and initialize a ref_root */
|
|
|
|
static struct ref_root *ref_root_alloc(void)
|
|
|
|
{
|
|
|
|
struct ref_root *ref_tree;
|
|
|
|
|
|
|
|
ref_tree = kmalloc(sizeof(*ref_tree), GFP_NOFS);
|
|
|
|
if (!ref_tree)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ref_tree->rb_root = RB_ROOT;
|
|
|
|
ref_tree->unique_refs = 0;
|
|
|
|
|
|
|
|
return ref_tree;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free all nodes in the ref tree, and reinit ref_root */
|
|
|
|
static void ref_root_fini(struct ref_root *ref_tree)
|
|
|
|
{
|
|
|
|
struct ref_node *node;
|
|
|
|
struct rb_node *next;
|
|
|
|
|
|
|
|
while ((next = rb_first(&ref_tree->rb_root)) != NULL) {
|
|
|
|
node = rb_entry(next, struct ref_node, rb_node);
|
|
|
|
rb_erase(next, &ref_tree->rb_root);
|
|
|
|
kfree(node);
|
|
|
|
}
|
|
|
|
|
|
|
|
ref_tree->rb_root = RB_ROOT;
|
|
|
|
ref_tree->unique_refs = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ref_root_free(struct ref_root *ref_tree)
|
|
|
|
{
|
|
|
|
if (!ref_tree)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ref_root_fini(ref_tree);
|
|
|
|
kfree(ref_tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare ref_node with (root_id, object_id, offset, parent)
|
|
|
|
*
|
|
|
|
* The function compares two ref_node a and b. It returns an integer less
|
|
|
|
* than, equal to, or greater than zero , respectively, to be less than, to
|
|
|
|
* equal, or be greater than b.
|
|
|
|
*/
|
|
|
|
static int ref_node_cmp(struct ref_node *a, struct ref_node *b)
|
|
|
|
{
|
|
|
|
if (a->root_id < b->root_id)
|
|
|
|
return -1;
|
|
|
|
else if (a->root_id > b->root_id)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (a->object_id < b->object_id)
|
|
|
|
return -1;
|
|
|
|
else if (a->object_id > b->object_id)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (a->offset < b->offset)
|
|
|
|
return -1;
|
|
|
|
else if (a->offset > b->offset)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (a->parent < b->parent)
|
|
|
|
return -1;
|
|
|
|
else if (a->parent > b->parent)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search ref_node with (root_id, object_id, offset, parent) in the tree
|
|
|
|
*
|
|
|
|
* if found, the pointer of the ref_node will be returned;
|
|
|
|
* if not found, NULL will be returned and pos will point to the rb_node for
|
|
|
|
* insert, pos_parent will point to pos'parent for insert;
|
|
|
|
*/
|
|
|
|
static struct ref_node *__ref_tree_search(struct ref_root *ref_tree,
|
|
|
|
struct rb_node ***pos,
|
|
|
|
struct rb_node **pos_parent,
|
|
|
|
u64 root_id, u64 object_id,
|
|
|
|
u64 offset, u64 parent)
|
|
|
|
{
|
|
|
|
struct ref_node *cur = NULL;
|
|
|
|
struct ref_node entry;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
entry.root_id = root_id;
|
|
|
|
entry.object_id = object_id;
|
|
|
|
entry.offset = offset;
|
|
|
|
entry.parent = parent;
|
|
|
|
|
|
|
|
*pos = &ref_tree->rb_root.rb_node;
|
|
|
|
|
|
|
|
while (**pos) {
|
|
|
|
*pos_parent = **pos;
|
|
|
|
cur = rb_entry(*pos_parent, struct ref_node, rb_node);
|
|
|
|
|
|
|
|
ret = ref_node_cmp(cur, &entry);
|
|
|
|
if (ret > 0)
|
|
|
|
*pos = &(**pos)->rb_left;
|
|
|
|
else if (ret < 0)
|
|
|
|
*pos = &(**pos)->rb_right;
|
|
|
|
else
|
|
|
|
return cur;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert a ref_node to the ref tree
|
|
|
|
* @pos used for specifiy the position to insert
|
|
|
|
* @pos_parent for specifiy pos's parent
|
|
|
|
*
|
|
|
|
* success, return 0;
|
|
|
|
* ref_node already exists, return -EEXIST;
|
|
|
|
*/
|
|
|
|
static int ref_tree_insert(struct ref_root *ref_tree, struct rb_node **pos,
|
|
|
|
struct rb_node *pos_parent, struct ref_node *ins)
|
|
|
|
{
|
|
|
|
struct rb_node **p = NULL;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct ref_node *cur = NULL;
|
|
|
|
|
|
|
|
if (!pos) {
|
|
|
|
cur = __ref_tree_search(ref_tree, &p, &parent, ins->root_id,
|
|
|
|
ins->object_id, ins->offset,
|
|
|
|
ins->parent);
|
|
|
|
if (cur)
|
|
|
|
return -EEXIST;
|
|
|
|
} else {
|
|
|
|
p = pos;
|
|
|
|
parent = pos_parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&ins->rb_node, parent, p);
|
|
|
|
rb_insert_color(&ins->rb_node, &ref_tree->rb_root);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Erase and free ref_node, caller should update ref_root->unique_refs */
|
|
|
|
static void ref_tree_remove(struct ref_root *ref_tree, struct ref_node *node)
|
|
|
|
{
|
|
|
|
rb_erase(&node->rb_node, &ref_tree->rb_root);
|
|
|
|
kfree(node);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update ref_root->unique_refs
|
|
|
|
*
|
|
|
|
* Call __ref_tree_search
|
|
|
|
* 1. if ref_node doesn't exist, ref_tree_insert this node, and update
|
|
|
|
* ref_root->unique_refs:
|
|
|
|
* if ref_node->ref_mod > 0, ref_root->unique_refs++;
|
|
|
|
* if ref_node->ref_mod < 0, do noting;
|
|
|
|
*
|
|
|
|
* 2. if ref_node is found, then get origin ref_node->ref_mod, and update
|
|
|
|
* ref_node->ref_mod.
|
|
|
|
* if ref_node->ref_mod is equal to 0,then call ref_tree_remove
|
|
|
|
*
|
|
|
|
* according to origin_mod and new_mod, update ref_root->items
|
|
|
|
* +----------------+--------------+-------------+
|
|
|
|
* | |new_count <= 0|new_count > 0|
|
|
|
|
* +----------------+--------------+-------------+
|
|
|
|
* |origin_count < 0| 0 | 1 |
|
|
|
|
* +----------------+--------------+-------------+
|
|
|
|
* |origin_count > 0| -1 | 0 |
|
|
|
|
* +----------------+--------------+-------------+
|
|
|
|
*
|
|
|
|
* In case of allocation failure, -ENOMEM is returned and the ref_tree stays
|
|
|
|
* unaltered.
|
|
|
|
* Success, return 0
|
|
|
|
*/
|
|
|
|
static int ref_tree_add(struct ref_root *ref_tree, u64 root_id, u64 object_id,
|
|
|
|
u64 offset, u64 parent, int count)
|
|
|
|
{
|
|
|
|
struct ref_node *node = NULL;
|
|
|
|
struct rb_node **pos = NULL;
|
|
|
|
struct rb_node *pos_parent = NULL;
|
|
|
|
int origin_count;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!count)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
node = __ref_tree_search(ref_tree, &pos, &pos_parent, root_id,
|
|
|
|
object_id, offset, parent);
|
|
|
|
if (node == NULL) {
|
|
|
|
node = kmalloc(sizeof(*node), GFP_NOFS);
|
|
|
|
if (!node)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
node->root_id = root_id;
|
|
|
|
node->object_id = object_id;
|
|
|
|
node->offset = offset;
|
|
|
|
node->parent = parent;
|
|
|
|
node->ref_mod = count;
|
|
|
|
|
|
|
|
ret = ref_tree_insert(ref_tree, pos, pos_parent, node);
|
|
|
|
ASSERT(!ret);
|
|
|
|
if (ret) {
|
|
|
|
kfree(node);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ref_tree->unique_refs += node->ref_mod > 0 ? 1 : 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
origin_count = node->ref_mod;
|
|
|
|
node->ref_mod += count;
|
|
|
|
|
|
|
|
if (node->ref_mod > 0)
|
|
|
|
ref_tree->unique_refs += origin_count > 0 ? 0 : 1;
|
|
|
|
else if (node->ref_mod <= 0)
|
|
|
|
ref_tree->unique_refs += origin_count > 0 ? -1 : 0;
|
|
|
|
|
|
|
|
if (!node->ref_mod)
|
|
|
|
ref_tree_remove(ref_tree, node);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-17 21:43:03 +07:00
|
|
|
static int check_extent_in_eb(struct btrfs_key *key, struct extent_buffer *eb,
|
|
|
|
struct btrfs_file_extent_item *fi,
|
|
|
|
u64 extent_item_pos,
|
|
|
|
struct extent_inode_elem **eie)
|
|
|
|
{
|
2013-07-06 00:58:19 +07:00
|
|
|
u64 offset = 0;
|
2012-05-17 21:43:03 +07:00
|
|
|
struct extent_inode_elem *e;
|
|
|
|
|
2013-07-06 00:58:19 +07:00
|
|
|
if (!btrfs_file_extent_compression(eb, fi) &&
|
|
|
|
!btrfs_file_extent_encryption(eb, fi) &&
|
|
|
|
!btrfs_file_extent_other_encoding(eb, fi)) {
|
|
|
|
u64 data_offset;
|
|
|
|
u64 data_len;
|
2012-05-17 21:43:03 +07:00
|
|
|
|
2013-07-06 00:58:19 +07: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 21:43:03 +07:00
|
|
|
|
|
|
|
e = kmalloc(sizeof(*e), GFP_NOFS);
|
|
|
|
if (!e)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
e->next = *eie;
|
|
|
|
e->inum = key->objectid;
|
2013-07-06 00:58:19 +07:00
|
|
|
e->offset = key->offset + offset;
|
2012-05-17 21:43:03 +07:00
|
|
|
*eie = e;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-28 18:13:38 +07: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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-17 21:43:03 +07:00
|
|
|
static int find_extent_in_eb(struct extent_buffer *eb, u64 wanted_disk_byte,
|
|
|
|
u64 extent_item_pos,
|
|
|
|
struct extent_inode_elem **eie)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
|
|
|
ret = check_extent_in_eb(&key, eb, fi, extent_item_pos, eie);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
/*
|
|
|
|
* this structure records all encountered refs on the way up to the root
|
|
|
|
*/
|
|
|
|
struct __prelim_ref {
|
|
|
|
struct list_head list;
|
|
|
|
u64 root_id;
|
2012-05-15 22:55:51 +07:00
|
|
|
struct btrfs_key key_for_search;
|
2011-11-24 00:55:04 +07:00
|
|
|
int level;
|
|
|
|
int count;
|
2012-05-30 23:05:21 +07:00
|
|
|
struct extent_inode_elem *inode_list;
|
2011-11-24 00:55:04 +07:00
|
|
|
u64 parent;
|
|
|
|
u64 wanted_disk_byte;
|
|
|
|
};
|
|
|
|
|
2013-08-09 12:25:36 +07: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",
|
|
|
|
sizeof(struct __prelim_ref),
|
|
|
|
0,
|
2016-06-24 01:17:08 +07:00
|
|
|
SLAB_MEM_SPREAD,
|
2013-08-09 12:25:36 +07:00
|
|
|
NULL);
|
|
|
|
if (!btrfs_prelim_ref_cache)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void btrfs_prelim_ref_exit(void)
|
|
|
|
{
|
2016-01-29 20:36:35 +07:00
|
|
|
kmem_cache_destroy(btrfs_prelim_ref_cache);
|
2013-08-09 12:25:36 +07:00
|
|
|
}
|
|
|
|
|
2012-05-15 22:55:51 +07: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
|
|
|
|
* (see __add_missing_keys)
|
|
|
|
* - 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.
|
|
|
|
*/
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
static int __add_prelim_ref(struct list_head *head, u64 root_id,
|
2012-05-15 22:55:51 +07:00
|
|
|
struct btrfs_key *key, int level,
|
2013-08-06 09:29:54 +07:00
|
|
|
u64 parent, u64 wanted_disk_byte, int count,
|
|
|
|
gfp_t gfp_mask)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
|
|
|
struct __prelim_ref *ref;
|
|
|
|
|
2013-10-30 12:25:24 +07:00
|
|
|
if (root_id == BTRFS_DATA_RELOC_TREE_OBJECTID)
|
|
|
|
return 0;
|
|
|
|
|
2013-08-09 12:25:36 +07:00
|
|
|
ref = kmem_cache_alloc(btrfs_prelim_ref_cache, gfp_mask);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (!ref)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ref->root_id = root_id;
|
Btrfs: teach backref walking about backrefs with underflowed offset values
When cloning/deduplicating file extents (through the clone and extent_same
ioctls) we can get data back references with offset values that are a
result of an unsigned integer arithmetic underflow, that is, values that
are much larger then they could be otherwise.
This is not a problem when decrementing or dropping the back references
(happens when we overwrite the extents or punch a hole for example, through
__btrfs_drop_extents()), since we compute the same too large offset value,
but it is a problem for the backref walking code, used by an incremental
send and the ioctls that are used by the btrfs tool "inspect-internal"
commands, as it makes it miss the corresponding file extent items because
the search key is set for an extent item that starts at an offset matching
the exceptionally large offset value of the data back reference. For an
incremental send this causes the send ioctl to fail with -EIO.
So teach the backref walking code to deal with these cases by setting the
search key's offset to 0 if the backref's offset value is larger than
LLONG_MAX (the largest possible file offset). This makes sure the backref
walking code finds the corresponding file extent items at the expense of
scanning more items and leafs in the btree.
Fixing the clone/dedup ioctls to not produce such underflowed results would
require major changes breaking backward compatibility, updating user space
tools, etc.
Simple reproducer case for fstests:
seq=`basename $0`
seqres=$RESULT_DIR/$seq
echo "QA output created by $seq"
tmp=/tmp/$$
status=1 # failure is the default!
trap "_cleanup; exit \$status" 0 1 2 3 15
_cleanup()
{
rm -fr $send_files_dir
rm -f $tmp.*
}
# get standard environment, filters and checks
. ./common/rc
. ./common/filter
# real QA test starts here
_supported_fs btrfs
_supported_os Linux
_require_scratch
_require_cloner
_need_to_be_root
send_files_dir=$TEST_DIR/btrfs-test-$seq
rm -f $seqres.full
rm -fr $send_files_dir
mkdir $send_files_dir
_scratch_mkfs >>$seqres.full 2>&1
_scratch_mount
# Create our test file with a single extent of 64K starting at file
# offset 128K.
$XFS_IO_PROG -f -c "pwrite -S 0xaa 128K 64K" $SCRATCH_MNT/foo \
| _filter_xfs_io
_run_btrfs_util_prog subvolume snapshot -r $SCRATCH_MNT \
$SCRATCH_MNT/mysnap1
# Now clone parts of the original extent into lower offsets of the file.
#
# The first clone operation adds a file extent item to file offset 0
# that points to our initial extent with a data offset of 16K. The
# corresponding data back reference in the extent tree has an offset of
# 18446744073709535232, which is the result of file_offset - data_offset
# = 0 - 16K.
#
# The second clone operation adds a file extent item to file offset 16K
# that points to our initial extent with a data offset of 48K. The
# corresponding data back reference in the extent tree has an offset of
# 18446744073709518848, which is the result of file_offset - data_offset
# = 16K - 48K.
#
# Those large back reference offsets (result of unsigned arithmetic
# underflow) confused the back reference walking code (used by an
# incremental send and the multiple inspect-internal ioctls) and made it
# miss the back references, which for the case of an incremental send it
# made it fail with -EIO and print a message like the following to
# dmesg:
#
# "BTRFS error (device sdc): did not find backref in send_root. \
# inode=257, offset=0, disk_byte=12845056 found extent=12845056"
#
$CLONER_PROG -s $(((128 + 16) * 1024)) -d 0 -l $((16 * 1024)) \
$SCRATCH_MNT/foo $SCRATCH_MNT/foo
$CLONER_PROG -s $(((128 + 48) * 1024)) -d $((16 * 1024)) \
-l $((16 * 1024)) $SCRATCH_MNT/foo $SCRATCH_MNT/foo
_run_btrfs_util_prog subvolume snapshot -r $SCRATCH_MNT \
$SCRATCH_MNT/mysnap2
_run_btrfs_util_prog send $SCRATCH_MNT/mysnap1 -f $send_files_dir/1.snap
_run_btrfs_util_prog send -p $SCRATCH_MNT/mysnap1 $SCRATCH_MNT/mysnap2 \
-f $send_files_dir/2.snap
echo "File digest in the original filesystem:"
md5sum $SCRATCH_MNT/mysnap2/foo | _filter_scratch
# Now recreate the filesystem by receiving both send streams and verify
# we get the same file contents that the original filesystem had.
_scratch_unmount
_scratch_mkfs >>$seqres.full 2>&1
_scratch_mount
_run_btrfs_util_prog receive $SCRATCH_MNT -f $send_files_dir/1.snap
_run_btrfs_util_prog receive $SCRATCH_MNT -f $send_files_dir/2.snap
echo "File digest in the new filesystem:"
md5sum $SCRATCH_MNT/mysnap2/foo | _filter_scratch
status=0
exit
The test's expected golden output is:
wrote 65536/65536 bytes at offset 131072
XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
File digest in the original filesystem:
6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
File digest in the new filesystem:
6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
But it failed with:
(...)
@@ -1,7 +1,5 @@
QA output created by 097
wrote 65536/65536 bytes at offset 131072
XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-File digest in the original filesystem:
-6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
-File digest in the new filesystem:
-6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
...
$ cat /home/fdmanana/git/hub/xfstests/results//btrfs/097.full
(...)
ERROR: send ioctl failed with -5: Input/output error
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-07-29 23:21:17 +07:00
|
|
|
if (key) {
|
2012-05-15 22:55:51 +07:00
|
|
|
ref->key_for_search = *key;
|
Btrfs: teach backref walking about backrefs with underflowed offset values
When cloning/deduplicating file extents (through the clone and extent_same
ioctls) we can get data back references with offset values that are a
result of an unsigned integer arithmetic underflow, that is, values that
are much larger then they could be otherwise.
This is not a problem when decrementing or dropping the back references
(happens when we overwrite the extents or punch a hole for example, through
__btrfs_drop_extents()), since we compute the same too large offset value,
but it is a problem for the backref walking code, used by an incremental
send and the ioctls that are used by the btrfs tool "inspect-internal"
commands, as it makes it miss the corresponding file extent items because
the search key is set for an extent item that starts at an offset matching
the exceptionally large offset value of the data back reference. For an
incremental send this causes the send ioctl to fail with -EIO.
So teach the backref walking code to deal with these cases by setting the
search key's offset to 0 if the backref's offset value is larger than
LLONG_MAX (the largest possible file offset). This makes sure the backref
walking code finds the corresponding file extent items at the expense of
scanning more items and leafs in the btree.
Fixing the clone/dedup ioctls to not produce such underflowed results would
require major changes breaking backward compatibility, updating user space
tools, etc.
Simple reproducer case for fstests:
seq=`basename $0`
seqres=$RESULT_DIR/$seq
echo "QA output created by $seq"
tmp=/tmp/$$
status=1 # failure is the default!
trap "_cleanup; exit \$status" 0 1 2 3 15
_cleanup()
{
rm -fr $send_files_dir
rm -f $tmp.*
}
# get standard environment, filters and checks
. ./common/rc
. ./common/filter
# real QA test starts here
_supported_fs btrfs
_supported_os Linux
_require_scratch
_require_cloner
_need_to_be_root
send_files_dir=$TEST_DIR/btrfs-test-$seq
rm -f $seqres.full
rm -fr $send_files_dir
mkdir $send_files_dir
_scratch_mkfs >>$seqres.full 2>&1
_scratch_mount
# Create our test file with a single extent of 64K starting at file
# offset 128K.
$XFS_IO_PROG -f -c "pwrite -S 0xaa 128K 64K" $SCRATCH_MNT/foo \
| _filter_xfs_io
_run_btrfs_util_prog subvolume snapshot -r $SCRATCH_MNT \
$SCRATCH_MNT/mysnap1
# Now clone parts of the original extent into lower offsets of the file.
#
# The first clone operation adds a file extent item to file offset 0
# that points to our initial extent with a data offset of 16K. The
# corresponding data back reference in the extent tree has an offset of
# 18446744073709535232, which is the result of file_offset - data_offset
# = 0 - 16K.
#
# The second clone operation adds a file extent item to file offset 16K
# that points to our initial extent with a data offset of 48K. The
# corresponding data back reference in the extent tree has an offset of
# 18446744073709518848, which is the result of file_offset - data_offset
# = 16K - 48K.
#
# Those large back reference offsets (result of unsigned arithmetic
# underflow) confused the back reference walking code (used by an
# incremental send and the multiple inspect-internal ioctls) and made it
# miss the back references, which for the case of an incremental send it
# made it fail with -EIO and print a message like the following to
# dmesg:
#
# "BTRFS error (device sdc): did not find backref in send_root. \
# inode=257, offset=0, disk_byte=12845056 found extent=12845056"
#
$CLONER_PROG -s $(((128 + 16) * 1024)) -d 0 -l $((16 * 1024)) \
$SCRATCH_MNT/foo $SCRATCH_MNT/foo
$CLONER_PROG -s $(((128 + 48) * 1024)) -d $((16 * 1024)) \
-l $((16 * 1024)) $SCRATCH_MNT/foo $SCRATCH_MNT/foo
_run_btrfs_util_prog subvolume snapshot -r $SCRATCH_MNT \
$SCRATCH_MNT/mysnap2
_run_btrfs_util_prog send $SCRATCH_MNT/mysnap1 -f $send_files_dir/1.snap
_run_btrfs_util_prog send -p $SCRATCH_MNT/mysnap1 $SCRATCH_MNT/mysnap2 \
-f $send_files_dir/2.snap
echo "File digest in the original filesystem:"
md5sum $SCRATCH_MNT/mysnap2/foo | _filter_scratch
# Now recreate the filesystem by receiving both send streams and verify
# we get the same file contents that the original filesystem had.
_scratch_unmount
_scratch_mkfs >>$seqres.full 2>&1
_scratch_mount
_run_btrfs_util_prog receive $SCRATCH_MNT -f $send_files_dir/1.snap
_run_btrfs_util_prog receive $SCRATCH_MNT -f $send_files_dir/2.snap
echo "File digest in the new filesystem:"
md5sum $SCRATCH_MNT/mysnap2/foo | _filter_scratch
status=0
exit
The test's expected golden output is:
wrote 65536/65536 bytes at offset 131072
XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
File digest in the original filesystem:
6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
File digest in the new filesystem:
6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
But it failed with:
(...)
@@ -1,7 +1,5 @@
QA output created by 097
wrote 65536/65536 bytes at offset 131072
XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-File digest in the original filesystem:
-6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
-File digest in the new filesystem:
-6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
...
$ cat /home/fdmanana/git/hub/xfstests/results//btrfs/097.full
(...)
ERROR: send ioctl failed with -5: Input/output error
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-07-29 23:21:17 +07: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 (ref->key_for_search.type == BTRFS_EXTENT_DATA_KEY &&
|
|
|
|
ref->key_for_search.offset >= LLONG_MAX)
|
|
|
|
ref->key_for_search.offset = 0;
|
|
|
|
} else {
|
2012-05-15 22:55:51 +07:00
|
|
|
memset(&ref->key_for_search, 0, sizeof(ref->key_for_search));
|
Btrfs: teach backref walking about backrefs with underflowed offset values
When cloning/deduplicating file extents (through the clone and extent_same
ioctls) we can get data back references with offset values that are a
result of an unsigned integer arithmetic underflow, that is, values that
are much larger then they could be otherwise.
This is not a problem when decrementing or dropping the back references
(happens when we overwrite the extents or punch a hole for example, through
__btrfs_drop_extents()), since we compute the same too large offset value,
but it is a problem for the backref walking code, used by an incremental
send and the ioctls that are used by the btrfs tool "inspect-internal"
commands, as it makes it miss the corresponding file extent items because
the search key is set for an extent item that starts at an offset matching
the exceptionally large offset value of the data back reference. For an
incremental send this causes the send ioctl to fail with -EIO.
So teach the backref walking code to deal with these cases by setting the
search key's offset to 0 if the backref's offset value is larger than
LLONG_MAX (the largest possible file offset). This makes sure the backref
walking code finds the corresponding file extent items at the expense of
scanning more items and leafs in the btree.
Fixing the clone/dedup ioctls to not produce such underflowed results would
require major changes breaking backward compatibility, updating user space
tools, etc.
Simple reproducer case for fstests:
seq=`basename $0`
seqres=$RESULT_DIR/$seq
echo "QA output created by $seq"
tmp=/tmp/$$
status=1 # failure is the default!
trap "_cleanup; exit \$status" 0 1 2 3 15
_cleanup()
{
rm -fr $send_files_dir
rm -f $tmp.*
}
# get standard environment, filters and checks
. ./common/rc
. ./common/filter
# real QA test starts here
_supported_fs btrfs
_supported_os Linux
_require_scratch
_require_cloner
_need_to_be_root
send_files_dir=$TEST_DIR/btrfs-test-$seq
rm -f $seqres.full
rm -fr $send_files_dir
mkdir $send_files_dir
_scratch_mkfs >>$seqres.full 2>&1
_scratch_mount
# Create our test file with a single extent of 64K starting at file
# offset 128K.
$XFS_IO_PROG -f -c "pwrite -S 0xaa 128K 64K" $SCRATCH_MNT/foo \
| _filter_xfs_io
_run_btrfs_util_prog subvolume snapshot -r $SCRATCH_MNT \
$SCRATCH_MNT/mysnap1
# Now clone parts of the original extent into lower offsets of the file.
#
# The first clone operation adds a file extent item to file offset 0
# that points to our initial extent with a data offset of 16K. The
# corresponding data back reference in the extent tree has an offset of
# 18446744073709535232, which is the result of file_offset - data_offset
# = 0 - 16K.
#
# The second clone operation adds a file extent item to file offset 16K
# that points to our initial extent with a data offset of 48K. The
# corresponding data back reference in the extent tree has an offset of
# 18446744073709518848, which is the result of file_offset - data_offset
# = 16K - 48K.
#
# Those large back reference offsets (result of unsigned arithmetic
# underflow) confused the back reference walking code (used by an
# incremental send and the multiple inspect-internal ioctls) and made it
# miss the back references, which for the case of an incremental send it
# made it fail with -EIO and print a message like the following to
# dmesg:
#
# "BTRFS error (device sdc): did not find backref in send_root. \
# inode=257, offset=0, disk_byte=12845056 found extent=12845056"
#
$CLONER_PROG -s $(((128 + 16) * 1024)) -d 0 -l $((16 * 1024)) \
$SCRATCH_MNT/foo $SCRATCH_MNT/foo
$CLONER_PROG -s $(((128 + 48) * 1024)) -d $((16 * 1024)) \
-l $((16 * 1024)) $SCRATCH_MNT/foo $SCRATCH_MNT/foo
_run_btrfs_util_prog subvolume snapshot -r $SCRATCH_MNT \
$SCRATCH_MNT/mysnap2
_run_btrfs_util_prog send $SCRATCH_MNT/mysnap1 -f $send_files_dir/1.snap
_run_btrfs_util_prog send -p $SCRATCH_MNT/mysnap1 $SCRATCH_MNT/mysnap2 \
-f $send_files_dir/2.snap
echo "File digest in the original filesystem:"
md5sum $SCRATCH_MNT/mysnap2/foo | _filter_scratch
# Now recreate the filesystem by receiving both send streams and verify
# we get the same file contents that the original filesystem had.
_scratch_unmount
_scratch_mkfs >>$seqres.full 2>&1
_scratch_mount
_run_btrfs_util_prog receive $SCRATCH_MNT -f $send_files_dir/1.snap
_run_btrfs_util_prog receive $SCRATCH_MNT -f $send_files_dir/2.snap
echo "File digest in the new filesystem:"
md5sum $SCRATCH_MNT/mysnap2/foo | _filter_scratch
status=0
exit
The test's expected golden output is:
wrote 65536/65536 bytes at offset 131072
XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
File digest in the original filesystem:
6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
File digest in the new filesystem:
6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
But it failed with:
(...)
@@ -1,7 +1,5 @@
QA output created by 097
wrote 65536/65536 bytes at offset 131072
XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-File digest in the original filesystem:
-6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
-File digest in the new filesystem:
-6c6079335cff141b8a31233ead04cbff SCRATCH_MNT/mysnap2/foo
...
$ cat /home/fdmanana/git/hub/xfstests/results//btrfs/097.full
(...)
ERROR: send ioctl failed with -5: Input/output error
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-07-29 23:21:17 +07:00
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2012-05-30 23:05:21 +07:00
|
|
|
ref->inode_list = NULL;
|
2011-11-24 00:55:04 +07:00
|
|
|
ref->level = level;
|
|
|
|
ref->count = count;
|
|
|
|
ref->parent = parent;
|
|
|
|
ref->wanted_disk_byte = wanted_disk_byte;
|
|
|
|
list_add_tail(&ref->list, head);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path,
|
2014-01-25 02:05:42 +07:00
|
|
|
struct ulist *parents, struct __prelim_ref *ref,
|
2014-03-20 00:35:14 +07:00
|
|
|
int level, u64 time_seq, const u64 *extent_item_pos,
|
|
|
|
u64 total_refs)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
2012-06-19 20:42:26 +07:00
|
|
|
int ret = 0;
|
|
|
|
int slot;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
struct btrfs_key key;
|
2014-01-25 02:05:42 +07:00
|
|
|
struct btrfs_key *key_for_search = &ref->key_for_search;
|
2011-11-24 00:55:04 +07:00
|
|
|
struct btrfs_file_extent_item *fi;
|
2013-07-06 01:03:47 +07:00
|
|
|
struct extent_inode_elem *eie = NULL, *old = NULL;
|
2011-11-24 00:55:04 +07:00
|
|
|
u64 disk_byte;
|
2014-01-25 02:05:42 +07:00
|
|
|
u64 wanted_disk_byte = ref->wanted_disk_byte;
|
|
|
|
u64 count = 0;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2012-06-19 20:42:26 +07:00
|
|
|
if (level != 0) {
|
|
|
|
eb = path->nodes[level];
|
|
|
|
ret = ulist_add(parents, eb->start, 0, GFP_NOFS);
|
2012-05-30 23:05:21 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-11-24 00:55:04 +07:00
|
|
|
return 0;
|
2012-06-19 20:42:26 +07:00
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
/*
|
2012-06-19 20:42:26 +07:00
|
|
|
* 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. In that case, go to the next leaf before we continue.
|
2011-11-24 00:55:04 +07:00
|
|
|
*/
|
2015-04-16 13:54:50 +07:00
|
|
|
if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
|
|
|
|
if (time_seq == (u64)-1)
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
else
|
|
|
|
ret = btrfs_next_old_leaf(root, path, time_seq);
|
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2014-03-20 00:35:14 +07:00
|
|
|
while (!ret && count < total_refs) {
|
2011-11-24 00:55:04 +07:00
|
|
|
eb = path->nodes[0];
|
2012-06-19 20:42:26 +07: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;
|
|
|
|
|
|
|
|
fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
|
|
|
|
disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
|
|
|
|
|
|
|
|
if (disk_byte == wanted_disk_byte) {
|
|
|
|
eie = NULL;
|
2013-07-06 01:03:47 +07:00
|
|
|
old = NULL;
|
2014-01-25 02:05:42 +07:00
|
|
|
count++;
|
2012-06-19 20:42:26 +07:00
|
|
|
if (extent_item_pos) {
|
|
|
|
ret = check_extent_in_eb(&key, eb, fi,
|
|
|
|
*extent_item_pos,
|
|
|
|
&eie);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
}
|
2013-07-06 01:03:47 +07:00
|
|
|
if (ret > 0)
|
|
|
|
goto next;
|
2014-07-28 15:57:04 +07:00
|
|
|
ret = ulist_add_merge_ptr(parents, eb->start,
|
|
|
|
eie, (void **)&old, GFP_NOFS);
|
2013-07-06 01:03:47 +07:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
if (!ret && extent_item_pos) {
|
|
|
|
while (old->next)
|
|
|
|
old = old->next;
|
|
|
|
old->next = eie;
|
2012-06-19 20:42:26 +07:00
|
|
|
}
|
2014-01-28 18:13:38 +07:00
|
|
|
eie = NULL;
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
2013-07-06 01:03:47 +07:00
|
|
|
next:
|
2015-04-16 13:54:50 +07:00
|
|
|
if (time_seq == (u64)-1)
|
|
|
|
ret = btrfs_next_item(root, path);
|
|
|
|
else
|
|
|
|
ret = btrfs_next_old_item(root, path, time_seq);
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
2012-06-19 20:42:26 +07:00
|
|
|
if (ret > 0)
|
|
|
|
ret = 0;
|
2014-01-28 18:13:38 +07:00
|
|
|
else if (ret < 0)
|
|
|
|
free_inode_elem_list(eie);
|
2012-06-19 20:42:26 +07:00
|
|
|
return ret;
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* resolve an indirect backref in the form (root_id, key, level)
|
|
|
|
* to a logical address
|
|
|
|
*/
|
|
|
|
static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
|
2013-06-13 03:20:08 +07:00
|
|
|
struct btrfs_path *path, u64 time_seq,
|
|
|
|
struct __prelim_ref *ref,
|
|
|
|
struct ulist *parents,
|
2014-03-20 00:35:14 +07:00
|
|
|
const u64 *extent_item_pos, u64 total_refs)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
|
|
|
struct btrfs_root *root;
|
|
|
|
struct btrfs_key root_key;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
int ret = 0;
|
|
|
|
int root_level;
|
|
|
|
int level = ref->level;
|
2014-01-23 12:47:48 +07:00
|
|
|
int index;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
root_key.objectid = ref->root_id;
|
|
|
|
root_key.type = BTRFS_ROOT_ITEM_KEY;
|
|
|
|
root_key.offset = (u64)-1;
|
2014-01-23 12:47:48 +07:00
|
|
|
|
|
|
|
index = srcu_read_lock(&fs_info->subvol_srcu);
|
|
|
|
|
2015-11-06 05:37:58 +07:00
|
|
|
root = btrfs_get_fs_root(fs_info, &root_key, false);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (IS_ERR(root)) {
|
2014-01-23 12:47:48 +07:00
|
|
|
srcu_read_unlock(&fs_info->subvol_srcu, index);
|
2011-11-24 00:55:04 +07:00
|
|
|
ret = PTR_ERR(root);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-06-21 20:52:41 +07:00
|
|
|
if (btrfs_is_testing(fs_info)) {
|
2015-10-05 21:35:29 +07:00
|
|
|
srcu_read_unlock(&fs_info->subvol_srcu, index);
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:42:13 +07:00
|
|
|
if (path->search_commit_root)
|
|
|
|
root_level = btrfs_header_level(root->commit_root);
|
2015-04-16 13:54:50 +07:00
|
|
|
else if (time_seq == (u64)-1)
|
|
|
|
root_level = btrfs_header_level(root->node);
|
2014-03-14 02:42:13 +07:00
|
|
|
else
|
|
|
|
root_level = btrfs_old_root_level(root, time_seq);
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2014-01-23 12:47:48 +07:00
|
|
|
if (root_level + 1 == level) {
|
|
|
|
srcu_read_unlock(&fs_info->subvol_srcu, index);
|
2011-11-24 00:55:04 +07:00
|
|
|
goto out;
|
2014-01-23 12:47:48 +07:00
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
path->lowest_level = level;
|
2015-04-16 13:54:50 +07:00
|
|
|
if (time_seq == (u64)-1)
|
|
|
|
ret = btrfs_search_slot(NULL, root, &ref->key_for_search, path,
|
|
|
|
0, 0);
|
|
|
|
else
|
|
|
|
ret = btrfs_search_old_slot(root, &ref->key_for_search, path,
|
|
|
|
time_seq);
|
2014-01-23 12:47:48 +07:00
|
|
|
|
|
|
|
/* root node has been locked, we can release @subvol_srcu safely here */
|
|
|
|
srcu_read_unlock(&fs_info->subvol_srcu, index);
|
|
|
|
|
2016-09-20 21:05:02 +07: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 18:20:07 +07: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-24 00:55:04 +07:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
eb = path->nodes[level];
|
2012-06-27 20:23:09 +07:00
|
|
|
while (!eb) {
|
2013-10-31 12:00:08 +07:00
|
|
|
if (WARN_ON(!level)) {
|
2012-06-27 20:23:09 +07:00
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
level--;
|
|
|
|
eb = path->nodes[level];
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
2014-01-25 02:05:42 +07:00
|
|
|
ret = add_all_parents(root, path, parents, ref, level, time_seq,
|
2014-03-20 00:35:14 +07:00
|
|
|
extent_item_pos, total_refs);
|
2011-11-24 00:55:04 +07:00
|
|
|
out:
|
2013-06-13 03:20:08 +07:00
|
|
|
path->lowest_level = 0;
|
|
|
|
btrfs_release_path(path);
|
2011-11-24 00:55:04 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* resolve all indirect backrefs from the list
|
|
|
|
*/
|
|
|
|
static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info,
|
2013-06-13 03:20:08 +07:00
|
|
|
struct btrfs_path *path, u64 time_seq,
|
2012-05-17 21:43:03 +07:00
|
|
|
struct list_head *head,
|
2014-09-11 03:20:45 +07:00
|
|
|
const u64 *extent_item_pos, u64 total_refs,
|
|
|
|
u64 root_objectid)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int ret = 0;
|
|
|
|
struct __prelim_ref *ref;
|
|
|
|
struct __prelim_ref *ref_safe;
|
|
|
|
struct __prelim_ref *new_ref;
|
|
|
|
struct ulist *parents;
|
|
|
|
struct ulist_node *node;
|
2012-05-22 19:56:50 +07:00
|
|
|
struct ulist_iterator uiter;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
parents = ulist_alloc(GFP_NOFS);
|
|
|
|
if (!parents)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* _safe allows us to insert directly after the current item without
|
|
|
|
* iterating over the newly inserted items.
|
|
|
|
* we're also allowed to re-assign ref during iteration.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_safe(ref, ref_safe, head, list) {
|
|
|
|
if (ref->parent) /* already direct */
|
|
|
|
continue;
|
|
|
|
if (ref->count == 0)
|
|
|
|
continue;
|
2014-09-11 03:20:45 +07:00
|
|
|
if (root_objectid && ref->root_id != root_objectid) {
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
goto out;
|
|
|
|
}
|
2013-06-13 03:20:08 +07:00
|
|
|
err = __resolve_indirect_ref(fs_info, path, time_seq, ref,
|
2014-03-20 00:35:14 +07:00
|
|
|
parents, extent_item_pos,
|
|
|
|
total_refs);
|
2014-01-23 12:47:49 +07:00
|
|
|
/*
|
|
|
|
* we can only tolerate ENOENT,otherwise,we should catch error
|
|
|
|
* and return directly.
|
|
|
|
*/
|
|
|
|
if (err == -ENOENT) {
|
2011-11-24 00:55:04 +07:00
|
|
|
continue;
|
2014-01-23 12:47:49 +07:00
|
|
|
} else if (err) {
|
|
|
|
ret = err;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
/* we put the first parent into the ref at hand */
|
2012-05-22 19:56:50 +07:00
|
|
|
ULIST_ITER_INIT(&uiter);
|
|
|
|
node = ulist_next(parents, &uiter);
|
2011-11-24 00:55:04 +07:00
|
|
|
ref->parent = node ? node->val : 0;
|
2012-08-13 15:52:38 +07:00
|
|
|
ref->inode_list = node ?
|
2013-08-14 23:12:25 +07:00
|
|
|
(struct extent_inode_elem *)(uintptr_t)node->aux : NULL;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
/* additional parents require new refs being added here */
|
2012-05-22 19:56:50 +07:00
|
|
|
while ((node = ulist_next(parents, &uiter))) {
|
2013-08-09 12:25:36 +07:00
|
|
|
new_ref = kmem_cache_alloc(btrfs_prelim_ref_cache,
|
|
|
|
GFP_NOFS);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (!new_ref) {
|
|
|
|
ret = -ENOMEM;
|
2013-04-15 17:26:38 +07:00
|
|
|
goto out;
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
memcpy(new_ref, ref, sizeof(*ref));
|
|
|
|
new_ref->parent = node->val;
|
2012-08-13 15:52:38 +07:00
|
|
|
new_ref->inode_list = (struct extent_inode_elem *)
|
|
|
|
(uintptr_t)node->aux;
|
2011-11-24 00:55:04 +07:00
|
|
|
list_add(&new_ref->list, &ref->list);
|
|
|
|
}
|
|
|
|
ulist_reinit(parents);
|
|
|
|
}
|
2013-04-15 17:26:38 +07:00
|
|
|
out:
|
2011-11-24 00:55:04 +07:00
|
|
|
ulist_free(parents);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-15 22:55:51 +07:00
|
|
|
static inline int ref_for_same_block(struct __prelim_ref *ref1,
|
|
|
|
struct __prelim_ref *ref2)
|
|
|
|
{
|
|
|
|
if (ref1->level != ref2->level)
|
|
|
|
return 0;
|
|
|
|
if (ref1->root_id != ref2->root_id)
|
|
|
|
return 0;
|
|
|
|
if (ref1->key_for_search.type != ref2->key_for_search.type)
|
|
|
|
return 0;
|
|
|
|
if (ref1->key_for_search.objectid != ref2->key_for_search.objectid)
|
|
|
|
return 0;
|
|
|
|
if (ref1->key_for_search.offset != ref2->key_for_search.offset)
|
|
|
|
return 0;
|
|
|
|
if (ref1->parent != ref2->parent)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* read tree blocks and add keys where required.
|
|
|
|
*/
|
|
|
|
static int __add_missing_keys(struct btrfs_fs_info *fs_info,
|
|
|
|
struct list_head *head)
|
|
|
|
{
|
2015-12-21 22:50:23 +07:00
|
|
|
struct __prelim_ref *ref;
|
2012-05-15 22:55:51 +07:00
|
|
|
struct extent_buffer *eb;
|
|
|
|
|
2015-12-21 22:50:23 +07:00
|
|
|
list_for_each_entry(ref, head, list) {
|
2012-05-15 22:55:51 +07:00
|
|
|
if (ref->parent)
|
|
|
|
continue;
|
|
|
|
if (ref->key_for_search.type)
|
|
|
|
continue;
|
|
|
|
BUG_ON(!ref->wanted_disk_byte);
|
|
|
|
eb = read_tree_block(fs_info->tree_root, ref->wanted_disk_byte,
|
2014-06-15 06:07:32 +07:00
|
|
|
0);
|
2015-05-25 16:30:15 +07:00
|
|
|
if (IS_ERR(eb)) {
|
|
|
|
return PTR_ERR(eb);
|
|
|
|
} else if (!extent_buffer_uptodate(eb)) {
|
2013-04-24 01:17:42 +07:00
|
|
|
free_extent_buffer(eb);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2012-05-15 22:55:51 +07:00
|
|
|
btrfs_tree_read_lock(eb);
|
|
|
|
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_tree_read_unlock(eb);
|
|
|
|
free_extent_buffer(eb);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
/*
|
2015-04-01 13:39:06 +07:00
|
|
|
* merge backrefs and adjust counts accordingly
|
2011-11-24 00:55:04 +07:00
|
|
|
*
|
|
|
|
* mode = 1: merge identical keys, if key is set
|
2012-05-15 22:55:51 +07:00
|
|
|
* FIXME: if we add more keys in __add_prelim_ref, we can merge more here.
|
|
|
|
* additionally, we could even add a key range for the blocks we
|
|
|
|
* looked into to merge even more (-> replace unresolved refs by those
|
|
|
|
* having a parent).
|
2011-11-24 00:55:04 +07:00
|
|
|
* mode = 2: merge identical parents
|
|
|
|
*/
|
2013-04-11 14:08:55 +07:00
|
|
|
static void __merge_refs(struct list_head *head, int mode)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
2016-01-13 21:08:01 +07:00
|
|
|
struct __prelim_ref *pos1;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2016-01-13 21:08:01 +07:00
|
|
|
list_for_each_entry(pos1, head, list) {
|
|
|
|
struct __prelim_ref *pos2 = pos1, *tmp;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2016-01-13 21:08:01 +07:00
|
|
|
list_for_each_entry_safe_continue(pos2, tmp, head, list) {
|
2016-01-29 03:28:35 +07:00
|
|
|
struct __prelim_ref *ref1 = pos1, *ref2 = pos2;
|
2012-11-09 04:27:24 +07:00
|
|
|
struct extent_inode_elem *eie;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2015-04-01 13:39:06 +07:00
|
|
|
if (!ref_for_same_block(ref1, ref2))
|
|
|
|
continue;
|
2011-11-24 00:55:04 +07:00
|
|
|
if (mode == 1) {
|
2016-01-29 03:28:35 +07:00
|
|
|
if (!ref1->parent && ref2->parent)
|
|
|
|
swap(ref1, ref2);
|
2011-11-24 00:55:04 +07:00
|
|
|
} else {
|
|
|
|
if (ref1->parent != ref2->parent)
|
|
|
|
continue;
|
|
|
|
}
|
2012-11-09 04:27:24 +07:00
|
|
|
|
|
|
|
eie = ref1->inode_list;
|
|
|
|
while (eie && eie->next)
|
|
|
|
eie = eie->next;
|
|
|
|
if (eie)
|
|
|
|
eie->next = ref2->inode_list;
|
|
|
|
else
|
|
|
|
ref1->inode_list = ref2->inode_list;
|
|
|
|
ref1->count += ref2->count;
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
list_del(&ref2->list);
|
2013-08-09 12:25:36 +07:00
|
|
|
kmem_cache_free(btrfs_prelim_ref_cache, ref2);
|
2016-07-20 14:04:18 +07:00
|
|
|
cond_resched();
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* add all currently queued delayed refs from this head whose seq nr is
|
|
|
|
* smaller or equal that seq to the list
|
|
|
|
*/
|
|
|
|
static int __add_delayed_refs(struct btrfs_delayed_ref_head *head, u64 seq,
|
2014-09-11 03:20:45 +07:00
|
|
|
struct list_head *prefs, u64 *total_refs,
|
|
|
|
u64 inum)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
2015-03-30 16:03:00 +07:00
|
|
|
struct btrfs_delayed_ref_node *node;
|
2011-11-24 00:55:04 +07:00
|
|
|
struct btrfs_delayed_extent_op *extent_op = head->extent_op;
|
2012-05-15 22:55:51 +07:00
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key op_key = {0};
|
2011-11-24 00:55:04 +07:00
|
|
|
int sgn;
|
2012-01-27 03:01:11 +07:00
|
|
|
int ret = 0;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
if (extent_op && extent_op->update_key)
|
2012-05-15 22:55:51 +07:00
|
|
|
btrfs_disk_key_to_cpu(&op_key, &extent_op->key);
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2014-01-23 21:21:38 +07:00
|
|
|
spin_lock(&head->lock);
|
2015-03-30 16:03:00 +07:00
|
|
|
list_for_each_entry(node, &head->ref_list, list) {
|
2011-11-24 00:55:04 +07: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:
|
|
|
|
sgn = 1;
|
|
|
|
break;
|
|
|
|
case BTRFS_DROP_DELAYED_REF:
|
|
|
|
sgn = -1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
2014-03-20 00:35:14 +07:00
|
|
|
*total_refs += (node->ref_mod * sgn);
|
2011-11-24 00:55:04 +07:00
|
|
|
switch (node->type) {
|
|
|
|
case BTRFS_TREE_BLOCK_REF_KEY: {
|
|
|
|
struct btrfs_delayed_tree_ref *ref;
|
|
|
|
|
|
|
|
ref = btrfs_delayed_node_to_tree_ref(node);
|
2012-05-15 22:55:51 +07:00
|
|
|
ret = __add_prelim_ref(prefs, ref->root, &op_key,
|
2011-11-24 00:55:04 +07:00
|
|
|
ref->level + 1, 0, node->bytenr,
|
2013-08-06 09:29:54 +07:00
|
|
|
node->ref_mod * sgn, GFP_ATOMIC);
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_SHARED_BLOCK_REF_KEY: {
|
|
|
|
struct btrfs_delayed_tree_ref *ref;
|
|
|
|
|
|
|
|
ref = btrfs_delayed_node_to_tree_ref(node);
|
Btrfs: fix warning in backref walking
When we do backref walking, we search firstly in queued delayed refs
and then the on-disk backrefs, but we parse differently for shared
references, for delayed refs we also add 'ref->root' while for on-disk
backrefs we don't, this can prevent us from merging refs indexed
by the same bytenr and cause find_parent_nodes() to throw a warning at
'WARN_ON(ref->count < 0)', for example, when we have a shared data extent
with 'ref_cnt=1' and a delayed shared data with a BTRFS_DROP_DELAYED_REF,
that happens.
For shared references, no matter if it's delayed or on-disk, ref->root is
not at all used, instead it's ref->parent that really matters, so this has
delayed refs handled as the same way as on-disk refs.
Signed-off-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-07-28 17:03:30 +07:00
|
|
|
ret = __add_prelim_ref(prefs, 0, NULL,
|
2011-11-24 00:55:04 +07:00
|
|
|
ref->level + 1, ref->parent,
|
|
|
|
node->bytenr,
|
2013-08-06 09:29:54 +07:00
|
|
|
node->ref_mod * sgn, GFP_ATOMIC);
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_EXTENT_DATA_REF_KEY: {
|
|
|
|
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 03:20:45 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Found a inum that doesn't match our known inum, we
|
|
|
|
* know it's shared.
|
|
|
|
*/
|
|
|
|
if (inum && ref->objectid != inum) {
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
ret = __add_prelim_ref(prefs, ref->root, &key, 0, 0,
|
|
|
|
node->bytenr,
|
2013-08-06 09:29:54 +07:00
|
|
|
node->ref_mod * sgn, GFP_ATOMIC);
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_SHARED_DATA_REF_KEY: {
|
|
|
|
struct btrfs_delayed_data_ref *ref;
|
|
|
|
|
|
|
|
ref = btrfs_delayed_node_to_data_ref(node);
|
Btrfs: fix warning in backref walking
When we do backref walking, we search firstly in queued delayed refs
and then the on-disk backrefs, but we parse differently for shared
references, for delayed refs we also add 'ref->root' while for on-disk
backrefs we don't, this can prevent us from merging refs indexed
by the same bytenr and cause find_parent_nodes() to throw a warning at
'WARN_ON(ref->count < 0)', for example, when we have a shared data extent
with 'ref_cnt=1' and a delayed shared data with a BTRFS_DROP_DELAYED_REF,
that happens.
For shared references, no matter if it's delayed or on-disk, ref->root is
not at all used, instead it's ref->parent that really matters, so this has
delayed refs handled as the same way as on-disk refs.
Signed-off-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Chris Mason <clm@fb.com>
2015-07-28 17:03:30 +07:00
|
|
|
ret = __add_prelim_ref(prefs, 0, NULL, 0,
|
2011-11-24 00:55:04 +07:00
|
|
|
ref->parent, node->bytenr,
|
2013-08-06 09:29:54 +07:00
|
|
|
node->ref_mod * sgn, GFP_ATOMIC);
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
2013-04-10 18:22:50 +07:00
|
|
|
if (ret)
|
2014-01-23 21:21:38 +07:00
|
|
|
break;
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
2014-01-23 21:21:38 +07:00
|
|
|
spin_unlock(&head->lock);
|
|
|
|
return ret;
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* add all inline backrefs for bytenr to the list
|
|
|
|
*/
|
|
|
|
static int __add_inline_refs(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_path *path, u64 bytenr,
|
2014-03-20 00:35:14 +07:00
|
|
|
int *info_level, struct list_head *prefs,
|
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 08:36:46 +07:00
|
|
|
struct ref_root *ref_tree,
|
2014-09-11 03:20:45 +07:00
|
|
|
u64 *total_refs, u64 inum)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
2012-01-27 03:01:11 +07:00
|
|
|
int ret = 0;
|
2011-11-24 00:55:04 +07:00
|
|
|
int slot;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key key;
|
2013-06-29 00:11:22 +07:00
|
|
|
struct btrfs_key found_key;
|
2011-11-24 00:55:04 +07: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 18:43:25 +07:00
|
|
|
slot = path->slots[0];
|
2011-11-24 00:55:04 +07: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);
|
2014-03-20 00:35:14 +07:00
|
|
|
*total_refs += btrfs_extent_refs(leaf, ei);
|
2013-06-29 00:11:22 +07:00
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, slot);
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
ptr = (unsigned long)(ei + 1);
|
|
|
|
end = (unsigned long)ei + item_size;
|
|
|
|
|
2013-06-29 00:11:22 +07:00
|
|
|
if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
|
|
|
|
flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
|
2011-11-24 00:55:04 +07: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-29 00:11:22 +07:00
|
|
|
} else if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
|
|
|
|
*info_level = found_key.offset;
|
2011-11-24 00:55:04 +07: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;
|
|
|
|
type = btrfs_extent_inline_ref_type(leaf, iref);
|
|
|
|
offset = btrfs_extent_inline_ref_offset(leaf, iref);
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case BTRFS_SHARED_BLOCK_REF_KEY:
|
2012-05-15 22:55:51 +07:00
|
|
|
ret = __add_prelim_ref(prefs, 0, NULL,
|
2011-11-24 00:55:04 +07:00
|
|
|
*info_level + 1, offset,
|
2013-08-06 09:29:54 +07:00
|
|
|
bytenr, 1, GFP_NOFS);
|
2011-11-24 00:55:04 +07: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);
|
|
|
|
ret = __add_prelim_ref(prefs, 0, NULL, 0, offset,
|
2013-08-06 09:29:54 +07:00
|
|
|
bytenr, count, GFP_NOFS);
|
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 08:36:46 +07:00
|
|
|
if (ref_tree) {
|
|
|
|
if (!ret)
|
|
|
|
ret = ref_tree_add(ref_tree, 0, 0, 0,
|
|
|
|
bytenr, count);
|
|
|
|
if (!ret && ref_tree->unique_refs > 1)
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_TREE_BLOCK_REF_KEY:
|
2012-05-15 22:55:51 +07:00
|
|
|
ret = __add_prelim_ref(prefs, offset, NULL,
|
|
|
|
*info_level + 1, 0,
|
2013-08-06 09:29:54 +07:00
|
|
|
bytenr, 1, GFP_NOFS);
|
2011-11-24 00:55:04 +07: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 03:20:45 +07:00
|
|
|
|
|
|
|
if (inum && key.objectid != inum) {
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
root = btrfs_extent_data_ref_root(leaf, dref);
|
2012-05-15 22:55:51 +07:00
|
|
|
ret = __add_prelim_ref(prefs, root, &key, 0, 0,
|
2013-08-06 09:29:54 +07:00
|
|
|
bytenr, count, GFP_NOFS);
|
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 08:36:46 +07:00
|
|
|
if (ref_tree) {
|
|
|
|
if (!ret)
|
|
|
|
ret = ref_tree_add(ref_tree, root,
|
|
|
|
key.objectid,
|
|
|
|
key.offset, 0,
|
|
|
|
count);
|
|
|
|
if (!ret && ref_tree->unique_refs > 1)
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
2013-04-10 18:22:50 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-11-24 00:55:04 +07:00
|
|
|
ptr += btrfs_extent_inline_ref_size(type);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* add all non-inline backrefs for bytenr to the list
|
|
|
|
*/
|
|
|
|
static int __add_keyed_refs(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_path *path, u64 bytenr,
|
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 08:36:46 +07:00
|
|
|
int info_level, struct list_head *prefs,
|
|
|
|
struct ref_root *ref_tree, u64 inum)
|
2011-11-24 00:55:04 +07: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:
|
2012-05-15 22:55:51 +07:00
|
|
|
ret = __add_prelim_ref(prefs, 0, NULL,
|
2011-11-24 00:55:04 +07:00
|
|
|
info_level + 1, key.offset,
|
2013-08-06 09:29:54 +07:00
|
|
|
bytenr, 1, GFP_NOFS);
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
case BTRFS_SHARED_DATA_REF_KEY: {
|
|
|
|
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);
|
|
|
|
ret = __add_prelim_ref(prefs, 0, NULL, 0, key.offset,
|
2013-08-06 09:29:54 +07:00
|
|
|
bytenr, count, GFP_NOFS);
|
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 08:36:46 +07:00
|
|
|
if (ref_tree) {
|
|
|
|
if (!ret)
|
|
|
|
ret = ref_tree_add(ref_tree, 0, 0, 0,
|
|
|
|
bytenr, count);
|
|
|
|
if (!ret && ref_tree->unique_refs > 1)
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTRFS_TREE_BLOCK_REF_KEY:
|
2012-05-15 22:55:51 +07:00
|
|
|
ret = __add_prelim_ref(prefs, key.offset, NULL,
|
|
|
|
info_level + 1, 0,
|
2013-08-06 09:29:54 +07:00
|
|
|
bytenr, 1, GFP_NOFS);
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
case BTRFS_EXTENT_DATA_REF_KEY: {
|
|
|
|
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 03:20:45 +07:00
|
|
|
|
|
|
|
if (inum && key.objectid != inum) {
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
root = btrfs_extent_data_ref_root(leaf, dref);
|
|
|
|
ret = __add_prelim_ref(prefs, root, &key, 0, 0,
|
2013-08-06 09:29:54 +07:00
|
|
|
bytenr, count, GFP_NOFS);
|
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 08:36:46 +07:00
|
|
|
if (ref_tree) {
|
|
|
|
if (!ret)
|
|
|
|
ret = ref_tree_add(ref_tree, root,
|
|
|
|
key.objectid,
|
|
|
|
key.offset, 0,
|
|
|
|
count);
|
|
|
|
if (!ret && ref_tree->unique_refs > 1)
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
2013-04-10 18:22:50 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2011-11-24 00:55:04 +07: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
|
|
|
|
*
|
2015-05-20 02:49:50 +07:00
|
|
|
* NOTE: This can return values > 0
|
|
|
|
*
|
2015-04-16 13:54:50 +07:00
|
|
|
* If time_seq is set to (u64)-1, it will not search delayed_refs, and behave
|
|
|
|
* much like trans == NULL case, the difference only lies in it will not
|
|
|
|
* commit root.
|
|
|
|
* The special case is for qgroup to search roots in commit_transaction().
|
|
|
|
*
|
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 08:36:46 +07:00
|
|
|
* If check_shared is set to 1, any extent has more than one ref item, will
|
|
|
|
* be returned BACKREF_FOUND_SHARED immediately.
|
|
|
|
*
|
2011-11-24 00:55:04 +07: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 16:08:04 +07:00
|
|
|
u64 time_seq, struct ulist *refs,
|
2014-09-11 03:20:45 +07:00
|
|
|
struct ulist *roots, const u64 *extent_item_pos,
|
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 08:36:46 +07:00
|
|
|
u64 root_objectid, u64 inum, int check_shared)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_delayed_ref_root *delayed_refs = NULL;
|
2012-03-03 19:41:15 +07:00
|
|
|
struct btrfs_delayed_ref_head *head;
|
2011-11-24 00:55:04 +07:00
|
|
|
int info_level = 0;
|
|
|
|
int ret;
|
|
|
|
struct list_head prefs_delayed;
|
|
|
|
struct list_head prefs;
|
|
|
|
struct __prelim_ref *ref;
|
2014-01-28 18:13:38 +07:00
|
|
|
struct extent_inode_elem *eie = NULL;
|
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 08:36:46 +07:00
|
|
|
struct ref_root *ref_tree = NULL;
|
2014-03-20 00:35:14 +07:00
|
|
|
u64 total_refs = 0;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&prefs);
|
|
|
|
INIT_LIST_HEAD(&prefs_delayed);
|
|
|
|
|
|
|
|
key.objectid = bytenr;
|
|
|
|
key.offset = (u64)-1;
|
2013-06-29 00:11:22 +07:00
|
|
|
if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))
|
|
|
|
key.type = BTRFS_METADATA_ITEM_KEY;
|
|
|
|
else
|
|
|
|
key.type = BTRFS_EXTENT_ITEM_KEY;
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2014-02-13 10:19:47 +07:00
|
|
|
if (!trans) {
|
2013-06-13 03:20:08 +07:00
|
|
|
path->search_commit_root = 1;
|
2014-02-13 10:19:47 +07:00
|
|
|
path->skip_locking = 1;
|
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2015-04-16 13:54:50 +07:00
|
|
|
if (time_seq == (u64)-1)
|
|
|
|
path->skip_locking = 1;
|
|
|
|
|
2011-11-24 00:55:04 +07: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 19:41:15 +07:00
|
|
|
head = NULL;
|
|
|
|
|
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 08:36:46 +07:00
|
|
|
if (check_shared) {
|
|
|
|
if (!ref_tree) {
|
|
|
|
ref_tree = ref_root_alloc();
|
|
|
|
if (!ref_tree) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ref_root_fini(ref_tree);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
ret = btrfs_search_slot(trans, fs_info->extent_root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
BUG_ON(ret == 0);
|
|
|
|
|
2014-05-08 04:06:09 +07:00
|
|
|
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
|
2015-04-16 13:54:50 +07:00
|
|
|
if (trans && likely(trans->type != __TRANS_DUMMY) &&
|
|
|
|
time_seq != (u64)-1) {
|
2014-05-08 04:06:09 +07:00
|
|
|
#else
|
2015-04-16 13:54:50 +07:00
|
|
|
if (trans && time_seq != (u64)-1) {
|
2014-05-08 04:06:09 +07:00
|
|
|
#endif
|
2012-03-23 23:32:28 +07: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);
|
|
|
|
head = btrfs_find_delayed_ref_head(trans, bytenr);
|
|
|
|
if (head) {
|
|
|
|
if (!mutex_trylock(&head->mutex)) {
|
|
|
|
atomic_inc(&head->node.refs);
|
|
|
|
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);
|
|
|
|
btrfs_put_delayed_ref(&head->node);
|
|
|
|
goto again;
|
|
|
|
}
|
2014-01-23 21:21:38 +07:00
|
|
|
spin_unlock(&delayed_refs->lock);
|
2012-06-21 16:08:04 +07:00
|
|
|
ret = __add_delayed_refs(head, time_seq,
|
2014-09-11 03:20:45 +07:00
|
|
|
&prefs_delayed, &total_refs,
|
|
|
|
inum);
|
2012-06-22 19:01:00 +07:00
|
|
|
mutex_unlock(&head->mutex);
|
2014-01-23 21:21:38 +07:00
|
|
|
if (ret)
|
2012-03-23 23:32:28 +07:00
|
|
|
goto out;
|
2014-01-23 21:21:38 +07:00
|
|
|
} else {
|
|
|
|
spin_unlock(&delayed_refs->lock);
|
2012-03-03 19:41:15 +07:00
|
|
|
}
|
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 08:36:46 +07:00
|
|
|
|
|
|
|
if (check_shared && !list_empty(&prefs_delayed)) {
|
|
|
|
/*
|
|
|
|
* Add all delay_ref to the ref_tree and check if there
|
|
|
|
* are multiple ref items added.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(ref, &prefs_delayed, list) {
|
|
|
|
if (ref->key_for_search.type) {
|
|
|
|
ret = ref_tree_add(ref_tree,
|
|
|
|
ref->root_id,
|
|
|
|
ref->key_for_search.objectid,
|
|
|
|
ref->key_for_search.offset,
|
|
|
|
0, ref->count);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
ret = ref_tree_add(ref_tree, 0, 0, 0,
|
|
|
|
ref->parent, ref->count);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ref_tree->unique_refs > 1) {
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (path->slots[0]) {
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
int slot;
|
|
|
|
|
2012-05-22 18:43:25 +07:00
|
|
|
path->slots[0]--;
|
2011-11-24 00:55:04 +07:00
|
|
|
leaf = path->nodes[0];
|
2012-05-22 18:43:25 +07:00
|
|
|
slot = path->slots[0];
|
2011-11-24 00:55:04 +07:00
|
|
|
btrfs_item_key_to_cpu(leaf, &key, slot);
|
|
|
|
if (key.objectid == bytenr &&
|
2013-06-29 00:11:22 +07:00
|
|
|
(key.type == BTRFS_EXTENT_ITEM_KEY ||
|
|
|
|
key.type == BTRFS_METADATA_ITEM_KEY)) {
|
2011-11-24 00:55:04 +07:00
|
|
|
ret = __add_inline_refs(fs_info, path, bytenr,
|
2014-03-20 00:35:14 +07:00
|
|
|
&info_level, &prefs,
|
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 08:36:46 +07:00
|
|
|
ref_tree, &total_refs,
|
|
|
|
inum);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2012-05-15 22:55:51 +07:00
|
|
|
ret = __add_keyed_refs(fs_info, path, bytenr,
|
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 08:36:46 +07:00
|
|
|
info_level, &prefs,
|
|
|
|
ref_tree, inum);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
list_splice_init(&prefs_delayed, &prefs);
|
|
|
|
|
2012-05-15 22:55:51 +07:00
|
|
|
ret = __add_missing_keys(fs_info, &prefs);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2013-04-11 14:08:55 +07:00
|
|
|
__merge_refs(&prefs, 1);
|
2011-11-24 00:55:04 +07:00
|
|
|
|
2013-06-13 03:20:08 +07:00
|
|
|
ret = __resolve_indirect_refs(fs_info, path, time_seq, &prefs,
|
2014-09-11 03:20:45 +07:00
|
|
|
extent_item_pos, total_refs,
|
|
|
|
root_objectid);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2013-04-11 14:08:55 +07:00
|
|
|
__merge_refs(&prefs, 2);
|
2011-11-24 00:55:04 +07:00
|
|
|
|
|
|
|
while (!list_empty(&prefs)) {
|
|
|
|
ref = list_first_entry(&prefs, struct __prelim_ref, list);
|
2012-11-04 03:30:18 +07:00
|
|
|
WARN_ON(ref->count < 0);
|
2014-01-31 23:42:05 +07:00
|
|
|
if (roots && ref->count && ref->root_id && ref->parent == 0) {
|
2014-09-11 03:20:45 +07:00
|
|
|
if (root_objectid && ref->root_id != root_objectid) {
|
|
|
|
ret = BACKREF_FOUND_SHARED;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-11-24 00:55:04 +07:00
|
|
|
/* no parent == root of tree */
|
|
|
|
ret = ulist_add(roots, ref->root_id, 0, GFP_NOFS);
|
2013-03-30 06:03:21 +07:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
if (ref->count && ref->parent) {
|
2014-06-06 03:08:45 +07:00
|
|
|
if (extent_item_pos && !ref->inode_list &&
|
|
|
|
ref->level == 0) {
|
2012-05-17 21:43:03 +07:00
|
|
|
struct extent_buffer *eb;
|
2014-06-05 00:22:26 +07:00
|
|
|
|
2012-05-17 21:43:03 +07:00
|
|
|
eb = read_tree_block(fs_info->extent_root,
|
2014-06-15 06:07:32 +07:00
|
|
|
ref->parent, 0);
|
2015-05-25 16:30:15 +07:00
|
|
|
if (IS_ERR(eb)) {
|
|
|
|
ret = PTR_ERR(eb);
|
|
|
|
goto out;
|
|
|
|
} else if (!extent_buffer_uptodate(eb)) {
|
2013-04-24 01:17:42 +07:00
|
|
|
free_extent_buffer(eb);
|
2013-05-08 15:10:25 +07:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2013-04-24 01:17:42 +07:00
|
|
|
}
|
2014-07-03 02:07:54 +07:00
|
|
|
btrfs_tree_read_lock(eb);
|
|
|
|
btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
|
2012-05-17 21:43:03 +07:00
|
|
|
ret = find_extent_in_eb(eb, bytenr,
|
|
|
|
*extent_item_pos, &eie);
|
2014-07-03 02:07:54 +07:00
|
|
|
btrfs_tree_read_unlock_blocking(eb);
|
2012-05-17 21:43:03 +07:00
|
|
|
free_extent_buffer(eb);
|
2013-07-31 06:26:35 +07:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
ref->inode_list = eie;
|
2012-05-17 21:43:03 +07:00
|
|
|
}
|
2014-07-28 15:57:04 +07:00
|
|
|
ret = ulist_add_merge_ptr(refs, ref->parent,
|
|
|
|
ref->inode_list,
|
|
|
|
(void **)&eie, GFP_NOFS);
|
2013-03-30 06:03:21 +07:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2012-05-30 23:05:21 +07: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 18:13:38 +07:00
|
|
|
eie = NULL;
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
2013-08-08 12:04:17 +07:00
|
|
|
list_del(&ref->list);
|
2013-08-09 12:25:36 +07:00
|
|
|
kmem_cache_free(btrfs_prelim_ref_cache, ref);
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
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 08:36:46 +07:00
|
|
|
ref_root_free(ref_tree);
|
2011-11-24 00:55:04 +07:00
|
|
|
while (!list_empty(&prefs)) {
|
|
|
|
ref = list_first_entry(&prefs, struct __prelim_ref, list);
|
|
|
|
list_del(&ref->list);
|
2013-08-09 12:25:36 +07:00
|
|
|
kmem_cache_free(btrfs_prelim_ref_cache, ref);
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
while (!list_empty(&prefs_delayed)) {
|
|
|
|
ref = list_first_entry(&prefs_delayed, struct __prelim_ref,
|
|
|
|
list);
|
|
|
|
list_del(&ref->list);
|
2013-08-09 12:25:36 +07:00
|
|
|
kmem_cache_free(btrfs_prelim_ref_cache, ref);
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
2014-01-28 18:13:38 +07:00
|
|
|
if (ret < 0)
|
|
|
|
free_inode_elem_list(eie);
|
2011-11-24 00:55:04 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-17 21:43:03 +07: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;
|
2012-08-13 15:52:38 +07:00
|
|
|
eie = (struct extent_inode_elem *)(uintptr_t)node->aux;
|
2014-01-28 18:13:38 +07:00
|
|
|
free_inode_elem_list(eie);
|
2012-05-17 21:43:03 +07:00
|
|
|
node->aux = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ulist_free(blocks);
|
|
|
|
}
|
|
|
|
|
2011-11-24 00:55:04 +07: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
|
|
|
|
*/
|
|
|
|
static int btrfs_find_all_leafs(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 bytenr,
|
2012-06-21 16:08:04 +07:00
|
|
|
u64 time_seq, struct ulist **leafs,
|
2012-05-17 21:43:03 +07:00
|
|
|
const u64 *extent_item_pos)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
*leafs = ulist_alloc(GFP_NOFS);
|
2014-01-31 23:42:05 +07:00
|
|
|
if (!*leafs)
|
2011-11-24 00:55:04 +07: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 08:36:46 +07:00
|
|
|
ret = find_parent_nodes(trans, fs_info, bytenr, time_seq,
|
|
|
|
*leafs, NULL, extent_item_pos, 0, 0, 0);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (ret < 0 && ret != -ENOENT) {
|
2012-05-17 21:43:03 +07:00
|
|
|
free_leaf_list(*leafs);
|
2011-11-24 00:55:04 +07: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.
|
|
|
|
*/
|
2014-03-14 02:42:13 +07:00
|
|
|
static int __btrfs_find_all_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 bytenr,
|
|
|
|
u64 time_seq, struct ulist **roots)
|
2011-11-24 00:55:04 +07:00
|
|
|
{
|
|
|
|
struct ulist *tmp;
|
|
|
|
struct ulist_node *node = NULL;
|
2012-05-22 19:56:50 +07:00
|
|
|
struct ulist_iterator uiter;
|
2011-11-24 00:55:04 +07: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 19:56:50 +07:00
|
|
|
ULIST_ITER_INIT(&uiter);
|
2011-11-24 00:55:04 +07: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 08:36:46 +07:00
|
|
|
ret = find_parent_nodes(trans, fs_info, bytenr, time_seq,
|
|
|
|
tmp, *roots, NULL, 0, 0, 0);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (ret < 0 && ret != -ENOENT) {
|
|
|
|
ulist_free(tmp);
|
|
|
|
ulist_free(*roots);
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-22 19:56:50 +07:00
|
|
|
node = ulist_next(tmp, &uiter);
|
2011-11-24 00:55:04 +07:00
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
bytenr = node->val;
|
2014-01-26 21:32:18 +07:00
|
|
|
cond_resched();
|
2011-11-24 00:55:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
ulist_free(tmp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-14 02:42:13 +07:00
|
|
|
int btrfs_find_all_roots(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 bytenr,
|
|
|
|
u64 time_seq, struct ulist **roots)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!trans)
|
|
|
|
down_read(&fs_info->commit_root_sem);
|
|
|
|
ret = __btrfs_find_all_roots(trans, fs_info, bytenr, time_seq, roots);
|
|
|
|
if (!trans)
|
|
|
|
up_read(&fs_info->commit_root_sem);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-05-20 02:49:50 +07:00
|
|
|
/**
|
|
|
|
* btrfs_check_shared - tell us whether an extent is shared
|
|
|
|
*
|
|
|
|
* @trans: optional trans handle
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Return: 0 if extent is not shared, 1 if it is shared, < 0 on error.
|
|
|
|
*/
|
2014-09-11 03:20:45 +07:00
|
|
|
int btrfs_check_shared(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_fs_info *fs_info, u64 root_objectid,
|
|
|
|
u64 inum, u64 bytenr)
|
|
|
|
{
|
|
|
|
struct ulist *tmp = NULL;
|
|
|
|
struct ulist *roots = NULL;
|
|
|
|
struct ulist_iterator uiter;
|
|
|
|
struct ulist_node *node;
|
2015-02-25 21:47:32 +07:00
|
|
|
struct seq_list elem = SEQ_LIST_INIT(elem);
|
2014-09-11 03:20:45 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
tmp = ulist_alloc(GFP_NOFS);
|
|
|
|
roots = ulist_alloc(GFP_NOFS);
|
|
|
|
if (!tmp || !roots) {
|
|
|
|
ulist_free(tmp);
|
|
|
|
ulist_free(roots);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (trans)
|
|
|
|
btrfs_get_tree_mod_seq(fs_info, &elem);
|
|
|
|
else
|
|
|
|
down_read(&fs_info->commit_root_sem);
|
|
|
|
ULIST_ITER_INIT(&uiter);
|
|
|
|
while (1) {
|
|
|
|
ret = find_parent_nodes(trans, fs_info, bytenr, elem.seq, tmp,
|
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 08:36:46 +07:00
|
|
|
roots, NULL, root_objectid, inum, 1);
|
2014-09-11 03:20:45 +07:00
|
|
|
if (ret == BACKREF_FOUND_SHARED) {
|
2015-05-20 02:49:50 +07:00
|
|
|
/* this is the only condition under which we return 1 */
|
2014-09-11 03:20:45 +07:00
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ret < 0 && ret != -ENOENT)
|
|
|
|
break;
|
2015-05-20 02:49:50 +07:00
|
|
|
ret = 0;
|
2014-09-11 03:20:45 +07:00
|
|
|
node = ulist_next(tmp, &uiter);
|
|
|
|
if (!node)
|
|
|
|
break;
|
|
|
|
bytenr = node->val;
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
if (trans)
|
|
|
|
btrfs_put_tree_mod_seq(fs_info, &elem);
|
|
|
|
else
|
|
|
|
up_read(&fs_info->commit_root_sem);
|
|
|
|
ulist_free(tmp);
|
|
|
|
ulist_free(roots);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-09 01:32:27 +07: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;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
unsigned long ptr;
|
|
|
|
|
|
|
|
key.objectid = inode_objectid;
|
2014-06-04 23:41:45 +07:00
|
|
|
key.type = BTRFS_INODE_EXTREF_KEY;
|
2012-08-09 01:32:27 +07: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 23:41:45 +07:00
|
|
|
if (found_key.type != BTRFS_INODE_EXTREF_KEY)
|
2012-08-09 01:32:27 +07: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 03:41:01 +07: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 15:30:45 +07: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-14 00:52:59 +07:00
|
|
|
{
|
|
|
|
int slot;
|
|
|
|
u64 next_inum;
|
|
|
|
int ret;
|
2012-10-10 21:50:47 +07:00
|
|
|
s64 bytes_left = ((s64)size) - 1;
|
2011-06-14 00:52:59 +07:00
|
|
|
struct extent_buffer *eb = eb_in;
|
|
|
|
struct btrfs_key found_key;
|
2012-04-13 17:28:08 +07:00
|
|
|
int leave_spinning = path->leave_spinning;
|
2012-08-09 01:33:54 +07:00
|
|
|
struct btrfs_inode_ref *iref;
|
2011-06-14 00:52:59 +07:00
|
|
|
|
|
|
|
if (bytes_left >= 0)
|
|
|
|
dest[bytes_left] = '\0';
|
|
|
|
|
2012-04-13 17:28:08 +07:00
|
|
|
path->leave_spinning = 1;
|
2011-06-14 00:52:59 +07:00
|
|
|
while (1) {
|
2012-08-09 01:33:54 +07:00
|
|
|
bytes_left -= name_len;
|
2011-06-14 00:52:59 +07:00
|
|
|
if (bytes_left >= 0)
|
|
|
|
read_extent_buffer(eb, dest + bytes_left,
|
2012-08-09 01:33:54 +07:00
|
|
|
name_off, name_len);
|
2012-04-13 17:28:08 +07:00
|
|
|
if (eb != eb_in) {
|
2016-02-04 02:17:27 +07:00
|
|
|
if (!path->skip_locking)
|
|
|
|
btrfs_tree_read_unlock_blocking(eb);
|
2011-06-14 00:52:59 +07:00
|
|
|
free_extent_buffer(eb);
|
2012-04-13 17:28:08 +07:00
|
|
|
}
|
2015-01-03 01:03:17 +07:00
|
|
|
ret = btrfs_find_item(fs_root, path, parent, 0,
|
|
|
|
BTRFS_INODE_REF_KEY, &found_key);
|
2012-02-08 22:01:01 +07:00
|
|
|
if (ret > 0)
|
|
|
|
ret = -ENOENT;
|
2011-06-14 00:52:59 +07:00
|
|
|
if (ret)
|
|
|
|
break;
|
2012-08-09 01:33:54 +07:00
|
|
|
|
2011-06-14 00:52:59 +07: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 17:28:08 +07:00
|
|
|
if (eb != eb_in) {
|
2016-02-04 02:17:27 +07:00
|
|
|
if (!path->skip_locking)
|
|
|
|
btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
|
|
|
|
path->nodes[0] = NULL;
|
|
|
|
path->locks[0] = 0;
|
2012-04-13 17:28:08 +07:00
|
|
|
}
|
2011-06-14 00:52:59 +07:00
|
|
|
btrfs_release_path(path);
|
|
|
|
iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
|
2012-08-09 01:33:54 +07:00
|
|
|
|
|
|
|
name_len = btrfs_inode_ref_name_len(eb, iref);
|
|
|
|
name_off = (unsigned long)(iref + 1);
|
|
|
|
|
2011-06-14 00:52:59 +07:00
|
|
|
parent = next_inum;
|
|
|
|
--bytes_left;
|
|
|
|
if (bytes_left >= 0)
|
|
|
|
dest[bytes_left] = '/';
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
2012-04-13 17:28:08 +07:00
|
|
|
path->leave_spinning = leave_spinning;
|
2011-06-14 00:52:59 +07:00
|
|
|
|
|
|
|
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 09:01:28 +07:00
|
|
|
struct btrfs_path *path, struct btrfs_key *found_key,
|
|
|
|
u64 *flags_ret)
|
2011-06-14 00:52:59 +07:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u64 flags;
|
2013-06-29 00:11:22 +07:00
|
|
|
u64 size = 0;
|
2011-06-14 00:52:59 +07:00
|
|
|
u32 item_size;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
struct btrfs_extent_item *ei;
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
2013-06-29 00:11:22 +07:00
|
|
|
if (btrfs_fs_incompat(fs_info, SKINNY_METADATA))
|
|
|
|
key.type = BTRFS_METADATA_ITEM_KEY;
|
|
|
|
else
|
|
|
|
key.type = BTRFS_EXTENT_ITEM_KEY;
|
2011-06-14 00:52:59 +07: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 19:02:29 +07:00
|
|
|
ret = btrfs_previous_extent_item(fs_info->extent_root, path, 0);
|
|
|
|
if (ret) {
|
|
|
|
if (ret > 0)
|
|
|
|
ret = -ENOENT;
|
|
|
|
return ret;
|
2014-01-24 04:03:45 +07:00
|
|
|
}
|
2014-02-06 19:02:29 +07:00
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], found_key, path->slots[0]);
|
2013-06-29 00:11:22 +07:00
|
|
|
if (found_key->type == BTRFS_METADATA_ITEM_KEY)
|
2014-06-05 00:22:26 +07:00
|
|
|
size = fs_info->extent_root->nodesize;
|
2013-06-29 00:11:22 +07:00
|
|
|
else if (found_key->type == BTRFS_EXTENT_ITEM_KEY)
|
|
|
|
size = found_key->offset;
|
|
|
|
|
2014-01-24 04:03:45 +07:00
|
|
|
if (found_key->objectid > logical ||
|
2013-06-29 00:11:22 +07:00
|
|
|
found_key->objectid + size <= logical) {
|
2016-09-20 21:05:02 +07:00
|
|
|
btrfs_debug(fs_info,
|
|
|
|
"logical %llu is not within any extent", logical);
|
2011-06-14 00:52:59 +07:00
|
|
|
return -ENOENT;
|
2011-12-02 20:56:41 +07:00
|
|
|
}
|
2011-06-14 00:52:59 +07: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 21:05:02 +07: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 18:20:07 +07:00
|
|
|
logical, logical - found_key->objectid, found_key->objectid,
|
|
|
|
found_key->offset, flags, item_size);
|
2012-09-08 09:01:28 +07: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
|
|
|
|
BUG_ON(1);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-06-14 00:52:59 +07: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
|
|
|
|
* __get_extent_inline_ref must pass the modified ptr parameter to get the
|
|
|
|
* next ref. after the last ref was processed, 1 is returned.
|
|
|
|
* returns <0 on error
|
|
|
|
*/
|
|
|
|
static int __get_extent_inline_ref(unsigned long *ptr, struct extent_buffer *eb,
|
2014-06-09 09:54:07 +07:00
|
|
|
struct btrfs_key *key,
|
|
|
|
struct btrfs_extent_item *ei, u32 item_size,
|
|
|
|
struct btrfs_extent_inline_ref **out_eiref,
|
|
|
|
int *out_type)
|
2011-06-14 00:52:59 +07: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 09:54:07 +07: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-14 00:52:59 +07:00
|
|
|
} else {
|
|
|
|
*out_eiref = (struct btrfs_extent_inline_ref *)(ei + 1);
|
|
|
|
}
|
|
|
|
*ptr = (unsigned long)*out_eiref;
|
2014-06-08 18:04:13 +07:00
|
|
|
if ((unsigned long)(*ptr) >= (unsigned long)ei + item_size)
|
2011-06-14 00:52:59 +07:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
end = (unsigned long)ei + item_size;
|
2014-06-09 09:54:07 +07:00
|
|
|
*out_eiref = (struct btrfs_extent_inline_ref *)(*ptr);
|
2011-06-14 00:52:59 +07:00
|
|
|
*out_type = btrfs_extent_inline_ref_type(eb, *out_eiref);
|
|
|
|
|
|
|
|
*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
|
|
|
|
* call and may be modified (see __get_extent_inline_ref comment).
|
|
|
|
* 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 09:54:07 +07:00
|
|
|
struct btrfs_key *key, struct btrfs_extent_item *ei,
|
|
|
|
u32 item_size, u64 *out_root, u8 *out_level)
|
2011-06-14 00:52:59 +07:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int type;
|
|
|
|
struct btrfs_extent_inline_ref *eiref;
|
|
|
|
|
|
|
|
if (*ptr == (unsigned long)-1)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
while (1) {
|
2014-06-09 09:54:07 +07:00
|
|
|
ret = __get_extent_inline_ref(ptr, eb, key, ei, item_size,
|
|
|
|
&eiref, &type);
|
2011-06-14 00:52:59 +07: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 23:04:42 +07: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-14 00:52:59 +07:00
|
|
|
|
|
|
|
if (ret == 1)
|
|
|
|
*ptr = (unsigned long)-1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-20 21:05:02 +07: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-14 00:52:59 +07:00
|
|
|
{
|
2012-05-17 21:43:03 +07:00
|
|
|
struct extent_inode_elem *eie;
|
2011-12-02 20:56:41 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
2012-05-17 21:43:03 +07:00
|
|
|
for (eie = inode_list; eie; eie = eie->next) {
|
2016-09-20 21:05:02 +07: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 21:43:03 +07:00
|
|
|
ret = iterate(eie->inum, eie->offset, root, ctx);
|
2011-12-02 20:56:41 +07:00
|
|
|
if (ret) {
|
2016-09-20 21:05:02 +07:00
|
|
|
btrfs_debug(fs_info,
|
|
|
|
"stopping iteration for %llu due to ret=%d",
|
|
|
|
extent_item_objectid, ret);
|
2011-12-02 20:56:41 +07:00
|
|
|
break;
|
|
|
|
}
|
2011-06-14 00:52:59 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* calls iterate() for every inode that references the extent identified by
|
2011-12-02 20:56:41 +07:00
|
|
|
* the given parameters.
|
2011-06-14 00:52:59 +07: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 20:56:41 +07:00
|
|
|
u64 extent_item_objectid, u64 extent_item_pos,
|
2012-03-23 23:32:28 +07:00
|
|
|
int search_commit_root,
|
2011-06-14 00:52:59 +07:00
|
|
|
iterate_extent_inodes_t *iterate, void *ctx)
|
|
|
|
{
|
|
|
|
int ret;
|
2013-06-13 03:20:08 +07:00
|
|
|
struct btrfs_trans_handle *trans = NULL;
|
2012-03-23 23:32:28 +07:00
|
|
|
struct ulist *refs = NULL;
|
|
|
|
struct ulist *roots = NULL;
|
2011-12-02 20:56:41 +07:00
|
|
|
struct ulist_node *ref_node = NULL;
|
|
|
|
struct ulist_node *root_node = NULL;
|
2015-02-25 21:47:32 +07:00
|
|
|
struct seq_list tree_mod_seq_elem = SEQ_LIST_INIT(tree_mod_seq_elem);
|
2012-05-22 19:56:50 +07:00
|
|
|
struct ulist_iterator ref_uiter;
|
|
|
|
struct ulist_iterator root_uiter;
|
2011-06-14 00:52:59 +07:00
|
|
|
|
2016-09-20 21:05:02 +07:00
|
|
|
btrfs_debug(fs_info, "resolving all inodes for extent %llu",
|
2011-12-02 20:56:41 +07:00
|
|
|
extent_item_objectid);
|
2011-06-14 00:52:59 +07:00
|
|
|
|
2013-06-13 03:20:08 +07:00
|
|
|
if (!search_commit_root) {
|
2012-03-23 23:32:28 +07:00
|
|
|
trans = btrfs_join_transaction(fs_info->extent_root);
|
|
|
|
if (IS_ERR(trans))
|
|
|
|
return PTR_ERR(trans);
|
2012-05-16 23:36:03 +07:00
|
|
|
btrfs_get_tree_mod_seq(fs_info, &tree_mod_seq_elem);
|
2014-03-14 02:42:13 +07:00
|
|
|
} else {
|
|
|
|
down_read(&fs_info->commit_root_sem);
|
2012-03-23 23:32:28 +07:00
|
|
|
}
|
2011-06-14 00:52:59 +07:00
|
|
|
|
2011-12-02 20:56:41 +07:00
|
|
|
ret = btrfs_find_all_leafs(trans, fs_info, extent_item_objectid,
|
2012-06-21 16:08:04 +07:00
|
|
|
tree_mod_seq_elem.seq, &refs,
|
2012-05-16 23:36:03 +07:00
|
|
|
&extent_item_pos);
|
2011-12-02 20:56:41 +07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2011-06-14 00:52:59 +07:00
|
|
|
|
2012-05-22 19:56:50 +07:00
|
|
|
ULIST_ITER_INIT(&ref_uiter);
|
|
|
|
while (!ret && (ref_node = ulist_next(refs, &ref_uiter))) {
|
2014-03-14 02:42:13 +07:00
|
|
|
ret = __btrfs_find_all_roots(trans, fs_info, ref_node->val,
|
|
|
|
tree_mod_seq_elem.seq, &roots);
|
2011-12-02 20:56:41 +07:00
|
|
|
if (ret)
|
|
|
|
break;
|
2012-05-22 19:56:50 +07:00
|
|
|
ULIST_ITER_INIT(&root_uiter);
|
|
|
|
while (!ret && (root_node = ulist_next(roots, &root_uiter))) {
|
2016-09-20 21:05:02 +07: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 15:52:38 +07:00
|
|
|
(uintptr_t)ref_node->aux,
|
|
|
|
root_node->val,
|
|
|
|
extent_item_objectid,
|
|
|
|
iterate, ctx);
|
2011-12-02 20:56:41 +07:00
|
|
|
}
|
2012-05-17 21:43:03 +07:00
|
|
|
ulist_free(roots);
|
2011-06-14 00:52:59 +07:00
|
|
|
}
|
|
|
|
|
2012-05-17 21:43:03 +07:00
|
|
|
free_leaf_list(refs);
|
2011-12-02 20:56:41 +07:00
|
|
|
out:
|
2012-03-23 23:32:28 +07:00
|
|
|
if (!search_commit_root) {
|
2012-05-16 23:36:03 +07:00
|
|
|
btrfs_put_tree_mod_seq(fs_info, &tree_mod_seq_elem);
|
2012-03-23 23:32:28 +07:00
|
|
|
btrfs_end_transaction(trans, fs_info->extent_root);
|
2014-03-14 02:42:13 +07:00
|
|
|
} else {
|
|
|
|
up_read(&fs_info->commit_root_sem);
|
2012-03-23 23:32:28 +07:00
|
|
|
}
|
|
|
|
|
2011-06-14 00:52:59 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_path *path,
|
|
|
|
iterate_extent_inodes_t *iterate, void *ctx)
|
|
|
|
{
|
|
|
|
int ret;
|
2011-12-02 20:56:41 +07:00
|
|
|
u64 extent_item_pos;
|
2012-09-08 09:01:28 +07:00
|
|
|
u64 flags = 0;
|
2011-06-14 00:52:59 +07:00
|
|
|
struct btrfs_key found_key;
|
2012-03-23 23:32:28 +07:00
|
|
|
int search_commit_root = path->search_commit_root;
|
2011-06-14 00:52:59 +07:00
|
|
|
|
2012-09-08 09:01:28 +07:00
|
|
|
ret = extent_from_logical(fs_info, logical, path, &found_key, &flags);
|
2011-12-02 20:56:41 +07:00
|
|
|
btrfs_release_path(path);
|
2011-06-14 00:52:59 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2012-09-08 09:01:28 +07:00
|
|
|
if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
|
2012-08-01 17:28:01 +07:00
|
|
|
return -EINVAL;
|
2011-06-14 00:52:59 +07:00
|
|
|
|
2011-12-02 20:56:41 +07:00
|
|
|
extent_item_pos = logical - found_key.objectid;
|
2012-03-23 23:32:28 +07:00
|
|
|
ret = iterate_extent_inodes(fs_info, found_key.objectid,
|
|
|
|
extent_item_pos, search_commit_root,
|
|
|
|
iterate, ctx);
|
2011-06-14 00:52:59 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-09 01:33:54 +07: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-14 00:52:59 +07:00
|
|
|
{
|
2012-04-13 17:28:00 +07:00
|
|
|
int ret = 0;
|
2011-06-14 00:52:59 +07: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 17:28:00 +07:00
|
|
|
while (!ret) {
|
2015-01-03 01:03:17 +07:00
|
|
|
ret = btrfs_find_item(fs_root, path, inum,
|
|
|
|
parent ? parent + 1 : 0, BTRFS_INODE_REF_KEY,
|
|
|
|
&found_key);
|
|
|
|
|
2011-06-14 00:52:59 +07:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
if (ret) {
|
|
|
|
ret = found ? 0 : -ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++found;
|
|
|
|
|
|
|
|
parent = found_key.offset;
|
|
|
|
slot = path->slots[0];
|
2013-12-15 19:43:58 +07:00
|
|
|
eb = btrfs_clone_extent_buffer(path->nodes[0]);
|
|
|
|
if (!eb) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
extent_buffer_get(eb);
|
2012-04-13 17:28:08 +07:00
|
|
|
btrfs_tree_read_lock(eb);
|
|
|
|
btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
|
2011-06-14 00:52:59 +07:00
|
|
|
btrfs_release_path(path);
|
|
|
|
|
2013-09-16 21:58:09 +07:00
|
|
|
item = btrfs_item_nr(slot);
|
2011-06-14 00:52:59 +07: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 21:05:02 +07:00
|
|
|
btrfs_debug(fs_root->fs_info,
|
|
|
|
"following ref at offset %u for inode %llu in tree %llu",
|
|
|
|
cur, found_key.objectid, fs_root->objectid);
|
2012-08-09 01:33:54 +07:00
|
|
|
ret = iterate(parent, name_len,
|
|
|
|
(unsigned long)(iref + 1), eb, ctx);
|
2012-04-13 17:28:00 +07:00
|
|
|
if (ret)
|
2011-06-14 00:52:59 +07:00
|
|
|
break;
|
|
|
|
len = sizeof(*iref) + name_len;
|
|
|
|
iref = (struct btrfs_inode_ref *)((char *)iref + len);
|
|
|
|
}
|
2012-04-13 17:28:08 +07:00
|
|
|
btrfs_tree_read_unlock_blocking(eb);
|
2011-06-14 00:52:59 +07:00
|
|
|
free_extent_buffer(eb);
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-09 01:33:54 +07: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 19:43:58 +07:00
|
|
|
eb = btrfs_clone_extent_buffer(path->nodes[0]);
|
|
|
|
if (!eb) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
extent_buffer_get(eb);
|
2012-08-09 01:33:54 +07:00
|
|
|
|
|
|
|
btrfs_tree_read_lock(eb);
|
|
|
|
btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
|
|
|
|
btrfs_release_path(path);
|
|
|
|
|
2015-10-14 01:06:48 +07:00
|
|
|
item_size = btrfs_item_size_nr(eb, slot);
|
|
|
|
ptr = btrfs_item_ptr_offset(eb, slot);
|
2012-08-09 01:33:54 +07: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-14 01:06:48 +07:00
|
|
|
cur_offset += btrfs_inode_extref_name_len(eb, extref);
|
2012-08-09 01:33:54 +07:00
|
|
|
cur_offset += sizeof(*extref);
|
|
|
|
}
|
|
|
|
btrfs_tree_read_unlock_blocking(eb);
|
|
|
|
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-14 00:52:59 +07:00
|
|
|
/*
|
|
|
|
* returns 0 if the path could be dumped (probably truncated)
|
|
|
|
* returns <0 in case of an error
|
|
|
|
*/
|
2012-08-09 01:33:54 +07:00
|
|
|
static int inode_to_path(u64 inum, u32 name_len, unsigned long name_off,
|
|
|
|
struct extent_buffer *eb, void *ctx)
|
2011-06-14 00:52:59 +07: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-03 02:48:34 +07:00
|
|
|
fspath_min = (char *)ipath->fspath->val + (i + 1) * s_ptr;
|
2012-10-15 15:30:45 +07:00
|
|
|
fspath = btrfs_ref_to_path(ipath->fs_root, ipath->btrfs_path, name_len,
|
|
|
|
name_off, eb, inum, fspath_min, bytes_left);
|
2011-06-14 00:52:59 +07:00
|
|
|
if (IS_ERR(fspath))
|
|
|
|
return PTR_ERR(fspath);
|
|
|
|
|
|
|
|
if (fspath > fspath_min) {
|
2011-11-20 19:31:57 +07:00
|
|
|
ipath->fspath->val[i] = (u64)(unsigned long)fspath;
|
2011-06-14 00:52:59 +07: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-03 02:48:34 +07:00
|
|
|
* from ipath->fspath->val[i].
|
2011-06-14 00:52:59 +07:00
|
|
|
* when it returns, there are ipath->fspath->elem_cnt number of paths available
|
2011-11-03 02:48:34 +07:00
|
|
|
* in ipath->fspath->val[]. when the allocated space wasn't sufficient, the
|
2016-05-20 08:18:45 +07:00
|
|
|
* number of missed paths is recorded in ipath->fspath->elem_missed, otherwise,
|
2011-06-14 00:52:59 +07: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-09 01:33:54 +07:00
|
|
|
inode_to_path, ipath);
|
2011-06-14 00:52:59 +07: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));
|
2012-09-08 09:01:30 +07:00
|
|
|
data = vmalloc(alloc_bytes);
|
2011-06-14 00:52:59 +07: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))
|
|
|
|
return (void *)fspath;
|
|
|
|
|
|
|
|
ifp = kmalloc(sizeof(*ifp), GFP_NOFS);
|
|
|
|
if (!ifp) {
|
2016-05-10 19:56:20 +07:00
|
|
|
vfree(fspath);
|
2011-06-14 00:52:59 +07: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 03:47:52 +07:00
|
|
|
if (!ipath)
|
|
|
|
return;
|
2012-09-08 09:01:30 +07:00
|
|
|
vfree(ipath->fspath);
|
2011-06-14 00:52:59 +07:00
|
|
|
kfree(ipath);
|
|
|
|
}
|