marko10_000
/
btrfs-progs
forked from Mirrors/btrfs-progs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

btrfs-progs: check: introduce print_dir_item_err() 

check_dir_item() now checks relative dir_item/dir_index.

Introduce print_dir_item_err() to print error msg while
checking dir_item/dir_index.

Signed-off-by: Su Yue <suy.fnst@cn.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>
master
Su Yue 2017-08-28 14:44:56 +08:00 committed by David Sterba
parent 8c39fc0fcd
commit 564901eac7
1 changed files with 102 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
cmds-check.c
View File

@ -4813,25 +4813,59 @@ out:
return ret;
}
static void print_dir_item_err(struct btrfs_root *root, struct btrfs_key *key,
u64 ino, u64 index, const char *namebuf,
int name_len, u8 filetype, int err)
{
if (err & (DIR_ITEM_MISMATCH | DIR_ITEM_MISSING)) {
error("root %llu DIR ITEM[%llu %llu] name %s filetype %d %s",
root->objectid, key->objectid, key->offset, namebuf,
filetype,
err & DIR_ITEM_MISMATCH ? "mismath" : "missing");
}
if (err & (DIR_INDEX_MISMATCH | DIR_INDEX_MISSING)) {
error("root %llu DIR INDEX[%llu %llu] name %s filetype %d %s",
root->objectid, key->objectid, index, namebuf, filetype,
err & DIR_ITEM_MISMATCH ? "mismath" : "missing");
}
if (err & (INODE_ITEM_MISSING | INODE_ITEM_MISMATCH)) {
error(
"root %llu INODE_ITEM[%llu] index %llu name %s filetype %d %s",
root->objectid, ino, index, namebuf, filetype,
err & INODE_ITEM_MISMATCH ? "mismath" : "missing");
}
if (err & INODE_REF_MISSING)
error(
"root %llu INODE REF[%llu, %llu] name %s filetype %u missing",
root->objectid, ino, key->objectid, namebuf, filetype);
}
/*
* Traverse the given DIR_ITEM/DIR_INDEX and check related INODE_ITEM and
* call find_inode_ref() to check related INODE_REF/INODE_EXTREF.
*
* @root: the root of the fs/file tree
* @key: the key of the INODE_REF/INODE_EXTREF
* @path: the path
* @size: the st_size of the INODE_ITEM
* @ext_ref: the EXTENDED_IREF feature
*
* Return 0 if no error occurred.
*/
static int check_dir_item(struct btrfs_root *root, struct btrfs_key *key,
struct extent_buffer *node, int slot, u64 *size,
static int check_dir_item(struct btrfs_root *root, struct btrfs_key *di_key,
struct btrfs_path *path, u64 *size,
unsigned int ext_ref)
{
struct btrfs_dir_item *di;
struct btrfs_inode_item *ii;
struct btrfs_path path;
struct btrfs_key key;
struct btrfs_key location;
struct extent_buffer *node;
int slot;
char namebuf[BTRFS_NAME_LEN] = {0};
u32 total;
u32 cur = 0;
@ -4843,110 +4877,121 @@ static int check_dir_item(struct btrfs_root *root, struct btrfs_key *key,
u64 index;
int ret;
int err = 0;
int tmp_err;
node = path->nodes[0];
slot = path->slots[0];
/*
* For DIR_ITEM set index to (u64)-1, so that find_inode_ref
* ignore index check.
*/
index = (key->type == BTRFS_DIR_INDEX_KEY) ? key->offset : (u64)-1;
if (di_key->type == BTRFS_DIR_INDEX_KEY)
index = di_key->offset;
else
index = (u64)-1;
di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
total = btrfs_item_size_nr(node, slot);
memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf));
while (cur < total) {
data_len = btrfs_dir_data_len(node, di);
tmp_err = 0;
if (data_len)
error("root %llu %s[%llu %llu] data_len shouldn't be %u",
root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
"DIR_ITEM" : "DIR_INDEX",
key->objectid, key->offset, data_len);
root->objectid,
di_key->type == BTRFS_DIR_ITEM_KEY ? "DIR_ITEM" : "DIR_INDEX",
di_key->objectid, di_key->offset, data_len);
name_len = btrfs_dir_name_len(node, di);
if (cur + sizeof(*di) + name_len > total ||
name_len > BTRFS_NAME_LEN) {
if (name_len <= BTRFS_NAME_LEN) {
len = name_len;
} else {
len = BTRFS_NAME_LEN;
warning("root %llu %s[%llu %llu] name too long",
root->objectid,
key->type == BTRFS_DIR_ITEM_KEY ?
"DIR_ITEM" : "DIR_INDEX",
key->objectid, key->offset);
if (cur + sizeof(*di) > total)
break;
len = min_t(u32, total - cur - sizeof(*di),
BTRFS_NAME_LEN);
} else {
len = name_len;
di_key->type == BTRFS_DIR_ITEM_KEY ? "DIR_ITEM" : "DIR_INDEX",
di_key->objectid, di_key->offset);
}
(*size) += name_len;
read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
read_extent_buffer(node, namebuf, (unsigned long)(di + 1),
len);
filetype = btrfs_dir_type(node, di);
if (key->type == BTRFS_DIR_ITEM_KEY &&
key->offset != btrfs_name_hash(namebuf, len)) {
if (di_key->type == BTRFS_DIR_ITEM_KEY &&
di_key->offset != btrfs_name_hash(namebuf, len)) {
err |= -EIO;
error("root %llu DIR_ITEM[%llu %llu] name %s namelen %u filetype %u mismatch with its hash, wanted %llu have %llu",
root->objectid, key->objectid, key->offset,
namebuf, len, filetype, key->offset,
btrfs_name_hash(namebuf, len));
root->objectid, di_key->objectid, di_key->offset,
namebuf, len, filetype, di_key->offset,
btrfs_name_hash(namebuf, len));
}
btrfs_init_path(&path);
btrfs_dir_item_key_to_cpu(node, di, &location);
/* Ignore related ROOT_ITEM check */
if (location.type == BTRFS_ROOT_ITEM_KEY)
goto next;
btrfs_release_path(path);
/* Check relative INODE_ITEM(existence/filetype) */
ret = btrfs_search_slot(NULL, root, &location, &path, 0, 0);
ret = btrfs_search_slot(NULL, root, &location, path, 0, 0);
if (ret) {
err |= INODE_ITEM_MISSING;
error("root %llu %s[%llu %llu] couldn't find relative INODE_ITEM[%llu] namelen %u filename %s filetype %x",
root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
"DIR_ITEM" : "DIR_INDEX", key->objectid,
key->offset, location.objectid, name_len,
namebuf, filetype);
tmp_err |= INODE_ITEM_MISSING;
goto next;
}
ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
struct btrfs_inode_item);
mode = btrfs_inode_mode(path.nodes[0], ii);
mode = btrfs_inode_mode(path->nodes[0], ii);
if (imode_to_type(mode) != filetype) {
err |= INODE_ITEM_MISMATCH;
error("root %llu %s[%llu %llu] relative INODE_ITEM filetype mismatch namelen %u filename %s filetype %d",
root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
"DIR_ITEM" : "DIR_INDEX", key->objectid,
key->offset, name_len, namebuf, filetype);
tmp_err |= INODE_ITEM_MISMATCH;
goto next;
}
/* Check relative INODE_REF/INODE_EXTREF */
location.type = BTRFS_INODE_REF_KEY;
location.offset = key->objectid;
ret = find_inode_ref(root, &location, namebuf, len,
&index, ext_ref);
err |= ret;
if (ret & INODE_REF_MISSING)
error("root %llu %s[%llu %llu] relative INODE_REF missing namelen %u filename %s filetype %d",
root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
"DIR_ITEM" : "DIR_INDEX", key->objectid,
key->offset, name_len, namebuf, filetype);
key.objectid = location.objectid;
key.type = BTRFS_INODE_REF_KEY;
key.offset = di_key->objectid;
tmp_err |= find_inode_ref(root, &key, namebuf, len,
&index, ext_ref);
/* check relative INDEX/ITEM */
key.objectid = di_key->objectid;
if (key.type == BTRFS_DIR_ITEM_KEY) {
key.type = BTRFS_DIR_INDEX_KEY;
key.offset = index;
} else {
key.type = BTRFS_DIR_ITEM_KEY;
key.offset = btrfs_name_hash(namebuf, name_len);
}
tmp_err |= find_dir_item(root, &key, &location, namebuf,
name_len, filetype);
/* find_dir_item may find index */
if (key.type == BTRFS_DIR_INDEX_KEY)
index = key.offset;
next:
btrfs_release_path(&path);
btrfs_release_path(path);
print_dir_item_err(root, di_key, location.objectid, index,
namebuf, name_len, filetype, tmp_err);
err |= tmp_err;
len = sizeof(*di) + name_len + data_len;
di = (struct btrfs_dir_item *)((char *)di + len);
cur += len;
if (key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
if (di_key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
error("root %llu DIR_INDEX[%llu %llu] should contain only one entry",
root->objectid, key->objectid, key->offset);
root->objectid, di_key->objectid,
di_key->offset);
break;
}
}
/* research path */
btrfs_release_path(path);
ret = btrfs_search_slot(NULL, root, di_key, path, 0, 0);
if (ret)
err |= ret > 0 ? -ENOENT : ret;
return err;
}
@ -5334,8 +5379,7 @@ static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
imode_to_type(mode), key.objectid,
key.offset);
}
ret = check_dir_item(root, &key, node, slot, &size,
ext_ref);
ret = check_dir_item(root, &key, path, &size, ext_ref);
err |= ret;
break;
case BTRFS_EXTENT_DATA_KEY: