@@ -390,6 +390,7 @@ static int ext2_create_file_extents(struct btrfs_trans_handle *trans,
ext2_filsys ext2_fs, ext2_ino_t ext2_ino,
u32 convert_flags)
{
+ struct btrfs_fs_info *fs_info = trans->fs_info;
int ret;
char *buffer = NULL;
errcode_t err;
@@ -397,8 +398,20 @@ static int ext2_create_file_extents(struct btrfs_trans_handle *trans,
u32 last_block;
u32 sectorsize = root->fs_info->sectorsize;
u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
+ bool meet_inline_size_limit;
struct blk_iterate_data data;
+ if (S_ISLNK(btrfs_stack_inode_mode(btrfs_inode))) {
+ meet_inline_size_limit = inode_size <= btrfs_symlink_max_size(fs_info);
+ if (!meet_inline_size_limit) {
+ error("symlink too large for ext2 inode %u, has %llu max %u",
+ ext2_ino, inode_size, btrfs_symlink_max_size(fs_info));
+ return -ENAMETOOLONG;
+ }
+ } else {
+ meet_inline_size_limit = inode_size <= btrfs_data_inline_max_size(fs_info);
+ }
+
init_blk_iterate_data(&data, trans, root, btrfs_inode, objectid,
convert_flags & CONVERT_FLAG_DATACSUM);
@@ -430,8 +443,7 @@ static int ext2_create_file_extents(struct btrfs_trans_handle *trans,
if (ret)
goto fail;
if ((convert_flags & CONVERT_FLAG_INLINE_DATA) && data.first_block == 0
- && data.num_blocks > 0 && inode_size < sectorsize
- && inode_size <= BTRFS_MAX_INLINE_DATA_SIZE(root->fs_info)) {
+ && data.num_blocks > 0 && meet_inline_size_limit) {
u64 num_bytes = data.num_blocks * sectorsize;
u64 disk_bytenr = data.disk_block * sectorsize;
u64 nbytes;
@@ -476,21 +488,26 @@ static int ext2_create_symlink(struct btrfs_trans_handle *trans,
int ret;
char *pathname;
u64 inode_size = btrfs_stack_inode_size(btrfs_inode);
+
if (ext2fs_inode_data_blocks2(ext2_fs, ext2_inode)) {
- btrfs_set_stack_inode_size(btrfs_inode, inode_size + 1);
+ if (inode_size > btrfs_symlink_max_size(trans->fs_info)) {
+ error("symlink too large for ext2 inode %u, has %llu max %u",
+ ext2_ino, inode_size,
+ btrfs_symlink_max_size(trans->fs_info));
+ return -ENAMETOOLONG;
+ }
ret = ext2_create_file_extents(trans, root, objectid,
btrfs_inode, ext2_fs, ext2_ino,
CONVERT_FLAG_DATACSUM |
CONVERT_FLAG_INLINE_DATA);
- btrfs_set_stack_inode_size(btrfs_inode, inode_size);
return ret;
}
pathname = (char *)&(ext2_inode->i_block[0]);
BUG_ON(pathname[inode_size] != 0);
ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
- pathname, inode_size + 1);
- btrfs_set_stack_inode_nbytes(btrfs_inode, inode_size + 1);
+ pathname, inode_size);
+ btrfs_set_stack_inode_nbytes(btrfs_inode, inode_size);
return ret;
}
@@ -537,9 +537,15 @@ static int reiserfs_copy_symlink(struct btrfs_trans_handle *trans,
symlink = tp_item_body(&path);
len = get_ih_item_len(tp_item_head(&path));
+ if (len > btrfs_symlink_max_size(trans->fs_info)) {
+ error("symlink too large, has %u max %u",
+ len, btrfs_symlink_max_size(trans->fs_info));
+ ret = -ENAMETOOLONG;
+ goto fail;
+ }
ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
- symlink, len + 1);
- btrfs_set_stack_inode_nbytes(btrfs_inode, len + 1);
+ symlink, len);
+ btrfs_set_stack_inode_nbytes(btrfs_inode, len);
fail:
pathrelse(&path);
return ret;
@@ -26,6 +26,7 @@
#include "kernel-shared/extent_io.h"
#include "kernel-shared/uapi/btrfs.h"
#include "common/internal.h"
+#include "common/messages.h"
#define MAX_CSUM_ITEMS(r, size) ((((BTRFS_LEAF_DATA_SIZE(r->fs_info) - \
sizeof(struct btrfs_item) * 2) / \
@@ -88,6 +89,7 @@ int btrfs_insert_inline_extent(struct btrfs_trans_handle *trans,
struct btrfs_root *root, u64 objectid,
u64 offset, const char *buffer, size_t size)
{
+ struct btrfs_fs_info *fs_info = trans->fs_info;
struct btrfs_key key;
struct btrfs_path *path;
struct extent_buffer *leaf;
@@ -97,6 +99,10 @@ int btrfs_insert_inline_extent(struct btrfs_trans_handle *trans,
int err = 0;
int ret;
+ if (size > max(btrfs_symlink_max_size(fs_info),
+ btrfs_data_inline_max_size(fs_info)))
+ return -EUCLEAN;
+
path = btrfs_alloc_path();
if (!path)
return -ENOMEM;
@@ -92,5 +92,23 @@ int btrfs_csum_file_block(struct btrfs_trans_handle *trans, u64 logical,
int btrfs_insert_inline_extent(struct btrfs_trans_handle *trans,
struct btrfs_root *root, u64 objectid,
u64 offset, const char *buffer, size_t size);
+/*
+ * For symlink we allow up to PATH_MAX - 1 (PATH_MAX includes the terminating NUL,
+ * but fs doesn't store that terminating NUL).
+ *
+ * But for inlined data extents, the up limit is sectorsize - 1 (inclusive), or a
+ * regular extent should be created instead.
+ */
+static inline u32 btrfs_symlink_max_size(struct btrfs_fs_info *fs_info)
+{
+ return min_t(u32, BTRFS_MAX_INLINE_DATA_SIZE(fs_info),
+ PATH_MAX - 1);
+}
+
+static inline u32 btrfs_data_inline_max_size(struct btrfs_fs_info *fs_info)
+{
+ return min_t(u32, BTRFS_MAX_INLINE_DATA_SIZE(fs_info),
+ fs_info->sectorsize - 1);
+}
#endif
[BUG] Sometimes test case btrfs/012 fails randomly, with the failure to read a softlink: QA output created by 012 Checking converted btrfs against the original one: -OK +readlink: Structure needs cleaning Checking saved ext2 image against the original one: OK Furthermore, this will trigger a kernel error message: BTRFS critical (device dm-2): regular/prealloc extent found for non-regular inode 133081 [CAUSE] For that specific inode 133081, the tree dump looks like this: item 127 key (133081 INODE_ITEM 0) itemoff 40984 itemsize 160 generation 1 transid 1 size 4095 nbytes 4096 block group 0 mode 120777 links 1 uid 0 gid 0 rdev 0 sequence 0 flags 0x0(none) item 128 key (133081 INODE_REF 133080) itemoff 40972 itemsize 12 index 2 namelen 2 name: l3 item 129 key (133081 EXTENT_DATA 0) itemoff 40919 itemsize 53 generation 4 type 1 (regular) extent data disk byte 2147483648 nr 38080512 extent data offset 37974016 nr 4096 ram 38080512 extent compression 0 (none) Note that, the soft link inode size is 4095 at the max size (PATH_MAX, removing the terminating NUL). But the nbytes is 4096, exactly matching the sector size of the btrfs. Thus it results the creation of a regular extent, but for btrfs we do not accept a soft link with a regular/preallocated extent, thus kernel rejects such read and failed the readlink call. The root cause is in the convert code, where for soft links we always create a data extent with its size + 1, causing the above problem. I guess the original code is to handle the terminating NUL, but in btrfs we never need to store the terminating NUL for inline extents nor file names. Thus this pitfall in btrfs-convert leads to the above invalid data extent and fail the test case. [FIX] - Fix the ext2 and reiserfs symbolic link creation code To remove the terminating NUL. - Add extra checks for the size of a symbolic link Btrfs has extra limits on the size of a symbolic link, as btrfs must store symbolic link targets as inlined extents. This means for 4K node sized btrfs, the size limit is smaller than the usual PATH_MAX - 1 (only around 4000 bytes instead of 4095). So for certain nodesize, some filesystems can not be converted to btrfs. (this should be rare, because the default nodesize is 16K already) - Split the symbolic link and inline data extent size checks For symbolic links the real limit is PATH_MAX - 1 (removing the terminating NUL), but for inline data extents the limit is sectorsize - 1, which can be different from 4096 - 1 (e.g. 64K sector size). Signed-off-by: Qu Wenruo <wqu@suse.com> --- convert/source-ext2.c | 29 +++++++++++++++++++++++------ convert/source-reiserfs.c | 10 ++++++++-- kernel-shared/file-item.c | 6 ++++++ kernel-shared/file-item.h | 18 ++++++++++++++++++ 4 files changed, 55 insertions(+), 8 deletions(-)