btrfs: support fsverity
v5 cover btrfs: support fsverity
This patchset provides support for fsverity in btrfs.
At a high level, we store the verity descriptor and Merkle tree data in the file system btree with the file's inode as the objectid, and direct reads/writes to those items to implement the generic fsverity interface required by fs/verity/.
The first patch is a preparatory patch which adds a notion of compat_flags to the btrfs_inode and inode_item in order to allow enabling verity on a file without making the file system unusable for older kernels.
The second patch is the bulk of the fsverity implementation. It implements the fsverity interface, storage, caching, etc...
The third patch handles crashes mid-verity enable via orphan items.
I have tested this patch set in the following ways:
- xfstests auto group
- with a separate fix for btrfs fiemap and some light touches to the tests themselves: xfstests generic/572,573,574,575.
- new xfstest for btrfs specific corruptions (e.g. inline extents).
- new xfstest using dmlogwrites and dmsnapshot to exercise orphans.
- new xfstest using pwrite to exercise merkle cache EFBIG cases
- manual test with sleeps in kernel to force orphan vs. unlink race.
- manual end-to-end test with verity signed rpms.
--
changes for v5:
Significant rewrite/re-organization. Most changes in patch 1 and 2:
- rewrote ro_compat flags to use top 32 bits of flags, discovered tree checker/flags definitions were broken (see patch 1 for details)
- merged dio and inline/prealloc/hole patches into main verity patch, as they were basically empty.
- rewrote rollback to abort much less aggressively
- put orphan/enable verity on inode in one btrfs transaction
- tweaks to returned types to prefer u64 where reasonable
- use kmap_local, memzero_page properly
- use GFP_NOFS for allocating merkle tree cache pages
- many documentation fixes/improvements
- many style fixes
- rebase onto kdave/misc-next as of 6/24
changes for v4:
Patch 2:
- fix build without CONFIG_VERITY
- fix assumption of short writes
- make true_size match the item contents in get_verity_descriptor
- rewrite overflow logic in terms of file position instead of cache index
- round up position by 64k instead of adding 2048 pages
- fix conflation of block index and page index in write_merkle_block
- ensure reserved fields are 0 in the new descriptor item.
changes for v3:
Patch 2: fix bug in overflow logic, fix interface of get_verity_descriptor, truncate merkle cache items on failure, fix various code/style issues.
Patch 5: fix extent data leak if verity races with unlink or O_TMPFILE and removes a legitimate orphan, then system is interrupted such that the orphan was needed.
changes for v2:
Patch 1: Unchanged.
Patch 2: Return EFBIG if Merkle data past s_maxbytes. Added special descriptor item for encryption and to handle ERANGE case for get_verity_descriptor. Improved function comments. Rebased onto subpage read patches -- modified end_page_read to do verity check before marking the page uptodate. Changed from full compat to ro_compat; merged sysfs feature here.
Patch 3: Rebased onto subpage read patches.
Patch 4: Unchanged.
Patch 5: Used to be sysfs feature, now a new patch that handles orphaned verity data.
Boris Burkov (3):
btrfs: add ro compat flags to inodes
btrfs: initial fsverity support
btrfs: verity metadata orphan items
fs/btrfs/Makefile | 1 + fs/btrfs/btrfs_inode.h | 27 +- fs/btrfs/ctree.h | 53 +- fs/btrfs/delayed-inode.c | 9 +- fs/btrfs/extent_io.c | 25 +- fs/btrfs/file.c | 10 + fs/btrfs/inode.c | 31 +- fs/btrfs/ioctl.c | 21 +- fs/btrfs/super.c | 3 + fs/btrfs/sysfs.c | 6 + fs/btrfs/tree-checker.c | 18 +- fs/btrfs/tree-log.c | 5 +- fs/btrfs/verity.c | 833 ++++++++++++++++++++++++++++++++ include/uapi/linux/btrfs.h | 1 + include/uapi/linux/btrfs_tree.h | 35 ++ 15 files changed, 1031 insertions(+), 47 deletions(-) create mode 100644 fs/btrfs/verity.c
Signature · 1 line
2.31.1
PATCH v5 1/3 btrfs: add ro compat flags to inodes
Currently, inode flags are fully backwards incompatible in btrfs. If we introduce a new inode flag, then tree-checker will detect it and fail. This can even cause us to fail to mount entirely. To make it possible to introduce new flags which can be read-only compatible, like VERITY, we add new ro flags to btrfs without treating them quite so harshly in tree-checker. A read-only file system can survive an unexpected flag, and can be mounted.
As for the implementation, it unfortunately gets a little complicated.
The on-disk representation of the inode, btrfs_inode_item, has an __le64 for flags but the in-memory representation, btrfs_inode, uses a u32. Dave Sterba had the nice idea that we could reclaim those wasted 32 bits on disk and use them for the new ro-compat flags.
It turns out that the tree-checker code which checks for unknown flags is broken, and ignores the upper 32 bits we are hoping to use. The issue is that the flags use the literal 1 rather than 1ULL, so the flags are signed ints, and one of them is specifically (1 << 31). As a result, the mask which ORs the flags is a negative integer on machines where int is 32 bit twos complement. When tree-checker evaluates the expression:
btrfs_inode_flags(leaf, iitem) & ~BTRFS_INODE_FLAG_MASK)
The mask is something like 0x80000abc, which gets promoted to u64 with sign extension to 0xffffffff80000abc. Negating that 64 bit mask leaves all the upper bits zeroed, and we can't detect unexpected flags.
This suggests that we can't use those bits after all. Luckily, we have good reason to believe that they are zero anyway. Inode flags are metadata, which is always checksummed, so any bit flips that would introduce 1s would cause a checksum failure anyway (excluding the improbable case of the checksum getting corruped exactly badly). Further, unless the 1 << 31 flag is used, the cast to u64 of the 32 bit inode flag should preserve its value and not add leading zeroes (at least for twos complement..) The only place that flag (BTRFS_INODE_ROOT_ITEM_INIT) is used is in a special inode embedded in the root item, and indeed for that inode we see 0xffffffff80000000 as the flags on disk. However, that inode is never seen by tree checker, nor is it used in a context where verity might be meaningful. Theoretically, a future ro flag might cause trouble on that inode, so we should proactively clean up that mess before it does.
With the introduction of the new ro flags, keep two separate unsigned masks and check them against the appropriate u32. Since we no longer run afoul of sign extension, this also stops writing out 0xffffffff80000000 in root_item inodes going forward.
--- fs/btrfs/btrfs_inode.h | 20 +++++++++++++++++++- fs/btrfs/ctree.h | 30 ++++++++++++++++-------------- fs/btrfs/delayed-inode.c | 9 +++++++-- fs/btrfs/inode.c | 9 +++++++-- fs/btrfs/ioctl.c | 7 ++++--- fs/btrfs/tree-checker.c | 18 ++++++++++++++---- fs/btrfs/tree-log.c | 5 ++++- 7 files changed, 71 insertions(+), 27 deletions(-)
fs/btrfs/btrfs_inode.h +19 -1
@@ -189,8 +189,10 @@ struct btrfs_inode {*/ u64 csum_bytes; -/* flags field from the on disk inode */ +/* Backwards incompatible flags, lower half of inode_item::flags */ u32 flags; +/* Read-only compatibility flags, upper half of inode_item::flags */ +u32 ro_flags;/* * Counters to keep track of the number of extent item's we may use due
@@ -348,6 +350,22 @@ struct btrfs_dio_private {u8 csums[]; }; +/* +* btrfs_inode_item stores flags in a u64, btrfs_inode stores them in two +* separate u32s. These two functions convert between the two representations. +*/ +static inline u64 btrfs_inode_combine_flags (u32 flags,u32 ro_flags) +{ +return (flags | ((u64 )ro_flags <<32 )); +} + +static inline void btrfs_inode_split_flags (u64 inode_item_flags, +u32 *flags,u32 *ro_flags) +{ + *flags = (u32 )inode_item_flags; + *ro_flags = (u32)(inode_item_flags >>32 ); +} +/* Array of bytes with variable length, hexadecimal format 0x1234 */ #define CSUM_FMT "0x%*phN"#define CSUM_FMT_VALUE (size, bytes) size, bytes
fs/btrfs/ctree.h +16 -14
@@ -1486,20 +1486,20 @@ do { \/* * Inode flags */ -#define BTRFS_INODE_NODATASUM (1 << 0) -#define BTRFS_INODE_NODATACOW (1 << 1) -#define BTRFS_INODE_READONLY (1 << 2) -#define BTRFS_INODE_NOCOMPRESS (1 << 3) -#define BTRFS_INODE_PREALLOC (1 << 4) -#define BTRFS_INODE_SYNC (1 << 5) -#define BTRFS_INODE_IMMUTABLE (1 << 6) -#define BTRFS_INODE_APPEND (1 << 7) -#define BTRFS_INODE_NODUMP (1 << 8) -#define BTRFS_INODE_NOATIME (1 << 9) -#define BTRFS_INODE_DIRSYNC (1 << 10) -#define BTRFS_INODE_COMPRESS (1 << 11) - -#define BTRFS_INODE_ROOT_ITEM_INIT (1 << 31) +#define BTRFS_INODE_NODATASUM (1U << 0) +#define BTRFS_INODE_NODATACOW (1U << 1) +#define BTRFS_INODE_READONLY (1U << 2) +#define BTRFS_INODE_NOCOMPRESS (1U << 3) +#define BTRFS_INODE_PREALLOC (1U << 4) +#define BTRFS_INODE_SYNC (1U << 5) +#define BTRFS_INODE_IMMUTABLE (1U << 6) +#define BTRFS_INODE_APPEND (1U << 7) +#define BTRFS_INODE_NODUMP (1U << 8) +#define BTRFS_INODE_NOATIME (1U << 9) +#define BTRFS_INODE_DIRSYNC (1U << 10) +#define BTRFS_INODE_COMPRESS (1U << 11) + +#define BTRFS_INODE_ROOT_ITEM_INIT (1U << 31)#define BTRFS_INODE_FLAG_MASK \ (BTRFS_INODE_NODATASUM | \
@@ -1516,6 +1516,8 @@ do { \ BTRFS_INODE_COMPRESS | \ BTRFS_INODE_ROOT_ITEM_INIT) +#define BTRFS_INODE_RO_FLAG_MASK (0) +struct btrfs_map_token {struct extent_buffer *eb;char *kaddr;
fs/btrfs/delayed-inode.c +7 -2
@@ -1711,6 +1711,8 @@ static void fill_stack_inode_item(struct btrfs_trans_handle *trans,struct btrfs_inode_item *inode_item, struct inode *inode) { + u64 flags; +btrfs_set_stack_inode_uid (inode_item,i_uid_read (inode));btrfs_set_stack_inode_gid (inode_item,i_gid_read (inode));btrfs_set_stack_inode_size (inode_item,BTRFS_I (inode)->disk_i_size);
@@ -1723,7 +1725,9 @@ static void fill_stack_inode_item(struct btrfs_trans_handle *trans, inode_peek_iversion(inode));btrfs_set_stack_inode_transid (inode_item, trans->transid);btrfs_set_stack_inode_rdev (inode_item, inode->i_rdev); -btrfs_set_stack_inode_flags (inode_item,BTRFS_I (inode)->flags); + flags =btrfs_inode_combine_flags (BTRFS_I (inode)->flags, +BTRFS_I (inode)->ro_flags); +btrfs_set_stack_inode_flags (inode_item, flags);btrfs_set_stack_inode_block_group (inode_item,0 ); btrfs_set_stack_timespec_sec(&inode_item->atime,
@@ -1781,7 +1785,8 @@ int btrfs_fill_inode(struct inode *inode, u32 *rdev) btrfs_stack_inode_sequence(inode_item)); inode->i_rdev =0 ; *rdev =btrfs_stack_inode_rdev (inode_item); -BTRFS_I (inode)->flags =btrfs_stack_inode_flags (inode_item); +btrfs_inode_split_flags (btrfs_stack_inode_flags (inode_item), + &BTRFS_I (inode)->flags, &BTRFS_I (inode)->ro_flags); inode->i_atime.tv_sec =btrfs_stack_timespec_sec (&inode_item->atime); inode->i_atime.tv_nsec =btrfs_stack_timespec_nsec (&inode_item->atime);
fs/btrfs/inode.c +7 -2
@@ -3639,7 +3639,8 @@ static int btrfs_read_locked_inode(struct inode *inode, rdev =btrfs_inode_rdev (leaf, inode_item);BTRFS_I (inode)->index_cnt = (u64)-1 ; -BTRFS_I (inode)->flags =btrfs_inode_flags (leaf, inode_item); +btrfs_inode_split_flags (btrfs_inode_flags (leaf, inode_item), + &BTRFS_I (inode)->flags, &BTRFS_I (inode)->ro_flags); cache_index:/*
@@ -3770,6 +3771,7 @@ static void fill_inode_item(struct btrfs_trans_handle *trans, struct inode *inode) {struct btrfs_map_token token; +u64 flags;btrfs_init_map_token (&token, leaf);
@@ -3805,7 +3807,9 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,btrfs_set_token_inode_sequence (&token, item,inode_peek_iversion (inode));btrfs_set_token_inode_transid (&token, item, trans->transid);btrfs_set_token_inode_rdev (&token, item, inode->i_rdev); -btrfs_set_token_inode_flags (&token, item,BTRFS_I (inode)->flags); + flags =btrfs_inode_combine_flags (BTRFS_I (inode)->flags, +BTRFS_I (inode)->ro_flags); +btrfs_set_token_inode_flags (&token, item, flags);btrfs_set_token_inode_block_group (&token, item,0 ); }
@@ -8904,6 +8908,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb) ei->defrag_bytes =0 ; ei->disk_i_size =0 ; ei->flags =0 ; + ei->ro_flags =0 ; ei->csum_bytes =0 ; ei->index_cnt = (u64)-1 ; ei->dir_index =0 ;
fs/btrfs/ioctl.c +4 -3
@@ -103,9 +103,10 @@ static unsigned int btrfs_mask_fsflags_for_type(struct inode *inode,* Export internal inode flags to the format expected by the FS_IOC_GETFLAGS * ioctl. */ -static unsigned int btrfs_inode_flags_to_fsflags (unsigned int flags) +static unsigned int btrfs_inode_flags_to_fsflags (struct btrfs_inode *binode) {unsigned int iflags =0 ; +u32 flags = binode->flags;if (flags &BTRFS_INODE_SYNC ) iflags |=FS_SYNC_FL ;
@@ -200,7 +201,7 @@ int btrfs_fileattr_get(struct dentry *dentry, struct fileattr *fa) {struct btrfs_inode *binode =BTRFS_I (d_inode (dentry)); -fileattr_fill_flags (fa,btrfs_inode_flags_to_fsflags (binode->flags)); +fileattr_fill_flags (fa,btrfs_inode_flags_to_fsflags (binode));return 0 ; }
@@ -224,7 +225,7 @@ int btrfs_fileattr_set(struct user_namespace *mnt_userns,return -EOPNOTSUPP ; fsflags =btrfs_mask_fsflags_for_type (inode, fa->flags); - old_fsflags =btrfs_inode_flags_to_fsflags (binode->flags); + old_fsflags =btrfs_inode_flags_to_fsflags (binode); ret =check_fsflags (old_fsflags, fsflags);if (ret)return ret;
fs/btrfs/tree-checker.c +14 -4
@@ -24,6 +24,7 @@#include "compression.h" #include "volumes.h" #include "misc.h" +#include "btrfs_inode.h" /* * Error message should follow the following format:
@@ -999,6 +1000,8 @@ static int check_inode_item(struct extent_buffer *leaf,u32 valid_mask = (S_IFMT |S_ISUID |S_ISGID |S_ISVTX |0777 );u32 mode;int ret; +u32 flags; +u32 ro_flags; ret =check_inode_key (leaf, key, slot);if (unlikely (ret <0 ))
@@ -1054,11 +1057,18 @@ static int check_inode_item(struct extent_buffer *leaf, btrfs_inode_nlink(leaf, iitem));return -EUCLEAN ; } -if (unlikely (btrfs_inode_flags (leaf, iitem) & ~BTRFS_INODE_FLAG_MASK )) { +btrfs_inode_split_flags (btrfs_inode_flags (leaf, iitem), + &flags, &ro_flags); +if (unlikely (flags & ~BTRFS_INODE_FLAG_MASK )) {inode_item_err (leaf, slot, -"unknown flags detected: 0x%llx" , -btrfs_inode_flags (leaf, iitem) & - ~BTRFS_INODE_FLAG_MASK ); +"unknown incompat flags detected: 0x%x" , flags); +return -EUCLEAN ; + } +if (unlikely (!sb_rdonly (fs_info->sb) && + (ro_flags & ~BTRFS_INODE_RO_FLAG_MASK ))) { +inode_item_err (leaf, slot, +"unknown ro-compat flags detected on writeable mount: 0x%x" , + ro_flags);return -EUCLEAN ; }return 0 ;
fs/btrfs/tree-log.c +4 -1
@@ -3913,6 +3913,7 @@ static void fill_inode_item(struct btrfs_trans_handle *trans, u64 logged_isize) {struct btrfs_map_token token; +u64 flags;btrfs_init_map_token (&token, leaf);
@@ -3962,7 +3963,9 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,btrfs_set_token_inode_sequence (&token, item,inode_peek_iversion (inode));btrfs_set_token_inode_transid (&token, item, trans->transid);btrfs_set_token_inode_rdev (&token, item, inode->i_rdev); -btrfs_set_token_inode_flags (&token, item,BTRFS_I (inode)->flags); + flags =btrfs_inode_combine_flags (BTRFS_I (inode)->flags, +BTRFS_I (inode)->ro_flags); +btrfs_set_token_inode_flags (&token, item, flags);btrfs_set_token_inode_block_group (&token, item,0 ); }
Signature · 1 line
2.31.1
PATCH v5 2/3 btrfs: initial fsverity support
In reply to Boris BurkovAdd support for fsverity in btrfs. To support the generic interface in fs/verity, we add two new item types in the fs tree for inodes with verity enabled. One stores the per-file verity descriptor and btrfs verity item and the other stores the Merkle tree data itself.
Verity checking is done in end_page_read just before a page is marked uptodate. This naturally handles a variety of edge cases like holes, preallocated extents, and inline extents. Some care needs to be taken to not try to verity pages past the end of the file, which are accessed by the generic buffered file reading code under some circumstances like reading to the end of the last page and trying to read again. Direct IO on a verity file falls back to buffered reads.
Verity relies on PageChecked for the Merkle tree data itself to avoid re-walking up shared paths in the tree. For this reason, we need to cache the Merkle tree data. Since the file is immutable after verity is turned on, we can cache it at an index past EOF.
Use the new inode ro_flags to store verity on the inode item, so that we can enable verity on a file, then rollback to an older kernel and still mount the file system and read the file. Since we can't safely write the file anymore without ruining the invariants of the Merkle tree, we mark a ro_compat flag on the file system when a file has verity enabled.
--- fs/btrfs/Makefile | 1 + fs/btrfs/btrfs_inode.h | 7 + fs/btrfs/ctree.h | 25 +- fs/btrfs/extent_io.c | 25 +- fs/btrfs/file.c | 10 + fs/btrfs/inode.c | 6 + fs/btrfs/ioctl.c | 14 +- fs/btrfs/super.c | 3 + fs/btrfs/sysfs.c | 6 + fs/btrfs/verity.c | 763 ++++++++++++++++++++++++++++++++ include/uapi/linux/btrfs.h | 1 + include/uapi/linux/btrfs_tree.h | 35 ++ 12 files changed, 877 insertions(+), 19 deletions(-) create mode 100644 fs/btrfs/verity.c
fs/btrfs/Makefile +1 -0
@@ -36,6 +36,7 @@ btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o btrfs-$(CONFIG_BTRFS_FS_REF_VERIFY) += ref-verify.o btrfs-$(CONFIG_BLK_DEV_ZONED) += zoned.o +btrfs-$(CONFIG_FS_VERITY) += verity.o btrfs-$(CONFIG_BTRFS_FS_RUN_SANITY_TESTS) += tests/free-space-tests.o \ tests/extent-buffer-tests.o tests/btrfs-tests.o \
fs/btrfs/btrfs_inode.h +7 -0
@@ -51,6 +51,13 @@ enum {* the file range, inode's io_tree). */ BTRFS_INODE_NO_DELALLOC_FLUSH , +/* +* Set when we are working on enabling verity for a file. Computing and +* writing the whole Merkle tree can take a while so we want to prevent +* races where two separate tasks attempt to simultaneously start verity +* on the same file. +*/ + BTRFS_INODE_VERITY_IN_PROGRESS, };/* in memory btrfs inode */
fs/btrfs/ctree.h +23 -2
@@ -281,7 +281,8 @@ struct btrfs_super_block {#define BTRFS_FEATURE_COMPAT_RO_SUPP \ (BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE | \ - BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID) + BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID | \ + BTRFS_FEATURE_COMPAT_RO_VERITY)#define BTRFS_FEATURE_COMPAT_RO_SAFE_SET 0ULL#define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR 0ULL
@@ -1516,7 +1517,9 @@ do { \ BTRFS_INODE_COMPRESS | \ BTRFS_INODE_ROOT_ITEM_INIT) -#define BTRFS_INODE_RO_FLAG_MASK (0) +#define BTRFS_INODE_RO_VERITY (1U << 0) + +#define BTRFS_INODE_RO_FLAG_MASK (BTRFS_INODE_RO_VERITY)struct btrfs_map_token {struct extent_buffer *eb;
@@ -3783,6 +3786,24 @@ static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)return signal_pending (current); } +/* verity.c */ +#ifdef CONFIG_FS_VERITY +extern const struct fsverity_operations btrfs_verityops; +int btrfs_drop_verity_items (struct btrfs_inode *inode); +BTRFS_SETGET_FUNCS(verity_descriptor_encryption, struct btrfs_verity_descriptor_item, + encryption,8 ); +BTRFS_SETGET_FUNCS(verity_descriptor_size, struct btrfs_verity_descriptor_item, size, 64); +BTRFS_SETGET_STACK_FUNCS(stack_verity_descriptor_encryption, struct btrfs_verity_descriptor_item, + encryption,8 ); +BTRFS_SETGET_STACK_FUNCS(stack_verity_descriptor_size, struct btrfs_verity_descriptor_item, + size,64 ); +#else +static inline int btrfs_drop_verity_items (struct btrfs_inode *inode) +{ +return 0 ; +} +#endif +/* Sanity test specific functions */ #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS void btrfs_test_destroy_inode (struct inode *inode);
fs/btrfs/extent_io.c +10 -15
@@ -13,6 +13,7 @@#include <linux/pagevec.h> #include <linux/prefetch.h> #include <linux/cleancache.h> +#include <linux/fsverity.h> #include "misc.h" #include "extent_io.h" #include "extent-io-tree.h"
@@ -2245,18 +2246,6 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end,return bitset; } -/* -* helper function to set a given page up to date if all the -* extents in the tree for that page are up to date -*/ -static void check_page_uptodate (struct extent_io_tree *tree,struct page *page) -{ -u64 start =page_offset (page); -u64 end = start +PAGE_SIZE -1 ; -if (test_range_bit (tree, start, end,EXTENT_UPTODATE ,1 ,NULL )) -SetPageUptodate (page); -} -int free_io_failure (struct extent_io_tree *failure_tree,struct extent_io_tree *io_tree,struct io_failure_record *rec)
@@ -2688,7 +2677,14 @@ static void end_page_read(struct page *page, bool uptodate, u64 start, u32 len) start + len <= page_offset(page) + PAGE_SIZE);if (uptodate) { -btrfs_page_set_uptodate (fs_info, page, start, len); +if (!PageError (page) && !PageUptodate (page) && + start <i_size_read (page->mapping->host) && +fsverity_active (page->mapping->host) && + !fsverity_verify_page (page)) { +btrfs_page_set_error (fs_info, page, start, len); + }else { +btrfs_page_set_uptodate (fs_info, page, start, len); + } }else {btrfs_page_clear_uptodate (fs_info, page, start, len);btrfs_page_set_error (fs_info, page, start, len);
@@ -3097,7 +3093,7 @@ static void end_bio_extent_readpage(struct bio *bio)/* Update page status and unlock */ end_page_read (page, uptodate, start, len);endio_readpage_release_extent (&processed,BTRFS_I (inode), - start, end, uptodate); + start, end,PageUptodate (page)); }/* Release the last extent */ endio_readpage_release_extent (&processed,NULL ,0 ,0 , false);
@@ -3627,7 +3623,6 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,/* the get_extent function already copied into the page */ if (test_range_bit (tree, cur, cur_end,EXTENT_UPTODATE ,1 ,NULL )) { -check_page_uptodate (tree, page);unlock_extent (tree, cur, cur + iosize -1 );end_page_read (page, true, cur, iosize); cur = cur + iosize;
fs/btrfs/file.c +10 -0
@@ -16,6 +16,7 @@#include <linux/btrfs.h> #include <linux/uio.h> #include <linux/iversion.h> +#include <linux/fsverity.h> #include "ctree.h" #include "disk-io.h" #include "transaction.h"
@@ -3605,7 +3606,13 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)static int btrfs_file_open (struct inode *inode,struct file *filp) { +int ret; + filp->f_mode |=FMODE_NOWAIT |FMODE_BUF_RASYNC ; + + ret =fsverity_file_open (inode, filp); +if (ret) +return ret;return generic_file_open (inode, filp); }
@@ -3634,6 +3641,9 @@ static ssize_t btrfs_direct_read(struct kiocb *iocb, struct iov_iter *to)struct inode *inode =file_inode (iocb->ki_filp);ssize_t ret; +if (fsverity_active (inode)) +return 0 ; +if (check_direct_read (btrfs_sb (inode->i_sb), to, iocb->ki_pos))return 0 ;
fs/btrfs/inode.c +6 -0
@@ -32,6 +32,7 @@#include <linux/sched/mm.h> #include <linux/iomap.h> #include <asm/unaligned.h> +#include <linux/fsverity.h> #include "misc.h" #include "ctree.h" #include "disk-io.h"
@@ -5437,6 +5438,7 @@ void btrfs_evict_inode(struct inode *inode)trace_btrfs_inode_evict (inode);if (!root) { +fsverity_cleanup_inode (inode);clear_inode (inode);return ; }
@@ -5519,6 +5521,7 @@ void btrfs_evict_inode(struct inode *inode)* to retry these periodically in the future. */ btrfs_remove_delayed_node (BTRFS_I (inode)); +fsverity_cleanup_inode (inode);clear_inode (inode); }
@@ -9090,6 +9093,7 @@ static int btrfs_getattr(struct user_namespace *mnt_userns,struct inode *inode =d_inode (path->dentry);u32 blocksize = inode->i_sb->s_blocksize;u32 bi_flags =BTRFS_I (inode)->flags; +u32 bi_ro_flags =BTRFS_I (inode)->ro_flags; stat->result_mask |=STATX_BTIME ; stat->btime.tv_sec =BTRFS_I (inode)->i_otime.tv_sec;
@@ -9102,6 +9106,8 @@ static int btrfs_getattr(struct user_namespace *mnt_userns, stat->attributes |=STATX_ATTR_IMMUTABLE ;if (bi_flags &BTRFS_INODE_NODUMP ) stat->attributes |=STATX_ATTR_NODUMP ; +if (bi_ro_flags &BTRFS_INODE_RO_VERITY ) + stat->attributes |=STATX_ATTR_VERITY ; stat->attributes_mask |= (STATX_ATTR_APPEND | STATX_ATTR_COMPRESSED |
fs/btrfs/ioctl.c +12 -2
@@ -27,6 +27,7 @@#include <linux/uaccess.h> #include <linux/iversion.h> #include <linux/fileattr.h> +#include <linux/fsverity.h> #include "ctree.h" #include "disk-io.h" #include "export.h"
@@ -107,6 +108,7 @@ static unsigned int btrfs_inode_flags_to_fsflags(struct btrfs_inode *binode) {unsigned int iflags =0 ;u32 flags = binode->flags; +u32 ro_flags = binode->ro_flags;if (flags &BTRFS_INODE_SYNC ) iflags |=FS_SYNC_FL ;
@@ -122,6 +124,8 @@ static unsigned int btrfs_inode_flags_to_fsflags(struct btrfs_inode *binode) iflags |=FS_DIRSYNC_FL ;if (flags &BTRFS_INODE_NODATACOW ) iflags |=FS_NOCOW_FL ; +if (ro_flags &BTRFS_INODE_RO_VERITY ) + iflags |=FS_VERITY_FL ;if (flags &BTRFS_INODE_NOCOMPRESS ) iflags |=FS_NOCOMP_FL ;
@@ -149,10 +153,12 @@ void btrfs_sync_inode_flags_to_i_flags(struct inode *inode) new_fl |=S_NOATIME ;if (binode->flags &BTRFS_INODE_DIRSYNC ) new_fl |=S_DIRSYNC ; +if (binode->ro_flags &BTRFS_INODE_RO_VERITY ) + new_fl |=S_VERITY ;set_mask_bits (&inode->i_flags, -S_SYNC |S_APPEND |S_IMMUTABLE |S_NOATIME |S_DIRSYNC , - new_fl); +S_SYNC |S_APPEND |S_IMMUTABLE |S_NOATIME |S_DIRSYNC | +S_VERITY , new_fl); }/*
@@ -5014,6 +5020,10 @@ long btrfs_ioctl(struct file *file, unsigned intreturn btrfs_ioctl_get_subvol_rootref (file, argp);case BTRFS_IOC_INO_LOOKUP_USER :return btrfs_ioctl_ino_lookup_user (file, argp); +case FS_IOC_ENABLE_VERITY : +return fsverity_ioctl_enable (file, (const void __user *)argp); +case FS_IOC_MEASURE_VERITY : +return fsverity_ioctl_measure (file, argp); }return -ENOTTY ;
fs/btrfs/super.c +3 -0
@@ -1353,6 +1353,9 @@ static int btrfs_fill_super(struct super_block *sb, sb->s_op = &btrfs_super_ops; sb->s_d_op = &btrfs_dentry_operations; sb->s_export_op = &btrfs_export_ops; +#ifdef CONFIG_FS_VERITY + sb->s_vop = &btrfs_verityops; +#endif sb->s_xattr = btrfs_xattr_handlers; sb->s_time_gran =1 ;#ifdef CONFIG_BTRFS_FS_POSIX_ACL
fs/btrfs/sysfs.c +6 -0
@@ -267,6 +267,9 @@ BTRFS_FEAT_ATTR_INCOMPAT(raid1c34, RAID1C34);#ifdef CONFIG_BTRFS_DEBUG BTRFS_FEAT_ATTR_INCOMPAT (zoned,ZONED );#endif +#ifdef CONFIG_FS_VERITY +BTRFS_FEAT_ATTR_COMPAT_RO (verity,VERITY ); +#endif static struct attribute *btrfs_supported_feature_attrs[] = {BTRFS_FEAT_ATTR_PTR (mixed_backref),
@@ -284,6 +287,9 @@ static struct attribute *btrfs_supported_feature_attrs[] = { BTRFS_FEAT_ATTR_PTR(raid1c34),#ifdef CONFIG_BTRFS_DEBUG BTRFS_FEAT_ATTR_PTR(zoned), +#endif +#ifdef CONFIG_FS_VERITY +BTRFS_FEAT_ATTR_PTR (verity), #endifNULL };
fs/btrfs/verity.c new file +763 -0
763 lines not on this page · raw message
include/uapi/linux/btrfs.h +1 -0
@@ -288,6 +288,7 @@ struct btrfs_ioctl_fs_info_args {* first mount when booting older kernel versions. */ #define BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID (1ULL << 1) +#define BTRFS_FEATURE_COMPAT_RO_VERITY (1ULL << 2)#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0)#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1)
include/uapi/linux/btrfs_tree.h +35 -0
@@ -118,6 +118,29 @@#define BTRFS_INODE_REF_KEY 12#define BTRFS_INODE_EXTREF_KEY 13#define BTRFS_XATTR_ITEM_KEY 24 + +/* +* fs verity items are stored under two different key types on disk. +* The descriptor items: +* [ inode objectid, BTRFS_VERITY_DESC_ITEM_KEY, offset ] +* +* At offset 0, we store a btrfs_verity_descriptor_item which tracks the +* size of the descriptor item and some extra data for encryption. +* Starting at offset 1, these hold the generic fs verity descriptor. +* The latter are opaque to btrfs, we just read and write them as a blob for the +* higher level verity code. The most common descriptor size is 256 bytes. +* +* The merkle tree items: +* [ inode objectid, BTRFS_VERITY_MERKLE_ITEM_KEY, offset ] +* +* These also start at offset 0, and correspond to the merkle tree bytes. +* When fsverity asks for page 0 of the merkle tree, we pull up one page +* starting at offset 0 for this key type. These are also opaque to btrfs, +* we're blindly storing whatever fsverity sends down. +*/ +#define BTRFS_VERITY_DESC_ITEM_KEY 36 +#define BTRFS_VERITY_MERKLE_ITEM_KEY 37 +#define BTRFS_ORPHAN_ITEM_KEY 48/* reserve 2-15 close to the inode for later flexibility */
@@ -991,4 +1014,16 @@ struct btrfs_qgroup_limit_item {__le64 rsv_excl; } __attribute__ ((__packed__)); +struct btrfs_verity_descriptor_item { +/* size of the verity descriptor in bytes */ +__le64 size; +/* +* When we implement support for fscrypt, we will need to encrypt the +* Merkle tree for encrypted verity files. These 128 bits are for the +* eventual storage of an fscrypt initialization vector. +*/ +__le64 reserved[2 ]; +__u8 encryption; +} __attribute__ ((__packed__ )); +#endif /* _BTRFS_CTREE_H_ */
Signature · 1 line
2.31.1
kernel test robot
build botRe: [PATCH v5 2/3] btrfs: initial fsverity support
Thank you for the patch! Perhaps something to improve:
Hi Boris,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on kdave/for-next]
[also build test WARNING on next-20210624]
[cannot apply to v5.13-rc7]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Boris-Burkov/btrfs-support-fsverity/20210625-064209 base: https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next config: x86_64-randconfig-a006-20210622 (attached as .config) compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 9ca0171a9ffdef5fdb1511d197a3fd72490362de)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# https://github.com/0day-ci/linux/commit/24749321fc3abc183fb4ed2c9ac21e556523fc55
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Boris-Burkov/btrfs-support-fsverity/20210625-064209 git checkout 24749321fc3abc183fb4ed2c9ac21e556523fc55
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
>> fs/btrfs/verity.c:217:6: warning: variable 'copied' set but not used [-Wunused-but-set-variable]
u64 copied = 0;
^
fs/btrfs/verity.c:536:21: warning: unused variable 'root' [-Wunused-variable]
struct btrfs_root *root = inode->root;
^
fs/btrfs/verity.c:552:24: warning: variable 'trans' is uninitialized when used here [-Wuninitialized]
btrfs_end_transaction(trans);
^~~~~
fs/btrfs/verity.c:537:34: note: initialize the variable 'trans' to silence this warning
struct btrfs_trans_handle *trans;
^
= NULL3 warnings generated.
vim +/copied +217 fs/btrfs/verity.c
191
192
193 /*
194 * Insert and write inode items with a given key type and offset.
195 *
196 * @inode: The inode to insert for.
197 * @key_type: The key type to insert.
198 * @offset: The item offset to insert at.
199 * @src: Source data to write.
200 * @len: Length of source data to write.
201 *
202 * Write len bytes from src into items of up to 1k length.
203 * The inserted items will have key <ino, key_type, offset + off> where
204 * off is consecutively increasing from 0 up to the last item ending at
205 * offset + len.
206 *
207 * Returns 0 on success and a negative error code on failure.
208 */
209 static int write_key_bytes(struct btrfs_inode *inode, u8 key_type, u64 offset,
210 const char *src, u64 len)
211 {
212 struct btrfs_trans_handle *trans;
213 struct btrfs_path *path;
214 struct btrfs_root *root = inode->root;
215 struct extent_buffer *leaf;
216 struct btrfs_key key;
> 217 u64 copied = 0;
218 unsigned long copy_bytes;
219 unsigned long src_offset = 0;
220 void *data;
221 int ret;
222
223 path = btrfs_alloc_path();
224 if (!path)
225 return -ENOMEM;
226
227 while (len > 0) {
228 /*
229 * 1 for the new item being inserted
230 */
231 trans = btrfs_start_transaction(root, 1);
232 if (IS_ERR(trans)) {
233 ret = PTR_ERR(trans);
234 break;
235 }
236
237 key.objectid = btrfs_ino(inode);
238 key.type = key_type;
239 key.offset = offset;
240
241 /*
242 * Insert 2K at a time mostly to be friendly for smaller
243 * leaf size filesystems
244 */
245 copy_bytes = min_t(u64, len, 2048);
246
247 ret = btrfs_insert_empty_item(trans, root, path, &key, copy_bytes);
248 if (ret) {
249 btrfs_end_transaction(trans);
250 break;
251 }
252
253 leaf = path->nodes[0];
254
255 data = btrfs_item_ptr(leaf, path->slots[0], void);
256 write_extent_buffer(leaf, src + src_offset,
257 (unsigned long)data, copy_bytes);
258 offset += copy_bytes;
259 src_offset += copy_bytes;
260 len -= copy_bytes;
261 copied += copy_bytes;
262
263 btrfs_release_path(path);
264 btrfs_end_transaction(trans);
265 }
266
267 btrfs_free_path(path);
268 return ret;
269 }
270
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Dan Carpenter
build botRe: [PATCH v5 2/3] btrfs: initial fsverity support
In reply to Boris BurkovCC: kbuild-all(a)lists.01.org In-Reply-To: <459e0acf996441628bc465bbe64218d7fea132c4.1624573983.git.boris@bur.io> References: <459e0acf996441628bc465bbe64218d7fea132c4.1624573983.git.boris(a)bur.io>…
CC: kbuild-all(a)lists.01.org
In-Reply-To: <459e0acf996441628bc465bbe64218d7fea132c4.1624573983.git.boris@bur.io>
References: <459e0acf996441628bc465bbe64218d7fea132c4.1624573983.git.boris(a)bur.io>
TO: Boris Burkov <[email protected]>
TO: linux-btrfs(a)vger.kernel.org
TO: linux-fscrypt(a)vger.kernel.org
TO: kernel-team(a)fb.com
Hi Boris,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on kdave/for-next]
[also build test WARNING on next-20210625]
[cannot apply to v5.13-rc7]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Boris-Burkov/btrfs-support-fsverity/20210625-064209 base: https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next
:::::: branch date: 19 hours ago
:::::: commit date: 19 hours ago
config: parisc-randconfig-m031-20210625 (attached as .config)
compiler: hppa-linux-gcc (GCC) 9.3.0
If you fix the issue, kindly add following tag as appropriate
New smatch warnings:fs/btrfs/verity.c:268 write_key_bytes() error: uninitialized symbol 'ret'. fs/btrfs/verity.c:745 btrfs_write_merkle_tree_block() warn: should '1 << log_blocksize' be a 64 bit type?
Old smatch warnings:fs/btrfs/verity.c:552 btrfs_begin_enable_verity() error: uninitialized symbol 'trans'.
vim +/ret +268 fs/btrfs/verity.c
24749321fc3abc Boris Burkov 2021-06-24 191
24749321fc3abc Boris Burkov 2021-06-24 192
24749321fc3abc Boris Burkov 2021-06-24 193 /*
24749321fc3abc Boris Burkov 2021-06-24 194 * Insert and write inode items with a given key type and offset.
24749321fc3abc Boris Burkov 2021-06-24 195 *
24749321fc3abc Boris Burkov 2021-06-24 196 * @inode: The inode to insert for.
24749321fc3abc Boris Burkov 2021-06-24 197 * @key_type: The key type to insert.
24749321fc3abc Boris Burkov 2021-06-24 198 * @offset: The item offset to insert at.
24749321fc3abc Boris Burkov 2021-06-24 199 * @src: Source data to write.
24749321fc3abc Boris Burkov 2021-06-24 200 * @len: Length of source data to write.
24749321fc3abc Boris Burkov 2021-06-24 201 *
24749321fc3abc Boris Burkov 2021-06-24 202 * Write len bytes from src into items of up to 1k length.
24749321fc3abc Boris Burkov 2021-06-24 203 * The inserted items will have key <ino, key_type, offset + off> where
24749321fc3abc Boris Burkov 2021-06-24 204 * off is consecutively increasing from 0 up to the last item ending at
24749321fc3abc Boris Burkov 2021-06-24 205 * offset + len.
24749321fc3abc Boris Burkov 2021-06-24 206 *
24749321fc3abc Boris Burkov 2021-06-24 207 * Returns 0 on success and a negative error code on failure.
24749321fc3abc Boris Burkov 2021-06-24 208 */
24749321fc3abc Boris Burkov 2021-06-24 209 static int write_key_bytes(struct btrfs_inode *inode, u8 key_type, u64 offset,
24749321fc3abc Boris Burkov 2021-06-24 210 const char *src, u64 len)
24749321fc3abc Boris Burkov 2021-06-24 211 {
24749321fc3abc Boris Burkov 2021-06-24 212 struct btrfs_trans_handle *trans;
24749321fc3abc Boris Burkov 2021-06-24 213 struct btrfs_path *path;
24749321fc3abc Boris Burkov 2021-06-24 214 struct btrfs_root *root = inode->root;
24749321fc3abc Boris Burkov 2021-06-24 215 struct extent_buffer *leaf;
24749321fc3abc Boris Burkov 2021-06-24 216 struct btrfs_key key;
24749321fc3abc Boris Burkov 2021-06-24 217 u64 copied = 0;
24749321fc3abc Boris Burkov 2021-06-24 218 unsigned long copy_bytes;
24749321fc3abc Boris Burkov 2021-06-24 219 unsigned long src_offset = 0;
24749321fc3abc Boris Burkov 2021-06-24 220 void *data;
24749321fc3abc Boris Burkov 2021-06-24 221 int ret;
24749321fc3abc Boris Burkov 2021-06-24 222
24749321fc3abc Boris Burkov 2021-06-24 223 path = btrfs_alloc_path();
24749321fc3abc Boris Burkov 2021-06-24 224 if (!path)
24749321fc3abc Boris Burkov 2021-06-24 225 return -ENOMEM;
24749321fc3abc Boris Burkov 2021-06-24 226
24749321fc3abc Boris Burkov 2021-06-24 227 while (len > 0) {
24749321fc3abc Boris Burkov 2021-06-24 228 /*
24749321fc3abc Boris Burkov 2021-06-24 229 * 1 for the new item being inserted
24749321fc3abc Boris Burkov 2021-06-24 230 */
24749321fc3abc Boris Burkov 2021-06-24 231 trans = btrfs_start_transaction(root, 1);
24749321fc3abc Boris Burkov 2021-06-24 232 if (IS_ERR(trans)) {
24749321fc3abc Boris Burkov 2021-06-24 233 ret = PTR_ERR(trans);
24749321fc3abc Boris Burkov 2021-06-24 234 break;
24749321fc3abc Boris Burkov 2021-06-24 235 }
24749321fc3abc Boris Burkov 2021-06-24 236
24749321fc3abc Boris Burkov 2021-06-24 237 key.objectid = btrfs_ino(inode);
24749321fc3abc Boris Burkov 2021-06-24 238 key.type = key_type;
24749321fc3abc Boris Burkov 2021-06-24 239 key.offset = offset;
24749321fc3abc Boris Burkov 2021-06-24 240
24749321fc3abc Boris Burkov 2021-06-24 241 /*
24749321fc3abc Boris Burkov 2021-06-24 242 * Insert 2K at a time mostly to be friendly for smaller
24749321fc3abc Boris Burkov 2021-06-24 243 * leaf size filesystems
24749321fc3abc Boris Burkov 2021-06-24 244 */
24749321fc3abc Boris Burkov 2021-06-24 245 copy_bytes = min_t(u64, len, 2048);
24749321fc3abc Boris Burkov 2021-06-24 246
24749321fc3abc Boris Burkov 2021-06-24 247 ret = btrfs_insert_empty_item(trans, root, path, &key, copy_bytes);
24749321fc3abc Boris Burkov 2021-06-24 248 if (ret) {
24749321fc3abc Boris Burkov 2021-06-24 249 btrfs_end_transaction(trans);
24749321fc3abc Boris Burkov 2021-06-24 250 break;
24749321fc3abc Boris Burkov 2021-06-24 251 }
24749321fc3abc Boris Burkov 2021-06-24 252
24749321fc3abc Boris Burkov 2021-06-24 253 leaf = path->nodes[0];
24749321fc3abc Boris Burkov 2021-06-24 254
24749321fc3abc Boris Burkov 2021-06-24 255 data = btrfs_item_ptr(leaf, path->slots[0], void);
24749321fc3abc Boris Burkov 2021-06-24 256 write_extent_buffer(leaf, src + src_offset,
24749321fc3abc Boris Burkov 2021-06-24 257 (unsigned long)data, copy_bytes);
24749321fc3abc Boris Burkov 2021-06-24 258 offset += copy_bytes;
24749321fc3abc Boris Burkov 2021-06-24 259 src_offset += copy_bytes;
24749321fc3abc Boris Burkov 2021-06-24 260 len -= copy_bytes;
24749321fc3abc Boris Burkov 2021-06-24 261 copied += copy_bytes;
24749321fc3abc Boris Burkov 2021-06-24 262
24749321fc3abc Boris Burkov 2021-06-24 263 btrfs_release_path(path);
24749321fc3abc Boris Burkov 2021-06-24 264 btrfs_end_transaction(trans);
24749321fc3abc Boris Burkov 2021-06-24 265 }
24749321fc3abc Boris Burkov 2021-06-24 266
24749321fc3abc Boris Burkov 2021-06-24 267 btrfs_free_path(path);24749321fc3abc Boris Burkov 2021-06-24 @268 return ret;24749321fc3abc Boris Burkov 2021-06-24 269 }24749321fc3abc Boris Burkov 2021-06-24 270
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Re: [PATCH v5 2/3] btrfs: initial fsverity support
Quoted 7 lines · Dan Carpenter
Hi Boris,
url: https://github.com/0day-ci/linux/commits/Boris-Burkov/btrfs-support-fsverity/20210625-064209 base: https://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git for-next config: parisc-randconfig-m031-20210625 (attached as .config) compiler: hppa-linux-gcc (GCC) 9.3.0
Quoted 7 lines
If you fix the issue, kindly add following tag as appropriate
Reported-by kernel test robot <[email protected]>Reported-by Dan Carpenter <[email protected]>New smatch warnings:
fs/btrfs/verity.c:268write_key_bytes()error: uninitialized symbol 'ret'.fs/btrfs/verity.c:745btrfs_write_merkle_tree_block()warn: should '1 <<log_blocksize' be a 64 bit type?
good catch :)
Quoted 3 lines
Old smatch warnings:
fs/btrfs/verity.c:552btrfs_begin_enable_verity()error: uninitialized symbol 'trans'.
This was a screw up from re-arranging the patches, will clean up.
Quoted 23 lines
vim +/ret +268
fs/btrfs/verity.c24749321fc3abc Boris Burkov 2021-06-24 209 static int write_key_bytes(struct btrfs_inode *inode, u8 key_type, u64 offset, 24749321fc3abc Boris Burkov 2021-06-24 210 const char *src, u64 len) 24749321fc3abc Boris Burkov 2021-06-24 211 { 24749321fc3abc Boris Burkov 2021-06-24 212 struct btrfs_trans_handle *trans; 24749321fc3abc Boris Burkov 2021-06-24 213 struct btrfs_path *path; 24749321fc3abc Boris Burkov 2021-06-24 214 struct btrfs_root *root = inode->root; 24749321fc3abc Boris Burkov 2021-06-24 215 struct extent_buffer *leaf; 24749321fc3abc Boris Burkov 2021-06-24 216 struct btrfs_key key; 24749321fc3abc Boris Burkov 2021-06-24 217 u64 copied = 0; 24749321fc3abc Boris Burkov 2021-06-24 218 unsigned long copy_bytes; 24749321fc3abc Boris Burkov 2021-06-24 219 unsigned long src_offset = 0; 24749321fc3abc Boris Burkov 2021-06-24 220 void *data; 24749321fc3abc Boris Burkov 2021-06-24 221 int ret; 24749321fc3abc Boris Burkov 2021-06-24 222 24749321fc3abc Boris Burkov 2021-06-24 223 path = btrfs_alloc_path(); 24749321fc3abc Boris Burkov 2021-06-24 224 if (!path) 24749321fc3abc Boris Burkov 2021-06-24 225 return -ENOMEM; 24749321fc3abc Boris Burkov 2021-06-24 226 24749321fc3abc Boris Burkov 2021-06-24 227 while (len > 0) {
Quoted 3 lines
Can we write zero bytes? My test system has linux-next so I don't know. I don't think the kbuild bot uses the cross function DB so it doesn't know either.
Considering the three callsites and then the callsite of end_enable_verity in fs/verity/enable.c, I don't think it's possible to call write_key_bytes with len==0, but it doesn't hurt to fix it anyway, just in case. It makes write_key_bytes more correct as documented, at least.
Quoted 48 lines
24749321fc3abc Boris Burkov 2021-06-24 228 /* 24749321fc3abc Boris Burkov 2021-06-24 229 * 1 for the new item being inserted 24749321fc3abc Boris Burkov 2021-06-24 230 */ 24749321fc3abc Boris Burkov 2021-06-24 231 trans = btrfs_start_transaction(root, 1); 24749321fc3abc Boris Burkov 2021-06-24 232 if (IS_ERR(trans)) { 24749321fc3abc Boris Burkov 2021-06-24 233 ret = PTR_ERR(trans); 24749321fc3abc Boris Burkov 2021-06-24 234 break; 24749321fc3abc Boris Burkov 2021-06-24 235 } 24749321fc3abc Boris Burkov 2021-06-24 236 24749321fc3abc Boris Burkov 2021-06-24 237 key.objectid = btrfs_ino(inode); 24749321fc3abc Boris Burkov 2021-06-24 238 key.type = key_type; 24749321fc3abc Boris Burkov 2021-06-24 239 key.offset = offset; 24749321fc3abc Boris Burkov 2021-06-24 240 24749321fc3abc Boris Burkov 2021-06-24 241 /* 24749321fc3abc Boris Burkov 2021-06-24 242 * Insert 2K at a time mostly to be friendly for smaller 24749321fc3abc Boris Burkov 2021-06-24 243 * leaf size filesystems 24749321fc3abc Boris Burkov 2021-06-24 244 */ 24749321fc3abc Boris Burkov 2021-06-24 245 copy_bytes = min_t(u64, len, 2048); 24749321fc3abc Boris Burkov 2021-06-24 246 24749321fc3abc Boris Burkov 2021-06-24 247 ret = btrfs_insert_empty_item(trans, root, path, &key, copy_bytes); 24749321fc3abc Boris Burkov 2021-06-24 248 if (ret) { 24749321fc3abc Boris Burkov 2021-06-24 249 btrfs_end_transaction(trans); 24749321fc3abc Boris Burkov 2021-06-24 250 break; 24749321fc3abc Boris Burkov 2021-06-24 251 } 24749321fc3abc Boris Burkov 2021-06-24 252 24749321fc3abc Boris Burkov 2021-06-24 253 leaf = path->nodes[0]; 24749321fc3abc Boris Burkov 2021-06-24 254 24749321fc3abc Boris Burkov 2021-06-24 255 data = btrfs_item_ptr(leaf, path->slots[0], void); 24749321fc3abc Boris Burkov 2021-06-24 256 write_extent_buffer(leaf, src + src_offset, 24749321fc3abc Boris Burkov 2021-06-24 257 (unsigned long)data, copy_bytes); 24749321fc3abc Boris Burkov 2021-06-24 258 offset += copy_bytes; 24749321fc3abc Boris Burkov 2021-06-24 259 src_offset += copy_bytes; 24749321fc3abc Boris Burkov 2021-06-24 260 len -= copy_bytes; 24749321fc3abc Boris Burkov 2021-06-24 261 copied += copy_bytes; 24749321fc3abc Boris Burkov 2021-06-24 262 24749321fc3abc Boris Burkov 2021-06-24 263 btrfs_release_path(path); 24749321fc3abc Boris Burkov 2021-06-24 264 btrfs_end_transaction(trans); 24749321fc3abc Boris Burkov 2021-06-24 265 } 24749321fc3abc Boris Burkov 2021-06-24 266 24749321fc3abc Boris Burkov 2021-06-24 267 btrfs_free_path(path);
24749321fc3abcBoris Burkov 2021-06-24 @268 return ret;24749321fc3abcBoris Burkov 2021-06-24 269 }---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
PATCH v5 3/3 btrfs: verity metadata orphan items
In reply to Boris BurkovWriting out the verity data is too large of an operation to do in a single transaction. If we are interrupted before we finish creating fsverity metadata for a file, or fail to clean up already created metadata after a failure, we could leak the verity items that we already committed.
To address this issue, we use the orphan mechanism. When we start enabling verity on a file, we also add an orphan item for that inode. When we are finished, we delete the orphan. However, if we are interrupted midway, the orphan will be present at mount and we can cleanup the half-formed verity state.
There is a possible race with a normal unlink operation: if unlink and verity run on the same file in parallel, it is possible for verity to succeed and delete the still legitimate orphan added by unlink. Then, if we are interrupted and mount in that state, we will never clean up the inode properly. This is also possible for a file created with O_TMPFILE. Check nlink==0 before deleting to avoid this race.
A final thing to note is that this is a resurrection of using orphans to signal an operation besides "delete this inode". The old case was to signal the need to do a truncate. That case still technically applies for mounting very old file systems, so we need to take some care to not clobber it. To that end, we just have to be careful that verity orphan cleanup is a no-op for non-verity files.
--- fs/btrfs/inode.c | 16 ++++++++-- fs/btrfs/verity.c | 80 ++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 89 insertions(+), 7 deletions(-)
fs/btrfs/inode.c +14 -2
@@ -3432,7 +3432,14 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)/* * If we have an inode with links, there are a couple of -* possibilities. Old kernels (before v3.12) used to create an +* possibilities: +* +* 1. We were halfway through creating fsverity metadata for the +* file. In that case, the orphan item represents incomplete +* fsverity metadata which must be cleaned up with +* btrfs_drop_verity_items and deleting the orphan item. + +* 2. Old kernels (before v3.12) used to create an * orphan item for truncate indicating that there were possibly * extent items past i_size that needed to be deleted. In v3.12, * truncate was changed to update i_size in sync with the extent
@@ -3449,9 +3456,14 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)* deleted but wasn't. The inode number may have been reused, * but either way, we can delete the orphan item. */ +if (ret == -ENOENT || inode->i_nlink) { -if (!ret) +if (!ret) { + ret =btrfs_drop_verity_items (BTRFS_I (inode));iput (inode); +if (ret) + goto out; + } trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) { ret =PTR_ERR (trans);
fs/btrfs/verity.c +75 -5
140 lines not on this page · raw message
Signature · 1 line
2.31.1