btrfs-progs: check: Repair invalid inode mode in subvolume trees
cover btrfs-progs: check: Repair invalid inode mode in subvolume trees
Before this patch, btrfs check can only repair bad free space cache inode mode (as it was the first case detected by tree-checker and reported)
But now what may happen finally happened, we have user reorting bad inode mode in subvolumes trees.
Although the reported get the fs fixed by removing the offending old files, it's still a bad thing that "btrfs check" can't fix it.
This patch will bring the repair functionality to all inodes, along with needed test image.
Qu Wenruo (4):
btrfs-progs: check/common: Make repair_imode_common() to handle inodes
in subvolume trees
btrfs-progs: check/lowmem: Repair bad imode early
btrfs-progs: check/original: Fix inode mode in subvolume trees
btrfs-progs: tests/fsck: Add new images for inode mode repair
functionality
check/main.c | 32 ++++--
check/mode-common.c | 96 +++++++++++++++---
check/mode-common.h | 2 +
check/mode-lowmem.c | 39 +++++++
.../039-bad-inode-mode/.lowmem_repairable | 0
.../bad_free_space_cache_imode.raw.xz} | Bin
.../bad_regular_file_imode.img.xz | Bin 0 -> 2060 bytes
7 files changed, 147 insertions(+), 22 deletions(-)
create mode 100644 tests/fsck-tests/039-bad-inode-mode/.lowmem_repairable
rename tests/fsck-tests/{039-bad-free-space-cache-inode-mode/test.raw.xz => 039-bad-inode-mode/bad_free_space_cache_imode.raw.xz} (100%)
create mode 100644 tests/fsck-tests/039-bad-inode-mode/bad_regular_file_imode.img.xzSignature · 1 line
2.23.0
PATCH 1/4 btrfs-progs: check/common: Make repair_imode_common() to handle inodes in subvolume trees
Before this patch, repair_imode_common() can only handle two types of inodes:
- Free space cache inodes
- ROOT DIR inodes
For inodes in subvolume trees, the problem is how to determine the correct imode, thus it was not implemented.
However there are more reports of incorrect imode in subvolume trees, we need to support such fix.
So this patch adds a new function, detect_imode(), to detect (or call it educated guess) imode for inodes in subvolume trees.
--- check/mode-common.c | 96 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 83 insertions(+), 13 deletions(-)
check/mode-common.c +83 -13
@@ -836,6 +836,80 @@ int reset_imode(struct btrfs_trans_handle *trans, struct btrfs_root *root,return ret; } +static int detect_imode (struct btrfs_root *root,struct btrfs_path *path, +u32 *imode_ret) +{ +struct btrfs_key key; +struct btrfs_inode_item *iitem; +const u32 priv =0700 ; +u64 ino; +u32 imode =S_IFREG ; +int ret =0 ; + +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); + ino = key.objectid; + iitem =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_inode_item); + +/* +* Both CHR and BLK uses rdev, no way to distinguish them, so fall back +* to BLK. +*/ +if (btrfs_inode_rdev (path->nodes[0 ], iitem) !=0 ) { + imode =S_IFBLK ; + goto out; + } + +/* root inode */ +if (ino ==BTRFS_FIRST_FREE_OBJECTID ) { + imode =S_IFDIR ; + goto out; + } + +while (1 ) { + ret =btrfs_next_item (root, path); +if (ret >0 ) { +/* No determining result found, falls back to REG */ + ret =0 ; + goto out; + } +if (ret <0 ) + goto out; +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); +if (key.objectid != ino) + goto out; + +/* +* We ignore some types to make life easier: +* - INODE_REF +* We need to do a full tree search, which can fail for +* corrupted fs, but not worthy compared to other easier +* to determine types. +* - XATTR +* Both REG and DIR can have xattr, so not useful +*/ +switch (key.type) { +case BTRFS_DIR_ITEM_KEY : +case BTRFS_DIR_INDEX_KEY : + imode =S_IFDIR ; + goto out; +case BTRFS_EXTENT_DATA_KEY : +/* +* Both REG and LINK could have EXTENT_DATA. +* We just fall back to REG as user can inspect the +* content. +*/ + imode =S_IFREG ; + goto out; + } + } + +out: +/* Set default value even when something wrong happened */ + *imode_ret = (imode | priv); +return ret; +} +/* * Reset the inode mode of the inode specified by @path. *
@@ -852,22 +926,18 @@ int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path)u32 imode;int ret; -if (root->root_key.objectid !=BTRFS_ROOT_TREE_OBJECTID ) { -error ( -"repair inode mode outside of root tree is not supported yet" ); -return -ENOTTY ; - }btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]);ASSERT (key.type ==BTRFS_INODE_ITEM_KEY ); -if (key.objectid !=BTRFS_ROOT_TREE_DIR_OBJECTID && - !is_fstree (key.objectid)) { -error ("unsupported ino %llu" , key.objectid); -return -ENOTTY ; +if (root->objectid ==BTRFS_ROOT_TREE_OBJECTID ) { +/* In root tree we only have two possible imode */ +if (key.objectid ==BTRFS_ROOT_TREE_OBJECTID ) + imode =S_IFDIR |0755 ; +else + imode =S_IFREG |0600 ; + }else { +detect_imode (root, path, &imode); +/* Ignore error returned, just use the default value returned */ } -if (key.objectid ==BTRFS_ROOT_TREE_DIR_OBJECTID ) - imode =040755 ; -else - imode =0100600 ; trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) {
Signature · 1 line
2.23.0
Re: [PATCH 1/4] btrfs-progs: check/common: Make repair_imode_common() to handle inodes in subvolume trees
Quoted 118 lines · Qu Wenruo
Before this patch,
repair_imode_common()can only handle two types of inodes:
- Free space cache inodes
- ROOT DIR inodesFor inodes in subvolume trees, the problem is how to determine the correct imode, thus it was not implemented.
However there are more reports of incorrect imode in subvolume trees, we need to support such fix.
So this patch adds a new function,
detect_imode(), to detect (or call it educated guess) imode for inodes in subvolume trees.Signed-off-by Qu Wenruo <[email protected]>--- check/mode-common.c | 96 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 83 insertions(+), 13 deletions(-)check/mode-common.c +74
-8@@ -836,6 +836,80 @@ int reset_imode(struct btrfs_trans_handle *trans, struct btrfs_root *root,return ret; } +static int detect_imode (struct btrfs_root *root,struct btrfs_path *path, +u32 *imode_ret) +{ +struct btrfs_key key; +struct btrfs_inode_item *iitem; +const u32 priv =0700 ; +u64 ino; +u32 imode =S_IFREG ; +int ret =0 ; + +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); + ino = key.objectid; + iitem =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_inode_item); + +/* +* Both CHR and BLK uses rdev, no way to distinguish them, so fall back +* to BLK. +*/ +if (btrfs_inode_rdev (path->nodes[0 ], iitem) !=0 ) { + imode =S_IFBLK ; + goto out; + } + +/* root inode */ +if (ino ==BTRFS_FIRST_FREE_OBJECTID ) { + imode =S_IFDIR ; + goto out; + } + +while (1 ) { + ret =btrfs_next_item (root, path); +if (ret >0 ) { +/* No determining result found, falls back to REG */ + ret =0 ; + goto out; + } +if (ret <0 ) + goto out; +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); +if (key.objectid != ino) + goto out; + +/* +* We ignore some types to make life easier: +* - INODE_REF +* We need to do a full tree search, which can fail for +* corrupted fs, but not worthy compared to other easier +* to determine types. +* - XATTR +* Both REG and DIR can have xattr, so not useful +*/ +switch (key.type) { +case BTRFS_DIR_ITEM_KEY : +case BTRFS_DIR_INDEX_KEY : + imode =S_IFDIR ; + goto out; +case BTRFS_EXTENT_DATA_KEY : +/* +* Both REG and LINK could have EXTENT_DATA. +* We just fall back to REG as user can inspect the +* content. +*/ + imode =S_IFREG ; + goto out; + } + } + +out: +/* Set default value even when something wrong happened */ + *imode_ret = (imode | priv); +return ret; +} +/* * Reset the inode mode of the inode specified by @path. * @@ -852,22 +926,18 @@ int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path)u32 imode;int ret; -if (root->root_key.objectid !=BTRFS_ROOT_TREE_OBJECTID ) { -error ( -"repair inode mode outside of root tree is not supported yet" ); -return -ENOTTY ; - }btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]);ASSERT (key.type ==BTRFS_INODE_ITEM_KEY ); -if (key.objectid !=BTRFS_ROOT_TREE_DIR_OBJECTID && - !is_fstree (key.objectid)) { -error ("unsupported ino %llu" , key.objectid);
check/mode-common.c int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path) · line 939
Quoted 10 lines
check/mode-common.c +9
-1-return -ENOTTY ; +if (root->objectid ==BTRFS_ROOT_TREE_OBJECTID ) { +/* In root tree we only have two possible imode */ +if (key.objectid ==BTRFS_ROOT_TREE_OBJECTID ) + imode =S_IFDIR |0755 ; +else + imode =S_IFREG |0600 ; + }else { +detect_imode (root, path, &imode); +/* Ignore error returned, just use the default value returned */
Is this safe enough though? What if due to an error a directory is corrected to be file? Let's not forget the context we are oprating here
- a broken fs so it's possible (if not likely) that any of the search functions inside detect_imode could return negative error value. OTOH I'd expect the transaction commit to fail if that's the case e.g. faulty device.
Quoted 9 lines
check/mode-common.c +0
-4} -if (key.objectid ==BTRFS_ROOT_TREE_DIR_OBJECTID ) - imode =040755 ; -else - imode =0100600 ; trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) {
Re: [PATCH 1/4] btrfs-progs: check/common: Make repair_imode_common() to handle inodes in subvolume trees
Quoted 125 lines · Nikolay Borisov
Quoted 122 lines · Qu Wenruo
Before this patch,
repair_imode_common()can only handle two types of inodes:
- Free space cache inodes
- ROOT DIR inodesFor inodes in subvolume trees, the problem is how to determine the correct imode, thus it was not implemented.
However there are more reports of incorrect imode in subvolume trees, we need to support such fix.
So this patch adds a new function,
detect_imode(), to detect (or call it educated guess) imode for inodes in subvolume trees.Signed-off-by Qu Wenruo <[email protected]>--- check/mode-common.c | 96 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 83 insertions(+), 13 deletions(-)check/mode-common.c +77
-9@@ -836,6 +836,80 @@ int reset_imode(struct btrfs_trans_handle *trans, struct btrfs_root *root,return ret; } +static int detect_imode (struct btrfs_root *root,struct btrfs_path *path, +u32 *imode_ret) +{ +struct btrfs_key key; +struct btrfs_inode_item *iitem; +const u32 priv =0700 ; +u64 ino; +u32 imode =S_IFREG ; +int ret =0 ; + +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); + ino = key.objectid; + iitem =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_inode_item); + +/* +* Both CHR and BLK uses rdev, no way to distinguish them, so fall back +* to BLK. +*/ +if (btrfs_inode_rdev (path->nodes[0 ], iitem) !=0 ) { + imode =S_IFBLK ; + goto out; + } + +/* root inode */ +if (ino ==BTRFS_FIRST_FREE_OBJECTID ) { + imode =S_IFDIR ; + goto out; + } + +while (1 ) { + ret =btrfs_next_item (root, path); +if (ret >0 ) { +/* No determining result found, falls back to REG */ + ret =0 ; + goto out; + } +if (ret <0 ) + goto out; +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); +if (key.objectid != ino) + goto out; + +/* +* We ignore some types to make life easier: +* - INODE_REF +* We need to do a full tree search, which can fail for +* corrupted fs, but not worthy compared to other easier +* to determine types. +* - XATTR +* Both REG and DIR can have xattr, so not useful +*/ +switch (key.type) { +case BTRFS_DIR_ITEM_KEY : +case BTRFS_DIR_INDEX_KEY : + imode =S_IFDIR ; + goto out; +case BTRFS_EXTENT_DATA_KEY : +/* +* Both REG and LINK could have EXTENT_DATA. +* We just fall back to REG as user can inspect the +* content. +*/ + imode =S_IFREG ; + goto out; + } + } + +out: +/* Set default value even when something wrong happened */ + *imode_ret = (imode | priv); +return ret; +} +/* * Reset the inode mode of the inode specified by @path. * @@ -852,22 +926,18 @@ int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path)u32 imode;int ret; -if (root->root_key.objectid !=BTRFS_ROOT_TREE_OBJECTID ) { -error ( -"repair inode mode outside of root tree is not supported yet" ); -return -ENOTTY ; - }btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]);ASSERT (key.type ==BTRFS_INODE_ITEM_KEY ); -if (key.objectid !=BTRFS_ROOT_TREE_DIR_OBJECTID && - !is_fstree (key.objectid)) { -error ("unsupported ino %llu" , key.objectid); -return -ENOTTY ; +if (root->objectid ==BTRFS_ROOT_TREE_OBJECTID ) { +/* In root tree we only have two possible imode */ +if (key.objectid ==BTRFS_ROOT_TREE_OBJECTID )
Quoted 8 lines
check/mode-common.c int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path) · line 939
Quoted 6 lines
check/mode-common.c +6
-0+ imode =S_IFDIR |0755 ; + else + imode =S_IFREG |0600 ; + }else { +detect_imode (root, path, &imode); +/* Ignore error returned, just use the default value returned */ Is this safe enough though?
It depends. But I'd say if we failed in detect_imode(), then it doesn't matter whatever the type we're putting here.
Quoted 2 lines
What if due to an error a directory is
corrected to be file?
If a failure happens, it means btrfs-progs fails to read the next leaf. Then it really doesn't make much sense whatever the type is.
But I get your point, indeed we should error out without trying out to fix the inode.
I'll change this behavior in next version.
Thanks,
Qu
Quoted 15 lines
Let's not forget the context we are oprating here
- a broken fs so it's possible (if not likely) that any of the search functions insidedetect_imodecould return negative error value. OTOH I'd expect the transaction commit to fail if that's the case e.g. faulty device.Quoted 9 lines
check/mode-common.c +0
-4} -if (key.objectid ==BTRFS_ROOT_TREE_DIR_OBJECTID ) - imode =040755 ; -else - imode =0100600 ; trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) {
Re: [PATCH 1/4] btrfs-progs: check/common: Make repair_imode_common() to handle inodes in subvolume trees
Quoted 143 lines · Qu Wenruo
Quoted 125 lines · Nikolay Borisov
Quoted 122 lines · Qu Wenruo
Before this patch,
repair_imode_common()can only handle two types of inodes:
- Free space cache inodes
- ROOT DIR inodesFor inodes in subvolume trees, the problem is how to determine the correct imode, thus it was not implemented.
However there are more reports of incorrect imode in subvolume trees, we need to support such fix.
So this patch adds a new function,
detect_imode(), to detect (or call it educated guess) imode for inodes in subvolume trees.Signed-off-by Qu Wenruo <[email protected]>--- check/mode-common.c | 96 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 83 insertions(+), 13 deletions(-)check/mode-common.c +77
-9@@ -836,6 +836,80 @@ int reset_imode(struct btrfs_trans_handle *trans, struct btrfs_root *root,return ret; } +static int detect_imode (struct btrfs_root *root,struct btrfs_path *path, +u32 *imode_ret) +{ +struct btrfs_key key; +struct btrfs_inode_item *iitem; +const u32 priv =0700 ; +u64 ino; +u32 imode =S_IFREG ; +int ret =0 ; + +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); + ino = key.objectid; + iitem =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_inode_item); + +/* +* Both CHR and BLK uses rdev, no way to distinguish them, so fall back +* to BLK. +*/ +if (btrfs_inode_rdev (path->nodes[0 ], iitem) !=0 ) { + imode =S_IFBLK ; + goto out; + } + +/* root inode */ +if (ino ==BTRFS_FIRST_FREE_OBJECTID ) { + imode =S_IFDIR ; + goto out; + } + +while (1 ) { + ret =btrfs_next_item (root, path); +if (ret >0 ) { +/* No determining result found, falls back to REG */ + ret =0 ; + goto out; + } +if (ret <0 ) + goto out; +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); +if (key.objectid != ino) + goto out; + +/* +* We ignore some types to make life easier: +* - INODE_REF +* We need to do a full tree search, which can fail for +* corrupted fs, but not worthy compared to other easier +* to determine types. +* - XATTR +* Both REG and DIR can have xattr, so not useful +*/ +switch (key.type) { +case BTRFS_DIR_ITEM_KEY : +case BTRFS_DIR_INDEX_KEY : + imode =S_IFDIR ; + goto out; +case BTRFS_EXTENT_DATA_KEY : +/* +* Both REG and LINK could have EXTENT_DATA. +* We just fall back to REG as user can inspect the +* content. +*/ + imode =S_IFREG ; + goto out; + } + } + +out: +/* Set default value even when something wrong happened */ + *imode_ret = (imode | priv); +return ret; +} +/* * Reset the inode mode of the inode specified by @path. * @@ -852,22 +926,18 @@ int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path)u32 imode;int ret; -if (root->root_key.objectid !=BTRFS_ROOT_TREE_OBJECTID ) { -error ( -"repair inode mode outside of root tree is not supported yet" ); -return -ENOTTY ; - }btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]);ASSERT (key.type ==BTRFS_INODE_ITEM_KEY ); -if (key.objectid !=BTRFS_ROOT_TREE_DIR_OBJECTID && - !is_fstree (key.objectid)) { -error ("unsupported ino %llu" , key.objectid); -return -ENOTTY ; +if (root->objectid ==BTRFS_ROOT_TREE_OBJECTID ) { +/* In root tree we only have two possible imode */ +if (key.objectid ==BTRFS_ROOT_TREE_OBJECTID )Quoted 8 lines
check/mode-common.c int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path) · line 939
Quoted 6 lines
check/mode-common.c +6
-0+ imode =S_IFDIR |0755 ; + else + imode =S_IFREG |0600 ; + }else { +detect_imode (root, path, &imode); +/* Ignore error returned, just use the default value returned */ Is this safe enough though?
It depends. But I'd say if we failed in
detect_imode(), then it doesn't matter whatever the type we're putting here.Quoted 2 lines
What if due to an error a directory is
corrected to be file?
Quoted 7 lines
If a failure happens, it means btrfs-progs fails to read the next leaf. Then it really doesn't make much sense whatever the type is.
But I get your point, indeed we should error out without trying out to fix the inode.
I'll change this behavior in next version.
IMO the goal of btrfs-progs should be to make a broken filesystem better and not replace one type of breakage with potentially another. In such cases we ought to break out gracefully.
Quoted 20 lines
Thanks,
QuQuoted 15 lines
Let's not forget the context we are oprating here
- a broken fs so it's possible (if not likely) that any of the search functions insidedetect_imodecould return negative error value. OTOH I'd expect the transaction commit to fail if that's the case e.g. faulty device.Quoted 9 lines
check/mode-common.c +0
-4} -if (key.objectid ==BTRFS_ROOT_TREE_DIR_OBJECTID ) - imode =040755 ; -else - imode =0100600 ; trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) {
Re: [PATCH 1/4] btrfs-progs: check/common: Make repair_imode_common() to handle inodes in subvolume trees
Quoted 149 lines · Nikolay Borisov
Quoted 146 lines · Qu Wenruo
Quoted 125 lines · Nikolay Borisov
Quoted 122 lines · Qu Wenruo
Before this patch,
repair_imode_common()can only handle two types of inodes:
- Free space cache inodes
- ROOT DIR inodesFor inodes in subvolume trees, the problem is how to determine the correct imode, thus it was not implemented.
However there are more reports of incorrect imode in subvolume trees, we need to support such fix.
So this patch adds a new function,
detect_imode(), to detect (or call it educated guess) imode for inodes in subvolume trees.Signed-off-by Qu Wenruo <[email protected]>--- check/mode-common.c | 96 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 83 insertions(+), 13 deletions(-)check/mode-common.c +77
-9@@ -836,6 +836,80 @@ int reset_imode(struct btrfs_trans_handle *trans, struct btrfs_root *root,return ret; } +static int detect_imode (struct btrfs_root *root,struct btrfs_path *path, +u32 *imode_ret) +{ +struct btrfs_key key; +struct btrfs_inode_item *iitem; +const u32 priv =0700 ; +u64 ino; +u32 imode =S_IFREG ; +int ret =0 ; + +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); + ino = key.objectid; + iitem =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_inode_item); + +/* +* Both CHR and BLK uses rdev, no way to distinguish them, so fall back +* to BLK. +*/ +if (btrfs_inode_rdev (path->nodes[0 ], iitem) !=0 ) { + imode =S_IFBLK ; + goto out; + } + +/* root inode */ +if (ino ==BTRFS_FIRST_FREE_OBJECTID ) { + imode =S_IFDIR ; + goto out; + } + +while (1 ) { + ret =btrfs_next_item (root, path); +if (ret >0 ) { +/* No determining result found, falls back to REG */ + ret =0 ; + goto out; + } +if (ret <0 ) + goto out; +btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]); +if (key.objectid != ino) + goto out; + +/* +* We ignore some types to make life easier: +* - INODE_REF +* We need to do a full tree search, which can fail for +* corrupted fs, but not worthy compared to other easier +* to determine types. +* - XATTR +* Both REG and DIR can have xattr, so not useful +*/ +switch (key.type) { +case BTRFS_DIR_ITEM_KEY : +case BTRFS_DIR_INDEX_KEY : + imode =S_IFDIR ; + goto out; +case BTRFS_EXTENT_DATA_KEY : +/* +* Both REG and LINK could have EXTENT_DATA. +* We just fall back to REG as user can inspect the +* content. +*/ + imode =S_IFREG ; + goto out; + } + } + +out: +/* Set default value even when something wrong happened */ + *imode_ret = (imode | priv); +return ret; +} +/* * Reset the inode mode of the inode specified by @path. * @@ -852,22 +926,18 @@ int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path)u32 imode;int ret; -if (root->root_key.objectid !=BTRFS_ROOT_TREE_OBJECTID ) { -error ( -"repair inode mode outside of root tree is not supported yet" ); -return -ENOTTY ; - }btrfs_item_key_to_cpu (path->nodes[0 ], &key, path->slots[0 ]);ASSERT (key.type ==BTRFS_INODE_ITEM_KEY ); -if (key.objectid !=BTRFS_ROOT_TREE_DIR_OBJECTID && - !is_fstree (key.objectid)) { -error ("unsupported ino %llu" , key.objectid); -return -ENOTTY ; +if (root->objectid ==BTRFS_ROOT_TREE_OBJECTID ) { +/* In root tree we only have two possible imode */ +if (key.objectid ==BTRFS_ROOT_TREE_OBJECTID )Quoted 8 lines
check/mode-common.c int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path) · line 939
Quoted 6 lines
check/mode-common.c +6
-0+ imode =S_IFDIR |0755 ; + else + imode =S_IFREG |0600 ; + }else { +detect_imode (root, path, &imode); +/* Ignore error returned, just use the default value returned */ Is this safe enough though?
It depends. But I'd say if we failed in
detect_imode(), then it doesn't matter whatever the type we're putting here.Quoted 2 lines
What if due to an error a directory is
corrected to be file?If a failure happens, it means btrfs-progs fails to read the next leaf. Then it really doesn't make much sense whatever the type is.
Quoted 8 lines
Quoted 4 lines
But I get your point, indeed we should error out without trying out to fix the inode.
I'll change this behavior in next version.
IMO the goal of btrfs-progs should be to make a broken filesystem better and not replace one type of breakage with potentially another. In such cases we ought to break out gracefully.
Totally agreed.
BTW, I'll also implement the INODE_REF lookup method to provide the most accurate way to recover.
The planned recovery would be:
- INODE_REF lookup
If everything goes fine, that's it and call it a day.
If it failed, try the rest.
- INODE rdev lookup
For this case, either BLK or CHR, but it doesn't really matter nor would cause problem.
- DIR_INDEX/ITEM lookup
- EXTENT_DATA lookup
Both REG and LNK would be possible but falls back to REG won't cause further problem.
Thanks,
Qu
Quoted 21 lines
Quoted 21 lines
Thanks,
QuQuoted 15 lines
Let's not forget the context we are oprating here
- a broken fs so it's possible (if not likely) that any of the search functions insidedetect_imodecould return negative error value. OTOH I'd expect the transaction commit to fail if that's the case e.g. faulty device.Quoted 9 lines
check/mode-common.c +0
-4} -if (key.objectid ==BTRFS_ROOT_TREE_DIR_OBJECTID ) - imode =040755 ; -else - imode =0100600 ; trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) {
PATCH 2/4 btrfs-progs: check/lowmem: Repair bad imode early
In reply to Qu WenruoFor lowmem mode, if we hit a bad inode mode, normally it is reported when we checking the DIR_INDEX/DIR_ITEM of the parent inode.
If we didn't repair at that timing, the error will be recorded even we fixed it later.
So this patch will check for INODE_ITEM_MISMATCH error type, and if it's really caused by invalid imode, repair it and clear the error.
--- check/mode-lowmem.c | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+)
check/mode-lowmem.c +39 -0
@@ -1550,6 +1550,35 @@ static int lowmem_delete_corrupted_dir_item(struct btrfs_root *root,return ret; } +static int try_repair_imode (struct btrfs_root *root,u64 ino) +{ +struct btrfs_inode_item *iitem; +struct btrfs_path path; +struct btrfs_key key; +int ret; + + key.objectid = ino; + key.type =BTRFS_INODE_ITEM_KEY ; + key.offset =0 ; +btrfs_init_path (&path); + + ret =btrfs_search_slot (NULL , root, &key, &path,0 ,0 ); +if (ret >0 ) + ret = -ENOENT ; +if (ret <0 ) + goto out; + iitem =btrfs_item_ptr (path.nodes[0 ], path.slots[0 ], + struct btrfs_inode_item); +if (!is_valid_imode (btrfs_inode_mode (path.nodes[0 ], iitem))) { + ret =repair_imode_common (root, &path); + }else { + ret = -ENOTTY ; + } +out: +btrfs_release_path (&path); +return ret; +} +/* * Call repair_inode_item_missing and repair_ternary_lowmem to repair *
@@ -1574,6 +1603,16 @@ static int repair_dir_item(struct btrfs_root *root, struct btrfs_key *di_key, err &= ~(INODE_ITEM_MISMATCH |INODE_ITEM_MISSING ); } +if (err &INODE_ITEM_MISMATCH ) { +/* +* INODE_ITEM mismatch can be caused by bad imode, +* so check if it's a bad imode, then repair if possible. +*/ + ret =try_repair_imode (root, ino); +if (!ret) + err &= ~INODE_ITEM_MISMATCH ; + } +if (err & ~(INODE_ITEM_MISMATCH |INODE_ITEM_MISSING )) { ret =repair_ternary_lowmem (root, dirid, ino, index, namebuf, name_len, filetype, err);
Signature · 1 line
2.23.0
PATCH 3/4 btrfs-progs: check/original: Fix inode mode in subvolume trees
In reply to Qu WenruoTo make original mode to repair imode error in subvolume trees, this patch will do:
- Remove the show-stopper checks for root->objectid.
Now repair_imode_original() will accept inodes in subvolume trees.
- Export detect_imode() for original mode
Due to the call requirement, original mode must use an existing trans handler to do the repair, thus we need to re-implement most of the work done in repair_imode_common().
- Make repair_imode_original() to use detect_imode.
--- check/main.c | 32 +++++++++++++++++++++++--------- check/mode-common.c | 4 ++-- check/mode-common.h | 2 ++ 3 files changed, 27 insertions(+), 11 deletions(-)
check/main.c +23 -9
@@ -2771,18 +2771,31 @@ static int repair_imode_original(struct btrfs_trans_handle *trans,struct btrfs_path *path, struct inode_record *rec) { + struct btrfs_key key;int ret;u32 imode; -if (root->root_key.objectid !=BTRFS_ROOT_TREE_OBJECTID ) -return -ENOTTY ; -if (rec->ino !=BTRFS_ROOT_TREE_DIR_OBJECTID || !is_fstree (rec->ino)) -return -ENOTTY ; + key.objectid = rec->ino; + key.type =BTRFS_INODE_ITEM_KEY ; + key.offset =0 ; -if (rec->ino ==BTRFS_ROOT_TREE_DIR_OBJECTID ) - imode =040755 ; -else - imode =0100600 ; + ret =btrfs_search_slot (NULL , root, &key, path,0 ,0 ); +if (ret >0 ) + ret = -ENOENT ; +if (ret <0 ) +return ret; + +if (root->objectid ==BTRFS_ROOT_TREE_OBJECTID ) { +/* In root tree we only have two possible imode */ +if (rec->ino ==BTRFS_ROOT_TREE_OBJECTID ) + imode =S_IFDIR |0755 ; +else + imode =S_IFREG |0600 ; + }else { +detect_imode (root, path, &imode); +/* Ignore error returned, just use the default value returned */ + } +btrfs_release_path (path); ret =reset_imode (trans, root, path, rec->ino, imode);if (ret <0 )return ret;
@@ -2810,7 +2823,8 @@ static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)I_ERR_FILE_NBYTES_WRONG |I_ERR_INLINE_RAM_BYTES_WRONG |I_ERR_MISMATCH_DIR_HASH | - I_ERR_UNALIGNED_EXTENT_REC))) +I_ERR_UNALIGNED_EXTENT_REC | + I_ERR_INVALID_IMODE))) return rec->errors;/*
check/mode-common.c +2 -2
@@ -836,8 +836,8 @@ int reset_imode(struct btrfs_trans_handle *trans, struct btrfs_root *root,return ret; } -static int detect_imode (struct btrfs_root *root,struct btrfs_path *path, -u32 *imode_ret) +int detect_imode (struct btrfs_root *root,struct btrfs_path *path, +u32 *imode_ret) {struct btrfs_key key;struct btrfs_inode_item *iitem;
check/mode-common.h +2 -0
@@ -126,6 +126,8 @@ int delete_corrupted_dir_item(struct btrfs_trans_handle *trans,struct btrfs_root *root, struct btrfs_key *di_key, char *namebuf, u32 namelen); +int detect_imode (struct btrfs_root *root,struct btrfs_path *path, +u32 *imode_ret);int reset_imode (struct btrfs_trans_handle *trans,struct btrfs_root *root,struct btrfs_path *path,u64 ino,u32 mode);int repair_imode_common (struct btrfs_root *root,struct btrfs_path *path);
Signature · 1 line
2.23.0
PATCH 4/4 btrfs-progs: tests/fsck: Add new images for inode mode repair functionality
In reply to Qu WenruoAdd new test image for imode repair in subvolume trees.
Also rename the existing test case 039-bad-free-space-cache-inode-mode to 039-bad-inode-mode, since now we can fix all bad imode.
And add the beacon file for lowmem test.
---
.../039-bad-inode-mode/.lowmem_repairable | 0
.../bad_free_space_cache_imode.raw.xz} | Bin
.../bad_regular_file_imode.img.xz | Bin 0 -> 2060 bytes
3 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 tests/fsck-tests/039-bad-inode-mode/.lowmem_repairable
rename tests/fsck-tests/{039-bad-free-space-cache-inode-mode/test.raw.xz => 039-bad-inode-mode/bad_free_space_cache_imode.raw.xz} (100%)
create mode 100644 tests/fsck-tests/039-bad-inode-mode/bad_regular_file_imode.img.xztests/fsck-tests/039-bad-inode-mode/.lowmem_repairable new file +0 -0
tests/fsck-tests/039-bad-inode-mode/bad_free_space_cache_imode.raw.xz renamed from tests/fsck-tests/039-bad-free-space-cache-inode-mode/test.raw.xz +0 -0
tests/fsck-tests/039-bad-inode-mode/bad_regular_file_imode.img.xz new file binary +0 -0
Signature · 1 line
2.23.0