fs-verity support for XFS
Subsystems (10)
Hi everyone,
I've mostly finished rounding out xfs_db and both fsck support for fsverity. I'm now sending out a full set of patches for everything I've got, which is quite a bit more since the v5.2 stuff the other day.
This time around I've applied some more optimizations to the implementation, including getting rid of the incore validation bitmap, not storing trailing zeroes to reduce overhead, and eliding merkle tree blocks that contain hashes of zeroed data blocks. This last one is very useful for reducing overhead of gold master disk images on vm farms.
Note that metadump is kinda broken and xfs_scrub media scans do not yet know how to read verity files. All that is actually fixed in the version that's lodged in my development trees, but since Andrey's base is the 6.9 for-next branch plus only a few of the parent pointers patches, none of that stuff was easy to port to make a short dev branch.
Full versions are here:
https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux.git/log/?h=fsverity
https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=fsverity
--D
PATCH 1/1 fs-verity support for XFS
Hi all,
From Darrick J. Wong:
This v5.3 patchset builds upon v5.2 of Andrey's patchset to implement fsverity for XFS.
The biggest thing that I didn't like in the v5 patchset is the abuse of the data device's buffer cache to store the incore version of the merkle tree blocks. Not only do verity state flags end up in xfs_buf, but the double-alloc flag wastes memory and doesn't remain internally consistent if the xattrs shift around.
I replaced all of that with a per-inode xarray that indexes incore merkle tree blocks. For cache hits, this dramatically reduces the amount of work that xfs has to do to feed fsverity. The per-block overhead is much lower (8 bytes instead of ~300 for xfs_bufs), and we no longer have to entertain layering violations in the buffer cache. I also added a per-filesystem shrinker so that reclaim can cull cached merkle tree blocks, starting with the leaf tree nodes.
I've also rolled in some changes recommended by the fsverity maintainer, fixed some organization and naming problems in the xfs code, fixed a collision in the xfs_inode iflags, and improved dead merkle tree cleanup per the discussion of the v5 series. At this point I'm happy enough with this code to start integrating and testing it in my trees, so it's time to send it out a coherent patchset for comments.
For v5.3, I've added bits and pieces of online and offline repair support, reduced the size of partially filled merkle tree blocks by removing trailing zeroes, changed the xattr hash function to better avoid collisions between merkle tree keys, made the fsverity invalidation bitmap unnecessary, and made it so that we can save space on sparse verity files by not storing merkle tree blocks that hash totally zeroed data blocks.
From Andrey Albershteyn:
Here's v5 of my patchset of adding fs-verity support to XFS.
This implementation uses extended attributes to store fs-verity metadata. The Merkle tree blocks are stored in the remote extended attributes. The names are offsets into the tree.
A few key points of this patchset:
- fs-verity can work with Merkle tree blocks based caching (xfs) and PAGE caching (ext4, f2fs, btrfs)
- iomap does fs-verity verification
- In XFS, fs-verity metadata is stored in extended attributes
- per-sb workqueue for verification processing
- Inodes with fs-verity have new on-disk diflag
- xfs_attr_get() can return a buffer with an extended attribute
- xfs_buf can allocate double space for Merkle tree blocks. Part of the space is used to store the extended attribute data without leaf headers
- xfs_buf tracks verified status of merkle tree blocks
The patchset consists of five parts:
- [1]: fs-verity spinlock removal pending in fsverity/for-next
- [2..4]: Parent pointers adding binary xattr names
- [5]: Expose FS_XFLAG_VERITY for fs-verity files
- [6..9]: Changes to fs-verity core
- [10]: Integrate fs-verity to iomap
- [11-24]: Add fs-verity support to XFS
Testing:
The patchset is tested with xfstests -g verity on xfs_1k, xfs_4k, xfs_1k_quota, xfs_4k_quota, ext4_4k, and ext4_4k_quota. With KMEMLEAK and KASAN enabled. More testing on the way.
Changes from V4:
- Mainly fs-verity changes; removed unnecessary functions
- Replace XFS workqueue with per-sb workqueue created in fsverity_set_ops()
- Drop patch with readahead calculation in bytes
Changes from V3:
- redone changes to fs-verity core as previous version had an issue on ext4
- add blocks invalidation interface to fs-verity
- move memory ordering primitives out of block status check to fs read block function
- add fs-verity verification to iomap instead of general post read processing
Changes from V2:
- FS_XFLAG_VERITY extended attribute flag
- Change fs-verity to use Merkle tree blocks instead of expecting PAGE references from filesystem
- Change approach in iomap to filesystem provided bio_set and submit_io instead of just callouts to filesystem
- Add possibility for xfs_buf allocate more space for fs-verity extended attributes
- Make xfs_attr module to copy fs-verity blocks inside the xfs_buf, so XFS can get data without leaf headers
- Add Merkle tree removal for error path
- Makae scrub aware of new dinode flag
Changes from V1:
- Added parent pointer patches for easier testing
- Many issues and refactoring points fixed from the V1 review
- Adjusted for recent changes in fs-verity core (folios, non-4k)
- Dropped disabling of large folios
- Completely new fsverity patches (fix, callout, log_blocksize)
- Change approach to verification in iomap to the same one as in write path. Callouts to fs instead of direct fs-verity use.
- New XFS workqueue for post read folio verification
- xfs_attr_get() can return underlying xfs_buf
- xfs_bufs are marked with XBF_VERITY_CHECKED to track verified blocks
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
With a bit of luck, this should all go splendidly. Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=fsverity-xfs
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=fsverity-xfs
---
Commits in this patchset:
* fsverity: remove hash page spin lock
* xfs: add parent pointer support to attribute code
* xfs: define parent pointer ondisk extended attribute format
* xfs: add parent pointer validator functions
* fs: add FS_XFLAG_VERITY for verity files
* fsverity: pass tree_blocksize to end_enable_verity()
* fsverity: support block-based Merkle tree caching
* fsverity: add per-sb workqueue for post read processing
* fsverity: add tracepoints
* fsverity: fix "support block-based Merkle tree caching"
* fsverity: send the level of the merkle tree block to ->read_merkle_tree_block
* fsverity: pass the new tree size and block size to ->begin_enable_verity
* fsverity: expose merkle tree geometry to callers
* fsverity: rely on cached block callers to retain verified state
* fsverity: box up the write_merkle_tree_block parameters too
* fsverity: pass the zero-hash value to the implementation
* fsverity: report validation errors back to the filesystem
* iomap: integrate fs-verity verification into iomap's read path
* xfs: add attribute type for fs-verity
* xfs: add fs-verity ro-compat flag
* xfs: add inode on-disk VERITY flag
* xfs: initialize fs-verity on file open and cleanup on inode destruction
* xfs: don't allow to enable DAX on fs-verity sealed inode
* xfs: disable direct read path for fs-verity files
* xfs: widen flags argument to the xfs_iflags_* helpers
* xfs: add fs-verity support
* xfs: create a per-mount shrinker for verity inodes merkle tree blocks
* xfs: create an icache tag for files with cached merkle tree blocks
* xfs: shrink verity blob cache
* xfs: clean up stale fsverity metadata before starting
* xfs: better reporting and error handling in xfs_drop_merkle_tree
* xfs: make scrub aware of verity dinode flag
* xfs: add fs-verity ioctls
* xfs: advertise fs-verity being available on filesystem
* xfs: teach online repair to evaluate fsverity xattrs
* xfs: don't store trailing zeroes of merkle tree blocks
* xfs: create separate name hash function for xattrs
* xfs: use merkle tree offset as attr hash
* xfs: don't bother storing merkle tree blocks for zeroed data blocks
* xfs: enable ro-compat fs-verity flag
--- Documentation/filesystems/fsverity.rst | 8 MAINTAINERS | 1 fs/btrfs/verity.c | 13 - fs/ext4/verity.c | 13 - fs/f2fs/verity.c | 13 - fs/ioctl.c | 11 fs/iomap/buffered-io.c | 91 ++++ fs/super.c | 7 fs/verity/enable.c | 19 + fs/verity/fsverity_private.h | 42 ++ fs/verity/init.c | 1 fs/verity/open.c | 41 ++ fs/verity/read_metadata.c | 63 +-- fs/verity/signature.c | 2 fs/verity/verify.c | 233 +++++++--- fs/xfs/Makefile | 2 fs/xfs/libxfs/xfs_attr.c | 49 ++ fs/xfs/libxfs/xfs_attr.h | 6 fs/xfs/libxfs/xfs_attr_leaf.c | 4 fs/xfs/libxfs/xfs_da_format.h | 75 +++ fs/xfs/libxfs/xfs_format.h | 14 - fs/xfs/libxfs/xfs_fs.h | 1 fs/xfs/libxfs/xfs_log_format.h | 2 fs/xfs/libxfs/xfs_ondisk.h | 4 fs/xfs/libxfs/xfs_parent.c | 113 +++++ fs/xfs/libxfs/xfs_parent.h | 19 + fs/xfs/libxfs/xfs_sb.c | 4 fs/xfs/scrub/attr.c | 114 +++++ fs/xfs/scrub/attr.h | 4 fs/xfs/scrub/common.c | 27 + fs/xfs/xfs_attr_item.c | 9 fs/xfs/xfs_attr_list.c | 17 - fs/xfs/xfs_file.c | 23 + fs/xfs/xfs_icache.c | 85 ++++ fs/xfs/xfs_icache.h | 8 fs/xfs/xfs_inode.c | 2 fs/xfs/xfs_inode.h | 19 + fs/xfs/xfs_ioctl.c | 21 + fs/xfs/xfs_iops.c | 4 fs/xfs/xfs_mount.c | 10 fs/xfs/xfs_mount.h | 8 fs/xfs/xfs_super.c | 14 + fs/xfs/xfs_trace.h | 80 +++ fs/xfs/xfs_verity.c | 741 ++++++++++++++++++++++++++++++++ fs/xfs/xfs_verity.h | 29 + fs/xfs/xfs_xattr.c | 10 include/linux/fs.h | 2 include/linux/fsverity.h | 162 +++++++ include/trace/events/fsverity.h | 162 +++++++ include/uapi/linux/fs.h | 1 50 files changed, 2226 insertions(+), 177 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_parent.c create mode 100644 fs/xfs/libxfs/xfs_parent.h create mode 100644 fs/xfs/xfs_verity.c create mode 100644 fs/xfs/xfs_verity.h create mode 100644 include/trace/events/fsverity.h
PATCH 1/40 fsverity: remove hash page spin lock
From: Andrey Albershteyn <[email protected]>
The spin lock is not necessary here as it can be replaced with memory barrier which should be better performance-wise.
When Merkle tree block size differs from page size, in is_hash_block_verified() two things are modified during check - a bitmap and PG_checked flag of the page.
Each bit in the bitmap represent verification status of the Merkle tree blocks. PG_checked flag tells if page was just re-instantiated or was in pagecache. Both of this states are shared between verification threads. Page which was re-instantiated can not have already verified blocks (bit set in bitmap).
The spin lock was used to allow only one thread to modify both of these states and keep order of operations. The only requirement here is that PG_Checked is set strictly after bitmap is updated. This way other threads which see that PG_Checked=1 (page cached) knows that bitmap is up-to-date. Otherwise, if PG_Checked is set before bitmap is cleared, other threads can see bit=1 and therefore will not perform verification of that Merkle tree block.
However, there's still the case when one thread is setting a bit in verify_data_block() and other thread is clearing it in is_hash_block_verified(). This can happen if two threads get to !PageChecked branch and one of the threads is rescheduled before resetting the bitmap. This is fine as at worst blocks are re-verified in each thread.
--- fs/verity/fsverity_private.h | 1 - fs/verity/open.c | 1 - fs/verity/verify.c | 48 +++++++++++++++++++++--------------------- 3 files changed, 24 insertions(+), 26 deletions(-)
fs/verity/fsverity_private.h +0 -1
@@ -69,7 +69,6 @@ struct fsverity_info {u8 file_digest[FS_VERITY_MAX_DIGEST_SIZE ];const struct inode *inode;unsigned long *hash_block_verified; -spinlock_t hash_page_init_lock; };#define FS_VERITY_MAX_SIGNATURE_SIZE (FS_VERITY_MAX_DESCRIPTOR_SIZE - \
fs/verity/open.c +0 -1
@@ -239,7 +239,6 @@ struct fsverity_info *fsverity_create_info(const struct inode *inode, err = -ENOMEM ; goto fail; } -spin_lock_init (&vi->hash_page_init_lock); }return vi;
fs/verity/verify.c +24 -24
67 lines not on this page · raw message
PATCH 2/40 xfs: add parent pointer support to attribute code
In reply to Darrick J. WongFrom: Allison Henderson <[email protected]>
Add the new parent attribute type. XFS_ATTR_PARENT is used only for parent pointer entries; it uses reserved blocks like XFS_ATTR_ROOT.
--- fs/xfs/libxfs/xfs_attr.c | 3 ++- fs/xfs/libxfs/xfs_da_format.h | 5 ++++- fs/xfs/libxfs/xfs_log_format.h | 1 + fs/xfs/scrub/attr.c | 2 +- fs/xfs/xfs_trace.h | 3 ++- 5 files changed, 10 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_attr.c +2 -1
@@ -925,7 +925,8 @@ xfs_attr_set(struct xfs_inode *dp = args->dp;struct xfs_mount *mp = dp->i_mount;struct xfs_trans_res tres; -bool rsvd = (args->attr_filter &XFS_ATTR_ROOT ); +bool rsvd = (args->attr_filter & (XFS_ATTR_ROOT | +XFS_ATTR_PARENT ));int error, local;int rmt_blks =0 ;unsigned int total;
fs/xfs/libxfs/xfs_da_format.h +4 -1
@@ -714,12 +714,15 @@ struct xfs_attr3_leafblock {#define XFS_ATTR_LOCAL_BIT 0/* attr is stored locally */ #define XFS_ATTR_ROOT_BIT 1/* limit access to trusted attrs */ #define XFS_ATTR_SECURE_BIT 2/* limit access to secure attrs */ +#define XFS_ATTR_PARENT_BIT 3/* parent pointer attrs */ #define XFS_ATTR_INCOMPLETE_BIT 7/* attr in middle of create/delete */ #define XFS_ATTR_LOCAL (1u << XFS_ATTR_LOCAL_BIT)#define XFS_ATTR_ROOT (1u << XFS_ATTR_ROOT_BIT)#define XFS_ATTR_SECURE (1u << XFS_ATTR_SECURE_BIT) +#define XFS_ATTR_PARENT (1u << XFS_ATTR_PARENT_BIT)#define XFS_ATTR_INCOMPLETE (1u << XFS_ATTR_INCOMPLETE_BIT) -#define XFS_ATTR_NSP_ONDISK_MASK (XFS_ATTR_ROOT | XFS_ATTR_SECURE) +#define XFS_ATTR_NSP_ONDISK_MASK \ + (XFS_ATTR_ROOT | XFS_ATTR_SECURE | XFS_ATTR_PARENT)/* * Alignment for namelist and valuelist entries (since they are mixed
fs/xfs/libxfs/xfs_log_format.h +1 -0
@@ -974,6 +974,7 @@ struct xfs_icreate_log {*/ #define XFS_ATTRI_FILTER_MASK (XFS_ATTR_ROOT | \ XFS_ATTR_SECURE | \ + XFS_ATTR_PARENT | \ XFS_ATTR_INCOMPLETE)/*
fs/xfs/scrub/attr.c +1 -1
@@ -494,7 +494,7 @@ xchk_xattr_rec(/* Retrieve the entry and check it. */ hash =be32_to_cpu (ent->hashval); badflags = ~(XFS_ATTR_LOCAL |XFS_ATTR_ROOT |XFS_ATTR_SECURE | -XFS_ATTR_INCOMPLETE ); +XFS_ATTR_INCOMPLETE |XFS_ATTR_PARENT );if ((ent->flags & badflags) !=0 )xchk_da_set_corrupt (ds, level);if (ent->flags &XFS_ATTR_LOCAL ) {
fs/xfs/xfs_trace.h +2 -1
@@ -86,7 +86,8 @@ struct xfs_bmap_intent;#define XFS_ATTR_FILTER_FLAGS \ { XFS_ATTR_ROOT, "ROOT" }, \ { XFS_ATTR_SECURE, "SECURE" }, \ - { XFS_ATTR_INCOMPLETE, "INCOMPLETE" } + { XFS_ATTR_INCOMPLETE, "INCOMPLETE" }, \ + { XFS_ATTR_PARENT, "PARENT" } DECLARE_EVENT_CLASS(xfs_attr_list_class, TP_PROTO(struct xfs_attr_list_context *ctx),
PATCH 3/40 xfs: define parent pointer ondisk extended attribute format
In reply to Darrick J. WongFrom: Allison Henderson <[email protected]>
We need to define the parent pointer attribute format before we start adding support for it into all the code that needs to use it. The EA format we will use encodes the following information:
name={parent inode #, parent inode generation, dirent namehash}
value={dirent name}The inode/gen gives all the information we need to reliably identify the parent without requiring child->parent lock ordering, and allows userspace to do pathname component level reconstruction without the kernel ever needing to verify the parent itself as part of ioctl calls. Storing the dirent name hash in the key reduces hash collisions if a file is hardlinked multiple times in the same directory.
By using the NVLOOKUP mode in the extended attribute code to match parent pointers using both the xattr name and value, we can identify the exact parent pointer EA we need to modify/remove in rename/unlink operations without searching the entire EA space.
By storing the dirent name, we have enough information to be able to validate and reconstruct damaged directory trees. Earlier iterations of this patchset encoded the directory offset in the parent pointer key, but this format required repair to keep that in sync across directory rebuilds, which is unnecessary complexity.
--- fs/xfs/libxfs/xfs_da_format.h | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+)
fs/xfs/libxfs/xfs_da_format.h +20 -0
@@ -878,4 +878,24 @@ static inline unsigned int xfs_dir2_dirblock_bytes(struct xfs_sb *sbp)xfs_failaddr_t xfs_da3_blkinfo_verify (struct xfs_buf *bp,struct xfs_da3_blkinfo *hdr3); +/* +* Parent pointer attribute format definition +* +* The xattr name encodes the parent inode number, generation and the crc32c +* hash of the dirent name. +* +* The xattr value contains the dirent name. +*/ +struct xfs_parent_name_rec { +__be64 p_ino; +__be32 p_gen; +__be32 p_namehash; +}; + +/* +* Maximum size of the dirent name that can be stored in a parent pointer. +* This matches the maximum dirent name length. +*/ +#define XFS_PARENT_DIRENT_NAME_MAX_SIZE (MAXNAMELEN - 1) +#endif /* __XFS_DA_FORMAT_H__ */
PATCH 4/40 xfs: add parent pointer validator functions
In reply to Darrick J. WongFrom: Allison Henderson <[email protected]>
Attribute names of parent pointers are not strings. So we need to modify attr_namecheck to verify parent pointer records when the XFS_ATTR_PARENT flag is set. At the same time, we need to validate attr values during log recovery if the xattr is really a parent pointer.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_attr.c | 10 +++- fs/xfs/libxfs/xfs_attr.h | 3 + fs/xfs/libxfs/xfs_da_format.h | 8 +++ fs/xfs/libxfs/xfs_parent.c | 113 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_parent.h | 19 +++++++ fs/xfs/scrub/attr.c | 2 - fs/xfs/xfs_attr_item.c | 6 +- fs/xfs/xfs_attr_list.c | 14 +++-- 9 files changed, 165 insertions(+), 11 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_parent.c create mode 100644 fs/xfs/libxfs/xfs_parent.h
fs/xfs/Makefile +1 -0
@@ -41,6 +41,7 @@ xfs-y += $(addprefix libxfs/, \ xfs_inode_buf.o \ xfs_log_rlimit.o \ xfs_ag_resv.o \ + xfs_parent.o \ xfs_rmap.o \ xfs_rmap_btree.o \ xfs_refcount.o \
fs/xfs/libxfs/xfs_attr.c +8 -2
@@ -26,6 +26,7 @@#include "xfs_trace.h" #include "xfs_attr_item.h" #include "xfs_xattr.h" +#include "xfs_parent.h" struct kmem_cache *xfs_attr_intent_cache;
@@ -1515,9 +1516,14 @@ xfs_attr_node_get(/* Returns true if the attribute entry name is valid. */ bool xfs_attr_namecheck ( -const void *name, -size_t length) +struct xfs_mount *mp, +const void *name, +size_t length, +unsigned int flags) { +if (flags &XFS_ATTR_PARENT ) +return xfs_parent_namecheck (mp, name, length, flags); +/* * MAXNAMELEN includes the trailing null, but (name/length) leave it * out, so use >= for the length check.
fs/xfs/libxfs/xfs_attr.h +2 -1
@@ -547,7 +547,8 @@ int xfs_attr_get(struct xfs_da_args *args);int xfs_attr_set (struct xfs_da_args *args);int xfs_attr_set_iter (struct xfs_attr_intent *attr);int xfs_attr_remove_iter (struct xfs_attr_intent *attr); -bool xfs_attr_namecheck (const void *name,size_t length); +bool xfs_attr_namecheck (struct xfs_mount *mp,const void *name,size_t length, +unsigned int flags);int xfs_attr_calc_size (struct xfs_da_args *args,int *local);void xfs_init_attr_trans (struct xfs_da_args *args,struct xfs_trans_res *tres,unsigned int *total);
fs/xfs/libxfs/xfs_da_format.h +8 -0
@@ -757,6 +757,14 @@ xfs_attr3_leaf_name(xfs_attr_leafblock_t *leafp, int idx)return &((char *)leafp)[be16_to_cpu (entries[idx].nameidx)]; } +static inline int +xfs_attr3_leaf_flags (xfs_attr_leafblock_t *leafp,int idx) +{ +struct xfs_attr_leaf_entry *entries =xfs_attr3_leaf_entryp (leafp); + +return entries[idx].flags; +} +static inline xfs_attr_leaf_name_remote_t *xfs_attr3_leaf_name_remote (xfs_attr_leafblock_t *leafp,int idx) {
fs/xfs/libxfs/xfs_parent.c new file +113 -0
113 lines not on this page · raw message
fs/xfs/libxfs/xfs_parent.h new file +19 -0
@@ -0,0 +1,19 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (c) 2022-2024 Oracle. +* All Rights Reserved. +*/ +#ifndef __XFS_PARENT_H__ +#define __XFS_PARENT_H__ + +/* Metadata validators */ +bool xfs_parent_namecheck (struct xfs_mount *mp, +const struct xfs_parent_name_rec *rec,size_t reclen, +unsigned int attr_flags); +bool xfs_parent_valuecheck (struct xfs_mount *mp,const void *value, +size_t valuelen); +bool xfs_parent_hashcheck (struct xfs_mount *mp, +const struct xfs_parent_name_rec *rec,const void *value, +size_t valuelen); + +#endif /* __XFS_PARENT_H__ */
fs/xfs/scrub/attr.c +1 -1
@@ -195,7 +195,7 @@ xchk_xattr_listent( }/* Does this name make sense? */ -if (!xfs_attr_namecheck (name, namelen)) { +if (!xfs_attr_namecheck (sx->sc->mp, name, namelen, flags)) {xchk_fblock_set_corrupt (sx->sc,XFS_ATTR_FORK , args.blkno); goto fail_xref; }
fs/xfs/xfs_attr_item.c +4 -2
@@ -591,7 +591,8 @@ xfs_attr_recover_work(*/ attrp = &attrip->attri_format;if (!xfs_attri_validate (mp, attrp) || - !xfs_attr_namecheck (nv->name.i_addr, nv->name.i_len)) + !xfs_attr_namecheck (mp, nv->name.i_addr, nv->name.i_len, + attrp->alfi_attr_filter))return -EFSCORRUPTED ; attr =xfs_attri_recover_work (mp, dfp, attrp, &ip, nv);
@@ -731,7 +732,8 @@ xlog_recover_attri_commit_pass2(return -EFSCORRUPTED ; } -if (!xfs_attr_namecheck (attr_name, attri_formatp->alfi_name_len)) { +if (!xfs_attr_namecheck (mp, attr_name, attri_formatp->alfi_name_len, + attri_formatp->alfi_attr_filter)) {XFS_CORRUPTION_ERROR (__func__,XFS_ERRLEVEL_LOW , mp, item->ri_buf[1 ].i_addr, item->ri_buf[1 ].i_len);return -EFSCORRUPTED ;
fs/xfs/xfs_attr_list.c +9 -5
@@ -59,6 +59,7 @@ xfs_attr_shortform_list(struct xfs_attr_sf_sort *sbuf, *sbp;struct xfs_attr_sf_hdr *sf = dp->i_af.if_data;struct xfs_attr_sf_entry *sfe; +struct xfs_mount *mp = dp->i_mount;int sbsize, nsbuf, count, i;int error =0 ;
@@ -82,8 +83,9 @@ xfs_attr_shortform_list( (dp->i_af.if_bytes + sf->count * 16) < context->bufsize)) {for (i =0 , sfe =xfs_attr_sf_firstentry (sf); i < sf->count; i++) {if (XFS_IS_CORRUPT (context->dp->i_mount, - !xfs_attr_namecheck (sfe->nameval, - sfe->namelen))) { + !xfs_attr_namecheck (mp, sfe->nameval, + sfe->namelen, + sfe->flags))) {xfs_dirattr_mark_sick (context->dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; }
@@ -177,8 +179,9 @@ xfs_attr_shortform_list( cursor->offset =0 ; }if (XFS_IS_CORRUPT (context->dp->i_mount, - !xfs_attr_namecheck (sbp->name, - sbp->namelen))) { + !xfs_attr_namecheck (mp, sbp->name, + sbp->namelen, + sbp->flags))) {xfs_dirattr_mark_sick (context->dp,XFS_ATTR_FORK ); error = -EFSCORRUPTED ; goto out;
@@ -474,7 +477,8 @@ xfs_attr3_leaf_list_int( }if (XFS_IS_CORRUPT (context->dp->i_mount, - !xfs_attr_namecheck (name, namelen))) { + !xfs_attr_namecheck (mp, name, namelen, + entry->flags))) {xfs_dirattr_mark_sick (context->dp,XFS_ATTR_FORK );return -EFSCORRUPTED ; }
PATCH 5/40 fs: add FS_XFLAG_VERITY for verity files
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Add extended attribute FS_XFLAG_VERITY for inodes with fs-verity enabled.
--- Documentation/filesystems/fsverity.rst | 8 ++++++++ fs/ioctl.c | 11 +++++++++++ include/uapi/linux/fs.h | 1 + 3 files changed, 20 insertions(+)
Documentation/filesystems/fsverity.rst +8 -0
@@ -326,6 +326,14 @@ the file has fs-verity enabled. This can perform better than FS_IOC_GETFLAGS and FS_IOC_MEASURE_VERITY because it doesn't require opening the file, and opening verity files can be expensive. +FS_IOC_FSGETXATTR +----------------- + +Since Linux v6.9, the FS_IOC_FSGETXATTR ioctl sets FS_XFLAG_VERITY (0x00020000) +in the returned flags when the file has verity enabled. Note that this attribute +cannot be set with FS_IOC_FSSETXATTR as enabling verity requires input +parameters. See FS_IOC_ENABLE_VERITY. + .. _accessing_verity_files: Accessing verity files
fs/ioctl.c +11 -0
@@ -481,6 +481,8 @@ void fileattr_fill_xflags(struct fileattr *fa, u32 xflags) fa->flags |=FS_DAX_FL ;if (fa->fsx_xflags &FS_XFLAG_PROJINHERIT ) fa->flags |=FS_PROJINHERIT_FL ; +if (fa->fsx_xflags &FS_XFLAG_VERITY ) + fa->flags |=FS_VERITY_FL ; }EXPORT_SYMBOL (fileattr_fill_xflags);
@@ -511,6 +513,8 @@ void fileattr_fill_flags(struct fileattr *fa, u32 flags) fa->fsx_xflags |=FS_XFLAG_DAX ;if (fa->flags &FS_PROJINHERIT_FL ) fa->fsx_xflags |=FS_XFLAG_PROJINHERIT ; +if (fa->flags &FS_VERITY_FL ) + fa->fsx_xflags |=FS_XFLAG_VERITY ; }EXPORT_SYMBOL (fileattr_fill_flags);
@@ -641,6 +645,13 @@ static int fileattr_set_prepare(struct inode *inode, !(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))return -EINVAL ; +/* +* Verity cannot be changed through FS_IOC_FSSETXATTR/FS_IOC_SETFLAGS. +* See FS_IOC_ENABLE_VERITY. +*/ +if ((fa->fsx_xflags ^ old_ma->fsx_xflags) &FS_XFLAG_VERITY ) +return -EINVAL ; +/* Extent size hints of zero turn off the flags. */ if (fa->fsx_extsize ==0 ) fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE |FS_XFLAG_EXTSZINHERIT );
include/uapi/linux/fs.h +1 -0
@@ -140,6 +140,7 @@ struct fsxattr {#define FS_XFLAG_FILESTREAM 0x00004000/* use filestream allocator */ #define FS_XFLAG_DAX 0x00008000/* use DAX for IO */ #define FS_XFLAG_COWEXTSIZE 0x00010000/* CoW extent size allocator hint */ +#define FS_XFLAG_VERITY 0x00020000/* fs-verity enabled */ #define FS_XFLAG_HASATTR 0x80000000/* no DIFLAG for this */ /* the read-only stuff doesn't really belong here, but any other place is
PATCH 6/40 fsverity: pass tree_blocksize to end_enable_verity()
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
XFS will need to know tree_blocksize to remove the tree in case of an error. The size is needed to calculate offsets of particular Merkle tree blocks.
--- fs/btrfs/verity.c | 4 +++- fs/ext4/verity.c | 3 ++- fs/f2fs/verity.c | 3 ++- fs/verity/enable.c | 6 ++++-- include/linux/fsverity.h | 4 +++- 5 files changed, 14 insertions(+), 6 deletions(-)
fs/btrfs/verity.c +3 -1
@@ -621,6 +621,7 @@ static int btrfs_begin_enable_verity(struct file *filp)* @desc: verity descriptor to write out (NULL in error conditions) * @desc_size: size of the verity descriptor (variable with signatures) * @merkle_tree_size: size of the merkle tree in bytes +* @tree_blocksize: the Merkle tree block size * * If desc is null, then VFS is signaling an error occurred during verity * enable, and we should try to rollback. Otherwise, attempt to finish verity.
@@ -628,7 +629,8 @@ static int btrfs_begin_enable_verity(struct file *filp)* Returns 0 on success, negative error code on error. */ static int btrfs_end_enable_verity (struct file *filp,const void *desc, -size_t desc_size,u64 merkle_tree_size) +size_t desc_size,u64 merkle_tree_size, +unsigned int tree_blocksize) {struct btrfs_inode *inode =BTRFS_I (file_inode (filp));int ret =0 ;
fs/ext4/verity.c +2 -1
@@ -189,7 +189,8 @@ static int ext4_write_verity_descriptor(struct inode *inode, const void *desc, }static int ext4_end_enable_verity (struct file *filp,const void *desc, -size_t desc_size,u64 merkle_tree_size) +size_t desc_size,u64 merkle_tree_size, +unsigned int tree_blocksize) {struct inode *inode =file_inode (filp);const int credits =2 ;/* superblock and inode for ext4_orphan_del() */
fs/f2fs/verity.c +2 -1
@@ -144,7 +144,8 @@ static int f2fs_begin_enable_verity(struct file *filp) }static int f2fs_end_enable_verity (struct file *filp,const void *desc, -size_t desc_size,u64 merkle_tree_size) +size_t desc_size,u64 merkle_tree_size, +unsigned int tree_blocksize) {struct inode *inode =file_inode (filp);struct f2fs_sb_info *sbi =F2FS_I_SB (inode);
fs/verity/enable.c +4 -2
@@ -274,7 +274,8 @@ static int enable_verity(struct file *filp,* Serialized with ->begin_enable_verity() by the inode lock. */ inode_lock (inode); - err = vops->end_enable_verity (filp, desc, desc_size, params.tree_size); + err = vops->end_enable_verity (filp, desc, desc_size, params.tree_size, + params.block_size);inode_unlock (inode);if (err) { fsverity_err(inode, "%ps() failed with err %d",
@@ -300,7 +301,8 @@ static int enable_verity(struct file *filp, rollback:inode_lock (inode); - (void )vops->end_enable_verity (filp,NULL ,0 , params.tree_size); + (void )vops->end_enable_verity (filp,NULL ,0 , params.tree_size, + params.block_size);inode_unlock (inode); goto out; }
include/linux/fsverity.h +3 -1
@@ -51,6 +51,7 @@ struct fsverity_operations {* @desc: the verity descriptor to write, or NULL on failure * @desc_size: size of verity descriptor, or 0 on failure * @merkle_tree_size: total bytes the Merkle tree took up +* @tree_blocksize: the Merkle tree block size * * If desc == NULL, then enabling verity failed and the filesystem only * must do any necessary cleanups. Else, it must also store the given
@@ -65,7 +66,8 @@ struct fsverity_operations {* Return: 0 on success, -errno on failure */ int (*end_enable_verity)(struct file *filp,const void *desc, -size_t desc_size,u64 merkle_tree_size); +size_t desc_size,u64 merkle_tree_size, +unsigned int tree_blocksize);/** * Get the verity descriptor of the given inode.
PATCH 7/40 fsverity: support block-based Merkle tree caching
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
In the current implementation fs-verity expects filesystem to provide PAGEs filled with Merkle tree blocks. Then, when fs-verity is done with processing the blocks, reference to PAGE is freed. This doesn't fit well with the way XFS manages its memory.
To allow XFS integrate fs-verity this patch adds ability to fs-verity verification code to take Merkle tree blocks instead of PAGE reference. This way ext4, f2fs, and btrfs are still able to pass PAGE references and XFS can pass reference to Merkle tree blocks stored in XFS's buffer infrastructure.
Another addition is invalidation function which tells fs-verity to mark part of Merkle tree as not verified. This function is used by filesystem to tell fs-verity to invalidate block which was evicted from memory.
Depending on Merkle tree block size fs-verity is using either bitmap or PG_checked flag to track "verified" status of the blocks. With a Merkle tree block caching (XFS) there is no PAGE to flag it as verified. fs-verity always uses bitmap to track verified blocks for filesystems which use block caching.
Further this patch allows filesystem to make additional processing on verified pages via fsverity_drop_block() instead of just dropping a reference. This will be used by XFS for internal buffer cache manipulation in further patches. The btrfs, ext4, and f2fs just drop the reference.
--- fs/verity/fsverity_private.h | 8 +++ fs/verity/open.c | 8 ++- fs/verity/read_metadata.c | 64 ++++++++++++++-------- fs/verity/verify.c | 125 ++++++++++++++++++++++++++++++++---------- include/linux/fsverity.h | 65 ++++++++++++++++++++++ 5 files changed, 217 insertions(+), 53 deletions(-)
fs/verity/fsverity_private.h +8 -0
@@ -154,4 +154,12 @@ static inline void fsverity_init_signature(void)void __init fsverity_init_workqueue (void ); +/* +* Drop 'block' obtained with ->read_merkle_tree_block(). Calls out back to +* filesystem if ->drop_block() is set, otherwise, drop the reference in the +* block->context. +*/ +void fsverity_drop_block (struct inode *inode, +struct fsverity_blockbuf *block); +#endif /* _FSVERITY_PRIVATE_H */
fs/verity/open.c +7 -1
@@ -213,7 +213,13 @@ struct fsverity_info *fsverity_create_info(const struct inode *inode,if (err) goto fail; -if (vi->tree_params.block_size !=PAGE_SIZE ) { +/* +* If fs passes Merkle tree blocks to fs-verity (e.g. XFS), then +* fs-verity should use hash_block_verified bitmap as there's no page +* to mark it with PG_checked. +*/ +if (vi->tree_params.block_size !=PAGE_SIZE || + inode->i_sb->s_vop->read_merkle_tree_block) {/* * When the Merkle tree block size and page size differ, we use * a bitmap to keep track of which hash blocks have been
fs/verity/read_metadata.c +41 -23
98 lines not on this page · raw message
fs/verity/verify.c +96 -29
201 lines not on this page · raw message
include/linux/fsverity.h +65 -0
89 lines not on this page · raw message
PATCH 8/40 fsverity: add per-sb workqueue for post read processing
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
For XFS, fsverity's global workqueue is not really suitable due to:
1. High priority workqueues are used within XFS to ensure that data IO completion cannot stall processing of journal IO completions. Hence using a WQ_HIGHPRI workqueue directly in the user data IO path is a potential filesystem livelock/deadlock vector.
2. The fsverity workqueue is global - it creates a cross-filesystem contention point.
This patch adds per-filesystem, per-cpu workqueue for fsverity work. This allows iomap to add verification work in the read path on BIO completion.
--- fs/super.c | 7 +++++++ include/linux/fs.h | 2 ++ include/linux/fsverity.h | 22 ++++++++++++++++++++++ 3 files changed, 31 insertions(+)
fs/super.c +7 -0
@@ -642,6 +642,13 @@ void generic_shutdown_super(struct super_block *sb) sb->s_dio_done_wq =NULL ; } +#ifdef CONFIG_FS_VERITY +if (sb->s_read_done_wq) { +destroy_workqueue (sb->s_read_done_wq); + sb->s_read_done_wq =NULL ; + } +#endif +if (sop->put_super) sop->put_super (sb);
include/linux/fs.h +2 -0
@@ -1221,6 +1221,8 @@ struct super_block {#endif #ifdef CONFIG_FS_VERITY const struct fsverity_operations *s_vop; +/* Completion queue for post read verification */ +struct workqueue_struct *s_read_done_wq;#endif #if IS_ENABLED (CONFIG_UNICODE )struct unicode_map *s_encoding;
include/linux/fsverity.h +22 -0
@@ -241,6 +241,22 @@ void fsverity_enqueue_verify_work(struct work_struct *work);void fsverity_invalidate_block (struct inode *inode,struct fsverity_blockbuf *block); +static inline int fsverity_set_ops (struct super_block *sb, +const struct fsverity_operations *ops) +{ + sb->s_vop = ops; + +/* Create per-sb workqueue for post read bio verification */ +struct workqueue_struct *wq =alloc_workqueue ( +"pread/%s" , (WQ_FREEZABLE |WQ_MEM_RECLAIM ),0 , sb->s_id); +if (!wq) +return -ENOMEM ; + + sb->s_read_done_wq = wq; + +return 0 ; +} +#else /* !CONFIG_FS_VERITY */ static inline struct fsverity_info *fsverity_get_info (const struct inode *inode)
@@ -318,6 +334,12 @@ static inline void fsverity_enqueue_verify_work(struct work_struct *work) WARN_ON_ONCE(1); } +static inline int fsverity_set_ops (struct super_block *sb, +const struct fsverity_operations *ops) +{ +return -EOPNOTSUPP ; +} +#endif /* !CONFIG_FS_VERITY */ static inline bool fsverity_verify_folio (struct folio *folio)
PATCH 9/40 fsverity: add tracepoints
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
fs-verity previously had debug printk but it was removed. This patch adds trace points to the same places where printk were used (with a few additional ones).
--- MAINTAINERS | 1 fs/verity/enable.c | 3 + fs/verity/fsverity_private.h | 2 fs/verity/init.c | 1 fs/verity/signature.c | 2 fs/verity/verify.c | 7 ++ include/trace/events/fsverity.h | 181 +++++++++++++++++++++++++++++++++++++++ 7 files changed, 197 insertions(+) create mode 100644 include/trace/events/fsverity.h
MAINTAINERS +1 -0
@@ -8740,6 +8740,7 @@ T: git https://git.kernel.org/pub/scm/fs/fsverity/linux.git F: Documentation/filesystems/fsverity.rst F: fs/verity/ F: include/linux/fsverity.h +F: include/trace/events/fsverity.h F: include/uapi/linux/fsverity.h FT260 FTDI USB-HID TO I2C BRIDGE DRIVER
fs/verity/enable.c +3 -0
@@ -227,6 +227,8 @@ static int enable_verity(struct file *filp,if (err) goto out; +trace_fsverity_enable (inode, desc, ¶ms); +/* * Start enabling verity on this file, serialized by the inode lock. * Fail if verity is already enabled or is already being enabled.
@@ -255,6 +257,7 @@ static int enable_verity(struct file *filp,fsverity_err (inode,"Error %d building Merkle tree" , err); goto rollback; } +trace_fsverity_tree_done (inode, desc, ¶ms);/* * Create the fsverity_info. Don't bother trying to save work by
fs/verity/fsverity_private.h +2 -0
@@ -162,4 +162,6 @@ void __init fsverity_init_workqueue(void);void fsverity_drop_block (struct inode *inode,struct fsverity_blockbuf *block); +#include <trace/events/fsverity.h> +#endif /* _FSVERITY_PRIVATE_H */
fs/verity/init.c +1 -0
@@ -5,6 +5,7 @@* Copyright 2019 Google LLC */ +#define CREATE_TRACE_POINTS #include "fsverity_private.h" #include <linux/ratelimit.h>
fs/verity/signature.c +2 -0
@@ -53,6 +53,8 @@ int fsverity_verify_signature(const struct fsverity_info *vi,struct fsverity_formatted_digest *d;int err; +trace_fsverity_verify_signature (inode, signature, sig_size); +if (sig_size ==0 ) {if (fsverity_require_signatures) { fsverity_err(inode,
fs/verity/verify.c +7 -0
@@ -118,6 +118,7 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,/* Byte offset of the wanted hash relative to @addr */ unsigned int hoffset; } hblocks[FS_VERITY_MAX_LEVELS ]; +trace_fsverity_verify_block (inode, data_pos);/* * The index of the previous level's block within that level; also the * index of that block's hash within the current level.
@@ -215,6 +216,8 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,if (is_hash_block_verified (inode, block, hblock_idx)) {memcpy (_want_hash, block->kaddr + hoffset, hsize); want_hash = _want_hash; +trace_fsverity_merkle_tree_block_verified (inode, + block,FSVERITY_TRACE_DIR_ASCEND );fsverity_drop_block (inode, block); goto descend; }
@@ -248,6 +251,8 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,SetPageChecked (hpage);memcpy (_want_hash, haddr + hoffset, hsize); want_hash = _want_hash; +trace_fsverity_merkle_tree_block_verified (inode, block, +FSVERITY_TRACE_DIR_DESCEND );fsverity_drop_block (inode, block); }
@@ -405,6 +410,8 @@ void fsverity_invalidate_block(struct inode *inode,struct fsverity_info *vi = inode->i_verity_info;const unsigned int log_blocksize = vi->tree_params.log_blocksize; +trace_fsverity_invalidate_block (inode, block); +if (block->offset > vi->tree_params.tree_size) { fsverity_err(inode, "Trying to invalidate beyond Merkle tree (tree %lld, offset %lld)",
include/trace/events/fsverity.h new file +181 -0
181 lines not on this page · raw message
PATCH 10/40 fsverity: fix "support block-based Merkle tree caching"
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Various fixes recommended by the maintainer.
--- fs/verity/fsverity_private.h | 36 ++++++++++- fs/verity/open.c | 9 +-- fs/verity/read_metadata.c | 63 ++++++------------- fs/verity/verify.c | 141 ++++++++++++++++++++++++------------------ include/linux/fsverity.h | 24 +++++-- 5 files changed, 151 insertions(+), 122 deletions(-)
fs/verity/fsverity_private.h +32 -4
@@ -154,13 +154,41 @@ static inline void fsverity_init_signature(void)void __init fsverity_init_workqueue (void ); +static inline bool fsverity_caches_blocks (const struct inode *inode) +{ +const struct fsverity_operations *vops = inode->i_sb->s_vop; + +WARN_ON_ONCE (vops->read_merkle_tree_block && + !vops->drop_merkle_tree_block); + +return vops->read_merkle_tree_block !=NULL ; +} + +static inline bool fsverity_uses_bitmap (const struct fsverity_info *vi, +const struct inode *inode) +{ +/* +* If fs uses block-based Merkle tree caching, then fs-verity must use +* hash_block_verified bitmap as there's no page to mark it with +* PG_checked. +*/ +if (vi->tree_params.block_size !=PAGE_SIZE ) +return true; +return fsverity_caches_blocks (inode); +} + +int fsverity_read_merkle_tree_block (struct inode *inode, +const struct merkle_tree_params *params, +u64 pos,unsigned long ra_bytes, +struct fsverity_blockbuf *block); +/* * Drop 'block' obtained with ->read_merkle_tree_block(). Calls out back to -* filesystem if ->drop_block() is set, otherwise, drop the reference in the -* block->context. +* filesystem if ->drop_merkle_tree_block() is set, otherwise, drop the +* reference in the block->context. */ -void fsverity_drop_block (struct inode *inode, -struct fsverity_blockbuf *block); +void fsverity_drop_merkle_tree_block (struct inode *inode, +struct fsverity_blockbuf *block);#include <trace/events/fsverity.h>
fs/verity/open.c +4 -5
@@ -214,12 +214,11 @@ struct fsverity_info *fsverity_create_info(const struct inode *inode, goto fail;/* -* If fs passes Merkle tree blocks to fs-verity (e.g. XFS), then -* fs-verity should use hash_block_verified bitmap as there's no page -* to mark it with PG_checked. +* If fs uses block-based Merkle tree cachin, then fs-verity must use +* hash_block_verified bitmap as there's no page to mark it with +* PG_checked. */ -if (vi->tree_params.block_size !=PAGE_SIZE || - inode->i_sb->s_vop->read_merkle_tree_block) { +if (fsverity_uses_bitmap (vi, inode)) {/* * When the Merkle tree block size and page size differ, we use * a bitmap to keep track of which hash blocks have been
fs/verity/read_metadata.c +20 -43
96 lines not on this page · raw message
fs/verity/verify.c +79 -62
251 lines not on this page · raw message
include/linux/fsverity.h +16 -8
@@ -41,10 +41,10 @@* written down to disk. * * While reading the tree, fs-verity calls ->read_merkle_tree_block followed by -* ->drop_block to let filesystem know that memory can be freed. +* ->drop_merkle_tree_block to let filesystem know that memory can be freed. * * The context is optional. This field can be used by filesystem to passthrough -* state from ->read_merkle_tree_block to ->drop_block. +* state from ->read_merkle_tree_block to ->drop_merkle_tree_block. */ struct fsverity_blockbuf {void *kaddr;
@@ -128,6 +128,9 @@ struct fsverity_operations {* * Note that this must retrieve a *page*, not necessarily a *block*. * +* If this function is implemented, do not implement +* ->read_merkle_tree_block or ->drop_merkle_tree_block. +* * Return: the page on success, ERR_PTR() on failure */ struct page *(*read_merkle_tree_page)(struct inode *inode,
@@ -138,12 +141,12 @@ struct fsverity_operations {* Read a Merkle tree block of the given inode. * @inode: the inode * @pos: byte offset of the block within the Merkle tree -* @block: block buffer for filesystem to point it to the block -* @log_blocksize: log2 of the size of the expected block * @ra_bytes: The number of bytes that should be * prefetched starting at @pos if the page at @pos * isn't already cached. Implementations may ignore this * argument; it's only a performance optimization. +* @log_blocksize: log2 of the size of the expected block +* @block: block buffer for filesystem to point it to the block * * This can be called at any time on an open verity file. It may be * called by multiple processes concurrently.
@@ -152,13 +155,15 @@ struct fsverity_operations {* fsverity_invalidate_block() to let fsverity know that block's * verification state is not valid anymore. * +* If this function is implemented, ->drop_merkle_tree_block must also +* be implemented. +* * Return: 0 on success, -errno on failure */ int (*read_merkle_tree_block)(struct inode *inode, -u64 pos, -struct fsverity_blockbuf *block, +u64 pos,unsigned long ra_bytes,unsigned int log_blocksize, -u64 ra_bytes); +struct fsverity_blockbuf *block);/** * Write a Merkle tree block to the given inode.
@@ -183,8 +188,11 @@ struct fsverity_operations {* * This is called when fs-verity is done with a block obtained with * ->read_merkle_tree_block(). +* +* If this function is implemented, ->read_merkle_tree_block must also +* be implemented. */ -void (*drop_block)(struct fsverity_blockbuf *block); +void (*drop_merkle_tree_block)(struct fsverity_blockbuf *block); };#ifdef CONFIG_FS_VERITY
PATCH 11/40 fsverity: send the level of the merkle tree block to ->read_merkle_tree_block
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When fsverity needs to pull in a merkle tree block for file data verification, it knows the level of the block within the tree. For XFS, we will cache the blocks in memory ourselves, and it is advantageous to make higher level nodes more resistant to memory reclamation.
Therefore, we need to pass the anticipated level to the ->read_merkle_tree_block functions to enable this kind of caching. Establish level == -1 to mean streaming read (e.g. downloading the merkle tree).
--- fs/verity/fsverity_private.h | 2 +- fs/verity/read_metadata.c | 2 +- fs/verity/verify.c | 25 +++++++++++++++++++------ include/linux/fsverity.h | 32 ++++++++++++++++++++++---------- 4 files changed, 43 insertions(+), 18 deletions(-)
fs/verity/fsverity_private.h +1 -1
@@ -179,7 +179,7 @@ static inline bool fsverity_uses_bitmap(const struct fsverity_info *vi,int fsverity_read_merkle_tree_block (struct inode *inode,const struct merkle_tree_params *params, -u64 pos,unsigned long ra_bytes, +int level,u64 pos,unsigned long ra_bytes,struct fsverity_blockbuf *block);/*
fs/verity/read_metadata.c +1 -1
@@ -43,7 +43,7 @@ static int fsverity_read_merkle_tree(struct inode *inode, params->block_size - offs_in_block); err =fsverity_read_merkle_tree_block (inode, &vi->tree_params, - pos - offs_in_block, ra_bytes, &block); +-1 , pos - offs_in_block, ra_bytes, &block);if (err) { fsverity_err(inode, "Error %d reading Merkle tree block %llu",
fs/verity/verify.c +19 -6
@@ -184,8 +184,8 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,else ra_bytes =0 ; - err =fsverity_read_merkle_tree_block (inode, params, hblock_pos, - ra_bytes, block); + err =fsverity_read_merkle_tree_block (inode, params, level, + hblock_pos, ra_bytes, block);if (err) { fsverity_err(inode, "Error %d reading Merkle tree block %llu",
@@ -406,6 +406,8 @@ EXPORT_SYMBOL_GPL(fsverity_invalidate_block);* fsverity_read_merkle_tree_block() - read Merkle tree block * @inode: inode to which this Merkle tree blocks belong * @params: merkle tree parameters +* @level: expected level of the block; level 0 are the leaves, -1 means a +* streaming read * @pos: byte position within merkle tree * @ra_bytes: try to read ahead this many btes * @block: block to be loaded
@@ -414,7 +416,7 @@ EXPORT_SYMBOL_GPL(fsverity_invalidate_block);*/ int fsverity_read_merkle_tree_block (struct inode *inode,const struct merkle_tree_params *params, -u64 pos,unsigned long ra_bytes, +int level,u64 pos,unsigned long ra_bytes,struct fsverity_blockbuf *block) {const struct fsverity_operations *vops = inode->i_sb->s_vop;
@@ -423,9 +425,20 @@ int fsverity_read_merkle_tree_block(struct inode *inode,unsigned long index;unsigned int offset_in_page; -if (fsverity_caches_blocks (inode)) -return vops->read_merkle_tree_block (inode, pos, ra_bytes, - params->log_blocksize, block); + block->offset = pos; + block->size = params->block_size; + +if (fsverity_caches_blocks (inode)) { +struct fsverity_readmerkle req = { + .inode = inode, + .level = level, + .num_levels = params->num_levels, + .log_blocksize = params->log_blocksize, + .ra_bytes = ra_bytes, + }; + +return vops->read_merkle_tree_block (&req, block); + } index = pos >> params->log_blocksize; page_idx =round_down (index, params->blocks_per_page);
include/linux/fsverity.h +22 -10
@@ -53,6 +53,26 @@ struct fsverity_blockbuf {void *context; }; +/** +* struct fsverity_readmerkle - Request to read a Merkle Tree block buffer +* @inode: the inode to read +* @level: expected level of the block; level 0 are the leaves, -1 means a +* streaming read +* @num_levels: number of levels in the tree total +* @log_blocksize: log2 of the size of the expected block +* @ra_bytes: The number of bytes that should be prefetched starting at pos +* if the page at @block->offset isn't already cached. +* Implementations may ignore this argument; it's only a +* performance optimization. +*/ +struct fsverity_readmerkle { +struct inode *inode; +unsigned long ra_bytes; +int level; +int num_levels; +u8 log_blocksize; +}; +/* Verity operations for filesystems */ struct fsverity_operations {
@@ -139,13 +159,7 @@ struct fsverity_operations {/** * Read a Merkle tree block of the given inode. -* @inode: the inode -* @pos: byte offset of the block within the Merkle tree -* @ra_bytes: The number of bytes that should be -* prefetched starting at @pos if the page at @pos -* isn't already cached. Implementations may ignore this -* argument; it's only a performance optimization. -* @log_blocksize: log2 of the size of the expected block +* @req: read request; see struct fsverity_readmerkle * @block: block buffer for filesystem to point it to the block * * This can be called at any time on an open verity file. It may be
@@ -160,9 +174,7 @@ struct fsverity_operations {* * Return: 0 on success, -errno on failure */ -int (*read_merkle_tree_block)(struct inode *inode, -u64 pos,unsigned long ra_bytes, -unsigned int log_blocksize, +int (*read_merkle_tree_block)(const struct fsverity_readmerkle *req,struct fsverity_blockbuf *block);/**
PATCH 12/40 fsverity: pass the new tree size and block size to ->begin_enable_verity
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
When starting up the process of enabling fsverity on a file, pass the new size of the merkle tree and the merkle tree block size to the fs implementation. XFS will want this information later to try to clean out a failed previous enablement attempt.
--- fs/btrfs/verity.c | 3 ++- fs/ext4/verity.c | 3 ++- fs/f2fs/verity.c | 3 ++- fs/verity/enable.c | 3 ++- include/linux/fsverity.h | 5 ++++- 5 files changed, 12 insertions(+), 5 deletions(-)
fs/btrfs/verity.c +2 -1
@@ -579,7 +579,8 @@ static int finish_verity(struct btrfs_inode *inode, const void *desc,* * Returns 0 on success, negative error code on failure. */ -static int btrfs_begin_enable_verity (struct file *filp) +static int btrfs_begin_enable_verity (struct file *filp,u64 merkle_tree_size, +unsigned int tree_blocksize) {struct btrfs_inode *inode =BTRFS_I (file_inode (filp));struct btrfs_root *root = inode->root;
fs/ext4/verity.c +2 -1
@@ -99,7 +99,8 @@ static int pagecache_write(struct inode *inode, const void *buf, size_t count,return 0 ; } -static int ext4_begin_enable_verity (struct file *filp) +static int ext4_begin_enable_verity (struct file *filp,u64 merkle_tree_size, +unsigned int tree_blocksize) {struct inode *inode =file_inode (filp);const int credits =2 ;/* superblock and inode for ext4_orphan_add() */
fs/f2fs/verity.c +2 -1
@@ -115,7 +115,8 @@ struct fsverity_descriptor_location {__le64 pos; }; -static int f2fs_begin_enable_verity (struct file *filp) +static int f2fs_begin_enable_verity (struct file *filp,u64 merkle_tree_size, +unsigned int tree_blocksize) {struct inode *inode =file_inode (filp);int err;
fs/verity/enable.c +2 -1
@@ -237,7 +237,8 @@ static int enable_verity(struct file *filp,if (IS_VERITY (inode)) err = -EEXIST ;else - err = vops->begin_enable_verity (filp); + err = vops->begin_enable_verity (filp, params.tree_size, + params.block_size);inode_unlock (inode);if (err) goto out;
include/linux/fsverity.h +4 -1
@@ -80,6 +80,8 @@ struct fsverity_operations {* Begin enabling verity on the given file. * * @filp: a readonly file descriptor for the file +* @merkle_tree_size: total bytes the new Merkle tree will take up +* @tree_blocksize: the new Merkle tree block size * * The filesystem must do any needed filesystem-specific preparations * for enabling verity, e.g. evicting inline data. It also must return
@@ -89,7 +91,8 @@ struct fsverity_operations {* * Return: 0 on success, -errno on failure */ -int (*begin_enable_verity)(struct file *filp); +int (*begin_enable_verity)(struct file *filp,u64 merkle_tree_size, +unsigned int tree_blocksize);/** * End enabling verity on the given file.
PATCH 13/40 fsverity: expose merkle tree geometry to callers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a function that will return selected information about the geometry of the merkle tree. Online fsck for XFS will need this piece to perform basic checks of the merkle tree.
--- fs/verity/open.c | 26 ++++++++++++++++++++++++++ include/linux/fsverity.h | 3 +++ 2 files changed, 29 insertions(+)
fs/verity/open.c +26 -0
@@ -412,6 +412,32 @@ void __fsverity_cleanup_inode(struct inode *inode) }EXPORT_SYMBOL_GPL (__fsverity_cleanup_inode); +/** +* fsverity_merkle_tree_geometry() - return Merkle tree geometry +* @inode: the inode for which the Merkle tree is being built +* @block_size: size of a merkle tree block, in bytes +* @tree_size: size of the merkle tree, in bytes +*/ +int fsverity_merkle_tree_geometry (struct inode *inode,unsigned int *block_size, +u64 *tree_size) +{ +struct fsverity_info *vi; +int error; + +if (!IS_VERITY (inode)) +return -EOPNOTSUPP ; + + error =ensure_verity_info (inode); +if (error) +return error; + + vi =fsverity_get_info (inode); + *block_size = vi->tree_params.block_size; + *tree_size = vi->tree_params.tree_size; +return 0 ; +} +EXPORT_SYMBOL_GPL (fsverity_merkle_tree_geometry); +void __init fsverity_init_info_cache (void ) { fsverity_info_cachep = KMEM_CACHE_USERCOPY(
include/linux/fsverity.h +3 -0
@@ -240,6 +240,9 @@ int __fsverity_file_open(struct inode *inode, struct file *filp);int __fsverity_prepare_setattr (struct dentry *dentry,struct iattr *attr);void __fsverity_cleanup_inode (struct inode *inode); +int fsverity_merkle_tree_geometry (struct inode *inode,unsigned int *block_size, +u64 *tree_size); +/** * fsverity_cleanup_inode() - free the inode's verity info, if present * @inode: an inode being evicted
PATCH 14/40 fsverity: rely on cached block callers to retain verified state
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Using a single contiguous bitmap to record merkle tree block verification state is unnecessary when we can retain that state in the merkle tree block cache. Worse, it doesn't scale well to large verity files and stresses the memory allocator.
Therefore, add a state bit to fsverity_blockbuf and let the implementation retain the validated state.
--- fs/verity/fsverity_private.h | 7 ++++--- fs/verity/verify.c | 39 +++++++-------------------------------- include/linux/fsverity.h | 13 ++++++++----- include/trace/events/fsverity.h | 19 ------------------- 4 files changed, 19 insertions(+), 59 deletions(-)
fs/verity/fsverity_private.h +4 -3
@@ -167,14 +167,15 @@ static inline bool fsverity_caches_blocks(const struct inode *inode)static inline bool fsverity_uses_bitmap (const struct fsverity_info *vi,const struct inode *inode) { +if (fsverity_caches_blocks (inode)) +return false; +/* * If fs uses block-based Merkle tree caching, then fs-verity must use * hash_block_verified bitmap as there's no page to mark it with * PG_checked. */ -if (vi->tree_params.block_size !=PAGE_SIZE ) -return true; -return fsverity_caches_blocks (inode); +return vi->tree_params.block_size !=PAGE_SIZE ; } int fsverity_read_merkle_tree_block(struct inode *inode,
fs/verity/verify.c +7 -32
@@ -26,12 +26,11 @@ static bool is_hash_block_verified(struct inode *inode,struct page *hpage;/* -* If the filesystem uses block-based caching, then -* ->hash_block_verified is always used and the filesystem pushes -* invalidations to it as needed. +* If the filesystem uses block-based caching, then rely on the +* implementation to retain verified status. */ if (fsverity_caches_blocks (inode)) -return test_bit (hblock_idx, vi->hash_block_verified); +return block->verified;/* Otherwise, the filesystem uses page-based caching. */ hpage = (struct page *)block->context;
@@ -224,7 +223,9 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,* idempotent, as the same hash block might be verified by * multiple threads concurrently. */ -if (fsverity_uses_bitmap (vi, inode)) +if (fsverity_caches_blocks (inode)) + block->verified = true; +else if (fsverity_uses_bitmap (vi, inode))set_bit (hblock_idx, vi->hash_block_verified);else SetPageChecked ((struct page *)block->context);
@@ -375,33 +376,6 @@ void __init fsverity_init_workqueue(void)panic ("failed to allocate fsverity_read_queue" ); } -/** -* fsverity_invalidate_block() - invalidate Merkle tree block -* @inode: inode to which this Merkle tree blocks belong -* @block: block to be invalidated -* -* This function invalidates/clears "verified" state of Merkle tree block -* in the fs-verity bitmap. The block needs to have ->offset set. -*/ -void fsverity_invalidate_block (struct inode *inode, -struct fsverity_blockbuf *block) -{ -struct fsverity_info *vi = inode->i_verity_info; -const unsigned int log_blocksize = vi->tree_params.log_blocksize; - -trace_fsverity_invalidate_block (inode, block); - -if (block->offset >= vi->tree_params.tree_size) { -fsverity_err (inode, -"Trying to invalidate beyond Merkle tree (tree %lld, offset %lld)" , - vi->tree_params.tree_size, block->offset); -return ; - } - -clear_bit (block->offset >> log_blocksize, vi->hash_block_verified); -} -EXPORT_SYMBOL_GPL (fsverity_invalidate_block); -/** * fsverity_read_merkle_tree_block() - read Merkle tree block * @inode: inode to which this Merkle tree blocks belong
@@ -436,6 +410,7 @@ int fsverity_read_merkle_tree_block(struct inode *inode, .log_blocksize = params->log_blocksize, .ra_bytes = ra_bytes, }; + block->verified = false;return vops->read_merkle_tree_block (&req, block); }
include/linux/fsverity.h +8 -5
@@ -32,6 +32,7 @@* @offset: block's offset into Merkle tree * @size: the Merkle tree block size * @context: filesystem private context +* @verified: has this buffer been validated? * * Buffer containing single Merkle Tree block. These buffers are passed * - to filesystem, when fs-verity is building merkel tree,
@@ -49,6 +50,7 @@struct fsverity_blockbuf {void *kaddr;u64 offset; +unsigned int verified:1 ;unsigned int size;void *context; };
@@ -168,9 +170,9 @@ struct fsverity_operations {* This can be called at any time on an open verity file. It may be * called by multiple processes concurrently. * -* In case that block was evicted from the memory filesystem has to use -* fsverity_invalidate_block() to let fsverity know that block's -* verification state is not valid anymore. +* Implementations may cache the @block->verified state in +* ->drop_merkle_tree_block. They must clear the @block->verified +* flag for a cache miss. * * If this function is implemented, ->drop_merkle_tree_block must also * be implemented.
@@ -204,6 +206,9 @@ struct fsverity_operations {* This is called when fs-verity is done with a block obtained with * ->read_merkle_tree_block(). * +* Implementations should cache a @block->verified==1 state to avoid +* unnecessary revalidations during later accesses. +* * If this function is implemented, ->read_merkle_tree_block must also * be implemented. */
@@ -264,8 +269,6 @@ int fsverity_ioctl_read_metadata(struct file *filp, const void __user *uarg);bool fsverity_verify_blocks (struct folio *folio,size_t len,size_t offset);void fsverity_verify_bio (struct bio *bio);void fsverity_enqueue_verify_work (struct work_struct *work); -void fsverity_invalidate_block (struct inode *inode, -struct fsverity_blockbuf *block);static inline int fsverity_set_ops (struct super_block *sb,const struct fsverity_operations *ops)
include/trace/events/fsverity.h +0 -19
@@ -109,25 +109,6 @@ TRACE_EVENT(fsverity_merkle_tree_block_verified, __entry->direction == 0 ? "ascend" : "descend") ); -TRACE_EVENT (fsverity_invalidate_block, - TP_PROTO(struct inode *inode, struct fsverity_blockbuf *block), -TP_ARGS (inode, block), -TP_STRUCT__entry ( - __field(ino_t, ino) - __field(u64, offset) - __field(unsigned int, block_size) - ), -TP_fast_assign ( - __entry->ino = inode->i_ino; - __entry->offset = block->offset; - __entry->block_size = block->size; - ), -TP_printk ("ino %lu block position %llu block size %u" , - (unsigned long ) __entry->ino, - __entry->offset, - __entry->block_size) -); - TRACE_EVENT(fsverity_read_merkle_tree_block, TP_PROTO(struct inode *inode, u64 offset, unsigned int log_blocksize), TP_ARGS(inode, offset, log_blocksize),
PATCH 15/40 fsverity: box up the write_merkle_tree_block parameters too
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Box up the tree write request parameters into a structure so that we can add more in the next few patches.
--- fs/btrfs/verity.c | 6 ++++-- fs/ext4/verity.c | 7 +++++-- fs/f2fs/verity.c | 7 +++++-- fs/verity/enable.c | 5 ++++- include/linux/fsverity.h | 21 ++++++++++++++++++--- 5 files changed, 36 insertions(+), 10 deletions(-)
fs/btrfs/verity.c +4 -2
@@ -791,9 +791,11 @@ static struct page *btrfs_read_merkle_tree_page(struct inode *inode,* * Returns 0 on success or negative error code on failure */ -static int btrfs_write_merkle_tree_block (struct inode *inode,const void *buf, -u64 pos,unsigned int size) +static int btrfs_write_merkle_tree_block (const struct fsverity_writemerkle *req, +const void *buf,u64 pos, +unsigned int size) { +struct inode *inode = req->inode;loff_t merkle_pos =merkle_file_pos (inode);if (merkle_pos <0 )
fs/ext4/verity.c +5 -2
@@ -382,9 +382,12 @@ static struct page *ext4_read_merkle_tree_page(struct inode *inode,return folio_file_page (folio, index); } -static int ext4_write_merkle_tree_block (struct inode *inode,const void *buf, -u64 pos,unsigned int size) +static int ext4_write_merkle_tree_block (const struct fsverity_writemerkle *req, +const void *buf,u64 pos, +unsigned int size) { +struct inode *inode = req->inode; + pos +=ext4_verity_metadata_pos (inode);return pagecache_write (inode, buf, size, pos);
fs/f2fs/verity.c +5 -2
@@ -277,9 +277,12 @@ static struct page *f2fs_read_merkle_tree_page(struct inode *inode,return page; } -static int f2fs_write_merkle_tree_block (struct inode *inode,const void *buf, -u64 pos,unsigned int size) +static int f2fs_write_merkle_tree_block (const struct fsverity_writemerkle *req, +const void *buf,u64 pos, +unsigned int size) { +struct inode *inode = req->inode; + pos +=f2fs_verity_metadata_pos (inode);return pagecache_write (inode, buf, size, pos);
fs/verity/enable.c +4 -1
@@ -50,10 +50,13 @@ static int write_merkle_tree_block(struct inode *inode, const u8 *buf,unsigned long index, const struct merkle_tree_params *params) { + struct fsverity_writemerkle req = { + .inode = inode, + };u64 pos = (u64 )index << params->log_blocksize;int err; - err = inode->i_sb->s_vop->write_merkle_tree_block (inode, buf, pos, + err = inode->i_sb->s_vop->write_merkle_tree_block (&req, buf, pos, params->block_size); if (err) fsverity_err(inode, "Error %d writing Merkle tree block %lu",
include/linux/fsverity.h +18 -3
@@ -75,6 +75,20 @@ struct fsverity_readmerkle {u8 log_blocksize; }; +/** +* struct fsverity_writemerkle - Request to write a Merkle Tree block buffer +* @inode: the inode to read +* @level: level of the block; level 0 are the leaves +* @num_levels: number of levels in the tree total +* @log_blocksize: log2 of the size of the block +*/ +struct fsverity_writemerkle { +struct inode *inode; +int level; +int num_levels; +u8 log_blocksize; +}; +/* Verity operations for filesystems */ struct fsverity_operations {
@@ -185,7 +199,7 @@ struct fsverity_operations {/** * Write a Merkle tree block to the given inode. * -* @inode: the inode for which the Merkle tree is being built +* @req: write request; see struct fsverity_writemerkle * @buf: the Merkle tree block to write * @pos: the position of the block in the Merkle tree (in bytes) * @size: the Merkle tree block size (in bytes)
@@ -195,8 +209,9 @@ struct fsverity_operations {* * Return: 0 on success, -errno on failure */ -int (*write_merkle_tree_block)(struct inode *inode,const void *buf, -u64 pos,unsigned int size); +int (*write_merkle_tree_block)(const struct fsverity_writemerkle *req, +const void *buf,u64 pos, +unsigned int size);/** * Release the reference to a Merkle tree block
PATCH 16/40 fsverity: pass the zero-hash value to the implementation
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Compute the hash of a data block full of zeros, and then supply this to the merkle tree read and write methods. A subsequent xfs patch will use this to reduce the size of the merkle tree when dealing with sparse gold master disk images and the like.
--- fs/verity/enable.c | 2 ++ fs/verity/fsverity_private.h | 2 ++ fs/verity/open.c | 7 +++++++ fs/verity/verify.c | 2 ++ include/linux/fsverity.h | 8 ++++++++ 5 files changed, 21 insertions(+)
fs/verity/enable.c +2 -0
@@ -52,6 +52,8 @@ static int write_merkle_tree_block(struct inode *inode, const u8 *buf, {struct fsverity_writemerkle req = { .inode = inode, + .zero_digest = params->zero_digest, + .digest_size = params->digest_size, };u64 pos = (u64 )index << params->log_blocksize;int err;
fs/verity/fsverity_private.h +2 -0
@@ -47,6 +47,8 @@ struct merkle_tree_params {u64 tree_size;/* Merkle tree size in bytes */ unsigned long tree_pages;/* Merkle tree size in pages */ +u8 zero_digest[FS_VERITY_MAX_DIGEST_SIZE ];/* hash of zeroed data block */ +/* * Starting block index for each tree level, ordered from leaf level (0) * to root level ('num_levels - 1')
fs/verity/open.c +7 -0
@@ -144,6 +144,13 @@ int fsverity_init_merkle_tree_params(struct merkle_tree_params *params, goto out_err; } + err =fsverity_hash_buffer (params->hash_alg,page_address (ZERO_PAGE (0 )), +i_blocksize (inode), params->zero_digest); +if (err) { +fsverity_err (inode,"Error %d computing zero digest" , err); + goto out_err; + } + params->tree_size = offset << log_blocksize; params->tree_pages =PAGE_ALIGN (params->tree_size) >>PAGE_SHIFT ;return 0 ;
fs/verity/verify.c +2 -0
@@ -409,6 +409,8 @@ int fsverity_read_merkle_tree_block(struct inode *inode, .num_levels = params->num_levels, .log_blocksize = params->log_blocksize, .ra_bytes = ra_bytes, + .zero_digest = params->zero_digest, + .digest_size = params->digest_size, }; block->verified = false;
include/linux/fsverity.h +8 -0
@@ -66,6 +66,8 @@ struct fsverity_blockbuf {* if the page at @block->offset isn't already cached. * Implementations may ignore this argument; it's only a * performance optimization. +* @zero_digest: the hash for a data block of zeroes +* @digest_size: size of zero_digest */ struct fsverity_readmerkle {struct inode *inode;
@@ -73,6 +75,8 @@ struct fsverity_readmerkle {int level;int num_levels;u8 log_blocksize; +const u8 *zero_digest; +unsigned int digest_size; };/**
@@ -81,12 +85,16 @@ struct fsverity_readmerkle {* @level: level of the block; level 0 are the leaves * @num_levels: number of levels in the tree total * @log_blocksize: log2 of the size of the block +* @zero_digest: the hash for a data block of zeroes +* @digest_size: size of zero_digest */ struct fsverity_writemerkle {struct inode *inode;int level;int num_levels;u8 log_blocksize; +const u8 *zero_digest; +unsigned int digest_size; };/* Verity operations for filesystems */
Eric Biggers
maintainerRe: [PATCH 16/40] fsverity: pass the zero-hash value to the implementation
Quoted 5 lines · Darrick J. Wong
fs/verity/open.c +0
-0
fs/verity/open.c int fsverity_init_merkle_tree_params(struct merkle_tree_params *params, · line 152
Quoted 9 lines
fs/verity/open.c +6
-0@@ -144,6 +144,13 @@ int fsverity_init_merkle_tree_params(struct merkle_tree_params *params, goto out_err; } + err =fsverity_hash_buffer (params->hash_alg,page_address (ZERO_PAGE (0 )), +i_blocksize (inode), params->zero_digest); +if (err) { +fsverity_err (inode,"Error %d computing zero digest" , err); + goto out_err; + }
This doesn't take the salt into account. Also it's using the wrong block size (filesystem block size instead of Merkle tree block size).
How about using fsverity_hash_block()?
- Eric
Re: [PATCH 16/40] fsverity: pass the zero-hash value to the implementation
Quoted 19 lines · Eric Biggers
Quoted 5 lines · Darrick J. Wong
fs/verity/open.c +0
-0fs/verity/open.c int fsverity_init_merkle_tree_params(struct merkle_tree_params *params, · line 152
Quoted 9 lines
fs/verity/open.c +6
-0@@ -144,6 +144,13 @@ int fsverity_init_merkle_tree_params(struct merkle_tree_params *params, goto out_err; } + err =fsverity_hash_buffer (params->hash_alg,page_address (ZERO_PAGE (0 )), +i_blocksize (inode), params->zero_digest); +if (err) { +fsverity_err (inode,"Error %d computing zero digest" , err); + goto out_err; + }This doesn't take the salt into account. Also it's using the wrong block size (filesystem block size instead of Merkle tree block size).
Quoted 1 line
How about using
fsverity_hash_block()?
/me looks at build_merkle_tree again, realizes that it calls hash_one_block on params->block_size bytes of file data.
IOWs, fsverity_hash_block is indeed the correct function to call here. Thanks for the correction!
--D
Quoted 1 line
- Eric
PATCH 17/40 fsverity: report validation errors back to the filesystem
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Provide a new function call so that validation errors can be reported back to the filesystem.
--- fs/verity/verify.c | 14 +++++++++++++- include/linux/fsverity.h | 11 +++++++++++ 2 files changed, 24 insertions(+), 1 deletion(-)
fs/verity/verify.c +13 -1
@@ -255,6 +255,15 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,return false; } +static void fsverity_fail_validation (struct inode *inode,loff_t pos, +size_t len) +{ +const struct fsverity_operations *vops = inode->i_sb->s_vop; + +if (vops->fail_validation) + vops->fail_validation (inode, pos, len); +} +static bool verify_data_blocks (struct folio *data_folio,size_t len,size_t offset,unsigned long max_ra_bytes)
@@ -277,8 +286,11 @@ verify_data_blocks(struct folio *data_folio, size_t len, size_t offset, valid =verify_data_block (inode, vi, data, pos + offset, max_ra_bytes);kunmap_local (data); -if (!valid) +if (!valid) { +fsverity_fail_validation (inode, pos + offset, + block_size);return false; + } offset += block_size; len -= block_size; }while (len);
include/linux/fsverity.h +11 -0
@@ -236,6 +236,17 @@ struct fsverity_operations {* be implemented. */ void (*drop_merkle_tree_block)(struct fsverity_blockbuf *block); + +/** +* Notify the filesystem that file data validation failed +* +* @inode: the inode being validated +* @pos: the file position of the invalid data +* @len: the length of the invalid data +* +* This is called when fs-verity cannot validate the file contents. +*/ +void (*fail_validation)(struct inode *inode,loff_t pos,size_t len); };#ifdef CONFIG_FS_VERITY
PATCH 18/40 iomap: integrate fs-verity verification into iomap's read path
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
This patch adds fs-verity verification into iomap's read path. After BIO's io operation is complete the data are verified against fs-verity's Merkle tree. Verification work is done in a separate workqueue.
The read path ioend iomap_read_ioend are stored side by side with BIOs if FS_VERITY is enabled.
--- fs/iomap/buffered-io.c | 91 +++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 82 insertions(+), 9 deletions(-)
fs/iomap/buffered-io.c +82 -9
@@ -6,6 +6,7 @@#include <linux/module.h> #include <linux/compiler.h> #include <linux/fs.h> +#include <linux/fsverity.h> #include <linux/iomap.h> #include <linux/pagemap.h> #include <linux/uio.h>
@@ -330,6 +331,56 @@ static inline bool iomap_block_needs_zeroing(const struct iomap_iter *iter, pos >=i_size_read (iter->inode); } +#ifdef CONFIG_FS_VERITY +struct iomap_fsverity_bio { +struct work_struct work; +struct bio bio; +}; +static struct bio_set iomap_fsverity_bioset; + +static void +iomap_read_fsverify_end_io_work (struct work_struct *work) +{ +struct iomap_fsverity_bio *fbio = + container_of(work, struct iomap_fsverity_bio, work); + +fsverity_verify_bio (&fbio->bio); +iomap_read_end_io (&fbio->bio); +} + +static void +iomap_read_fsverity_end_io (struct bio *bio) +{ +struct iomap_fsverity_bio *fbio = + container_of(bio, struct iomap_fsverity_bio, bio); + +INIT_WORK (&fbio->work, iomap_read_fsverify_end_io_work); +queue_work (bio->bi_private, &fbio->work); +} +#endif /* CONFIG_FS_VERITY */ + +static struct bio *iomap_read_bio_alloc (struct inode *inode, +struct block_device *bdev,int nr_vecs,gfp_t gfp) +{ +struct bio *bio; + +#ifdef CONFIG_FS_VERITY +if (fsverity_active (inode)) { + bio =bio_alloc_bioset (bdev, nr_vecs,REQ_OP_READ , gfp, + &iomap_fsverity_bioset); +if (bio) { + bio->bi_private = inode->i_sb->s_read_done_wq; + bio->bi_end_io = iomap_read_fsverity_end_io; + } +return bio; + } +#endif + bio =bio_alloc (bdev, nr_vecs,REQ_OP_READ , gfp); +if (bio) + bio->bi_end_io = iomap_read_end_io; +return bio; +} +static loff_t iomap_readpage_iter (const struct iomap_iter *iter,struct iomap_readpage_ctx *ctx,loff_t offset) {
@@ -353,6 +404,12 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,if (iomap_block_needs_zeroing (iter, pos)) {folio_zero_range (folio, poff, plen); +if (fsverity_active (iter->inode) && + !fsverity_verify_blocks (folio, plen, poff)) { +folio_set_error (folio); + goto done; + } +iomap_set_range_uptodate (folio, poff, plen); goto done; }
@@ -370,28 +427,29 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter, !bio_add_folio(ctx->bio, folio, plen, poff)) {gfp_t gfp =mapping_gfp_constraint (folio->mapping,GFP_KERNEL );gfp_t orig_gfp = gfp; -unsigned int nr_vecs =DIV_ROUND_UP (length,PAGE_SIZE );if (ctx->bio)submit_bio (ctx->bio);if (ctx->rac)/* same as readahead_gfp_mask */ gfp |= __GFP_NORETRY | __GFP_NOWARN; - ctx->bio =bio_alloc (iomap->bdev,bio_max_segs (nr_vecs), -REQ_OP_READ , gfp); + + ctx->bio =iomap_read_bio_alloc (iter->inode, iomap->bdev, +bio_max_segs (DIV_ROUND_UP (length,PAGE_SIZE )), + gfp); +/* * If the bio_alloc fails, try it again for a single page to * avoid having to deal with partial page reads. This emulates * what do_mpage_read_folio does. */ if (!ctx->bio) { - ctx->bio =bio_alloc (iomap->bdev,1 ,REQ_OP_READ , - orig_gfp); + ctx->bio =iomap_read_bio_alloc (iter->inode, + iomap->bdev,1 , orig_gfp); }if (ctx->rac) ctx->bio->bi_opf |=REQ_RAHEAD ; ctx->bio->bi_iter.bi_sector = sector; - ctx->bio->bi_end_io = iomap_read_end_io;bio_add_folio_nofail (ctx->bio, folio, plen, poff); }
@@ -1996,10 +2054,25 @@ iomap_writepages(struct address_space *mapping, struct writeback_control *wbc, }EXPORT_SYMBOL_GPL (iomap_writepages); +#define IOMAP_POOL_SIZE (4 * (PAGE_SIZE / SECTOR_SIZE)) +static int __init iomap_init (void ) { -return bioset_init (&iomap_ioend_bioset,4 * (PAGE_SIZE /SECTOR_SIZE ), - offsetof(struct iomap_ioend , io_inline_bio), -BIOSET_NEED_BVECS ); +int error; + + error =bioset_init (&iomap_ioend_bioset,IOMAP_POOL_SIZE , + offsetof(struct iomap_ioend , io_inline_bio), +BIOSET_NEED_BVECS ); +#ifdef CONFIG_FS_VERITY +if (error) +return error; + + error =bioset_init (&iomap_fsverity_bioset,IOMAP_POOL_SIZE , + offsetof(struct iomap_fsverity_bio , bio), +BIOSET_NEED_BVECS ); +if (error) +bioset_exit (&iomap_ioend_bioset); +#endif +return error; }fs_initcall (iomap_init);
PATCH 19/40 xfs: add attribute type for fs-verity
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
The Merkle tree blocks and descriptor are stored in the extended attributes of the inode. Add new attribute type for fs-verity metadata. Add XFS_ATTR_INTERNAL_MASK to skip parent pointer and fs-verity attributes as those are only for internal use. While we're at it add a few comments in relevant places that internally visible attributes are not suppose to be handled via interface defined in xfs_xattr.c.
--- fs/xfs/libxfs/xfs_da_format.h | 10 +++++++++- fs/xfs/libxfs/xfs_log_format.h | 1 + fs/xfs/xfs_ioctl.c | 5 +++++ fs/xfs/xfs_trace.h | 3 ++- fs/xfs/xfs_xattr.c | 10 ++++++++++ 5 files changed, 27 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_da_format.h +9 -1
@@ -715,14 +715,22 @@ struct xfs_attr3_leafblock {#define XFS_ATTR_ROOT_BIT 1/* limit access to trusted attrs */ #define XFS_ATTR_SECURE_BIT 2/* limit access to secure attrs */ #define XFS_ATTR_PARENT_BIT 3/* parent pointer attrs */ +#define XFS_ATTR_VERITY_BIT 4/* verity merkle tree and descriptor */ #define XFS_ATTR_INCOMPLETE_BIT 7/* attr in middle of create/delete */ #define XFS_ATTR_LOCAL (1u << XFS_ATTR_LOCAL_BIT)#define XFS_ATTR_ROOT (1u << XFS_ATTR_ROOT_BIT)#define XFS_ATTR_SECURE (1u << XFS_ATTR_SECURE_BIT)#define XFS_ATTR_PARENT (1u << XFS_ATTR_PARENT_BIT) +#define XFS_ATTR_VERITY (1u << XFS_ATTR_VERITY_BIT)#define XFS_ATTR_INCOMPLETE (1u << XFS_ATTR_INCOMPLETE_BIT)#define XFS_ATTR_NSP_ONDISK_MASK \ - (XFS_ATTR_ROOT | XFS_ATTR_SECURE | XFS_ATTR_PARENT) + (XFS_ATTR_ROOT | XFS_ATTR_SECURE | XFS_ATTR_PARENT | \ + XFS_ATTR_VERITY) + +/* +* Internal attributes not exposed to the user +*/ +#define XFS_ATTR_INTERNAL_MASK (XFS_ATTR_PARENT | XFS_ATTR_VERITY)/* * Alignment for namelist and valuelist entries (since they are mixed
fs/xfs/libxfs/xfs_log_format.h +1 -0
@@ -975,6 +975,7 @@ struct xfs_icreate_log {#define XFS_ATTRI_FILTER_MASK (XFS_ATTR_ROOT | \ XFS_ATTR_SECURE | \ XFS_ATTR_PARENT | \ + XFS_ATTR_VERITY | \ XFS_ATTR_INCOMPLETE)/*
fs/xfs/xfs_ioctl.c +5 -0
@@ -352,6 +352,11 @@ static unsigned intxfs_attr_filter ( u32 ioc_flags) { +/* +* Only externally visible attributes should be specified here. +* Internally used attributes (such as parent pointers or fs-verity) +* should not be exposed to userspace. +*/ if (ioc_flags &XFS_IOC_ATTR_ROOT )return XFS_ATTR_ROOT ;if (ioc_flags &XFS_IOC_ATTR_SECURE )
fs/xfs/xfs_trace.h +2 -1
@@ -87,7 +87,8 @@ struct xfs_bmap_intent; { XFS_ATTR_ROOT, "ROOT" }, \ { XFS_ATTR_SECURE, "SECURE" }, \ { XFS_ATTR_INCOMPLETE, "INCOMPLETE" }, \ - { XFS_ATTR_PARENT, "PARENT" } + { XFS_ATTR_PARENT, "PARENT" }, \ + { XFS_ATTR_VERITY, "VERITY" } DECLARE_EVENT_CLASS(xfs_attr_list_class, TP_PROTO(struct xfs_attr_list_context *ctx),
fs/xfs/xfs_xattr.c +10 -0
@@ -20,6 +20,13 @@#include <linux/posix_acl_xattr.h> +/* +* This file defines interface to work with externally visible extended +* attributes, such as those in user, system or security namespaces. This +* interface should not be used for internally used attributes (consider +* xfs_attr.c). +*/ +/* * Get permission to use log-assisted atomic exchange of file extents. *
@@ -244,6 +251,9 @@ xfs_xattr_put_listent(ASSERT (context->count >=0 ); +if (flags &XFS_ATTR_INTERNAL_MASK ) +return ; +if (flags &XFS_ATTR_ROOT ) {#ifdef CONFIG_XFS_POSIX_ACL if (namelen == SGI_ACL_FILE_SIZE &&
PATCH 20/40 xfs: add fs-verity ro-compat flag
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
To mark inodes with fs-verity enabled the new XFS_DIFLAG2_VERITY flag will be added in further patch. This requires ro-compat flag to let older kernels know that fs with fs-verity can not be modified.
--- fs/xfs/libxfs/xfs_format.h | 1 + fs/xfs/libxfs/xfs_sb.c | 2 ++ fs/xfs/xfs_mount.h | 2 ++ 3 files changed, 5 insertions(+)
fs/xfs/libxfs/xfs_format.h +1 -0
@@ -353,6 +353,7 @@ xfs_sb_has_compat_feature(#define XFS_SB_FEAT_RO_COMPAT_RMAPBT (1 << 1)/* reverse map btree */ #define XFS_SB_FEAT_RO_COMPAT_REFLINK (1 << 2)/* reflinked files */ #define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3)/* inobt block counts */ +#define XFS_SB_FEAT_RO_COMPAT_VERITY (1 << 4)/* fs-verity */ #define XFS_SB_FEAT_RO_COMPAT_ALL \ (XFS_SB_FEAT_RO_COMPAT_FINOBT | \ XFS_SB_FEAT_RO_COMPAT_RMAPBT | \
fs/xfs/libxfs/xfs_sb.c +2 -0
@@ -163,6 +163,8 @@ xfs_sb_version_to_features( features |=XFS_FEAT_REFLINK ;if (sbp->sb_features_ro_compat &XFS_SB_FEAT_RO_COMPAT_INOBTCNT ) features |=XFS_FEAT_INOBTCNT ; +if (sbp->sb_features_ro_compat &XFS_SB_FEAT_RO_COMPAT_VERITY ) + features |=XFS_FEAT_VERITY ;if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_FTYPE ) features |=XFS_FEAT_FTYPE ;if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_SPINODES )
fs/xfs/xfs_mount.h +2 -0
@@ -292,6 +292,7 @@ typedef struct xfs_mount {#define XFS_FEAT_BIGTIME (1ULL << 24)/* large timestamps */ #define XFS_FEAT_NEEDSREPAIR (1ULL << 25)/* needs xfs_repair */ #define XFS_FEAT_NREXT64 (1ULL << 26)/* large extent counters */ +#define XFS_FEAT_VERITY (1ULL << 27)/* fs-verity */ /* Mount features */ #define XFS_FEAT_NOATTR2 (1ULL << 48)/* disable attr2 creation */
@@ -355,6 +356,7 @@ __XFS_HAS_FEAT(inobtcounts, INOBTCNT) __XFS_HAS_FEAT(bigtime, BIGTIME) __XFS_HAS_FEAT(needsrepair, NEEDSREPAIR) __XFS_HAS_FEAT(large_extent_counts, NREXT64) +__XFS_HAS_FEAT (verity,VERITY )/* * Mount features
PATCH 21/40 xfs: add inode on-disk VERITY flag
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Add flag to mark inodes which have fs-verity enabled on them (i.e. descriptor exist and tree is built).
--- fs/xfs/libxfs/xfs_format.h | 4 +++- fs/xfs/xfs_inode.c | 2 ++ fs/xfs/xfs_iops.c | 2 ++ 3 files changed, 7 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_format.h +3 -1
@@ -1085,16 +1085,18 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)#define XFS_DIFLAG2_COWEXTSIZE_BIT 2/* copy on write extent size hint */ #define XFS_DIFLAG2_BIGTIME_BIT 3/* big timestamps */ #define XFS_DIFLAG2_NREXT64_BIT 4/* large extent counters */ +#define XFS_DIFLAG2_VERITY_BIT 5/* inode sealed by fsverity */ #define XFS_DIFLAG2_DAX (1 << XFS_DIFLAG2_DAX_BIT)#define XFS_DIFLAG2_REFLINK (1 << XFS_DIFLAG2_REFLINK_BIT)#define XFS_DIFLAG2_COWEXTSIZE (1 << XFS_DIFLAG2_COWEXTSIZE_BIT)#define XFS_DIFLAG2_BIGTIME (1 << XFS_DIFLAG2_BIGTIME_BIT)#define XFS_DIFLAG2_NREXT64 (1 << XFS_DIFLAG2_NREXT64_BIT) +#define XFS_DIFLAG2_VERITY (1 << XFS_DIFLAG2_VERITY_BIT)#define XFS_DIFLAG2_ANY \ (XFS_DIFLAG2_DAX | XFS_DIFLAG2_REFLINK | XFS_DIFLAG2_COWEXTSIZE | \ - XFS_DIFLAG2_BIGTIME | XFS_DIFLAG2_NREXT64) + XFS_DIFLAG2_BIGTIME | XFS_DIFLAG2_NREXT64 | XFS_DIFLAG2_VERITY)static inline bool xfs_dinode_has_bigtime (const struct xfs_dinode *dip) {
fs/xfs/xfs_inode.c +2 -0
@@ -607,6 +607,8 @@ xfs_ip2xflags( flags |=FS_XFLAG_DAX ;if (ip->i_diflags2 &XFS_DIFLAG2_COWEXTSIZE ) flags |=FS_XFLAG_COWEXTSIZE ; +if (ip->i_diflags2 &XFS_DIFLAG2_VERITY ) + flags |=FS_XFLAG_VERITY ; }if (xfs_inode_has_attr_fork (ip))
fs/xfs/xfs_iops.c +2 -0
@@ -1241,6 +1241,8 @@ xfs_diflags_to_iflags( flags |=S_NOATIME ;if (init &&xfs_inode_should_enable_dax (ip)) flags |=S_DAX ; +if (xflags &FS_XFLAG_VERITY ) + flags |=S_VERITY ;/* * S_DAX can only be set during inode initialization and is never set by
PATCH 22/40 xfs: initialize fs-verity on file open and cleanup on inode destruction
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
fs-verity will read and attach metadata (not the tree itself) from a disk for those inodes which already have fs-verity enabled.
--- fs/xfs/xfs_file.c | 8 ++++++++ fs/xfs/xfs_super.c | 2 ++ 2 files changed, 10 insertions(+)
fs/xfs/xfs_file.c +8 -0
@@ -31,6 +31,7 @@#include <linux/mman.h> #include <linux/fadvise.h> #include <linux/mount.h> +#include <linux/fsverity.h> static const struct vm_operations_struct xfs_file_vm_ops;
@@ -1228,10 +1229,17 @@ xfs_file_open(struct inode *inode, struct file *file) { + int error; +if (xfs_is_shutdown (XFS_M (inode->i_sb)))return -EIO ; file->f_mode |=FMODE_NOWAIT |FMODE_BUF_RASYNC |FMODE_BUF_WASYNC |FMODE_DIO_PARALLEL_WRITE |FMODE_CAN_ODIRECT ; + + error =fsverity_file_open (inode, file); +if (error) +return error; +return generic_file_open (inode, file); }
fs/xfs/xfs_super.c +2 -0
@@ -49,6 +49,7 @@#include <linux/magic.h> #include <linux/fs_context.h> #include <linux/fs_parser.h> +#include <linux/fsverity.h> static const struct super_operations xfs_super_operations;
@@ -664,6 +665,7 @@ xfs_fs_destroy_inode(ASSERT (!rwsem_is_locked (&inode->i_rwsem));XFS_STATS_INC (ip->i_mount, vn_rele);XFS_STATS_INC (ip->i_mount, vn_remove); +fsverity_cleanup_inode (inode);xfs_inode_mark_reclaimable (ip); }
PATCH 23/40 xfs: don't allow to enable DAX on fs-verity sealed inode
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
fs-verity doesn't support DAX. Forbid filesystem to enable DAX on inodes which already have fs-verity enabled. The opposite is checked when fs-verity is enabled, it won't be enabled if DAX is.
--- fs/xfs/xfs_iops.c | 2 ++ 1 file changed, 2 insertions(+)
fs/xfs/xfs_iops.c +2 -0
@@ -1213,6 +1213,8 @@ xfs_inode_should_enable_dax(return false;if (!xfs_inode_supports_dax (ip))return false; +if (ip->i_diflags2 &XFS_DIFLAG2_VERITY ) +return false;if (xfs_has_dax_always (ip->i_mount))return true;if (ip->i_diflags2 &XFS_DIFLAG2_DAX )
PATCH 24/40 xfs: disable direct read path for fs-verity files
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
The direct path is not supported on verity files. Attempts to use direct I/O path on such files should fall back to buffered I/O path.
--- fs/xfs/xfs_file.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-)
fs/xfs/xfs_file.c +12 -3
@@ -281,7 +281,8 @@ xfs_file_dax_read(struct kiocb *iocb, struct iov_iter *to) { - struct xfs_inode *ip = XFS_I(iocb->ki_filp->f_mapping->host); + struct inode *inode = iocb->ki_filp->f_mapping->host; +struct xfs_inode *ip =XFS_I (inode);ssize_t ret =0 ;trace_xfs_file_dax_read (iocb, to);
@@ -334,10 +335,18 @@ xfs_file_read_iter(if (IS_DAX (inode)) ret =xfs_file_dax_read (iocb, to); -else if (iocb->ki_flags &IOCB_DIRECT ) +else if (iocb->ki_flags &IOCB_DIRECT && !fsverity_active (inode)) ret =xfs_file_dio_read (iocb, to); -else +else { +/* +* In case fs-verity is enabled, we also fallback to the +* buffered read from the direct read path. Therefore, +* IOCB_DIRECT is set and need to be cleared (see +* generic_file_read_iter()) +*/ + iocb->ki_flags &= ~IOCB_DIRECT ; ret =xfs_file_buffered_read (iocb, to); + }if (ret >0 )XFS_STATS_ADD (mp, xs_read_bytes, ret);
Re: [PATCH 24/40] xfs: disable direct read path for fs-verity files
Quoted 29 lines · Darrick J. Wong
From: Andrey Albershteyn <[email protected]>
The direct path is not supported on verity files. Attempts to use direct I/O path on such files should fall back to buffered I/O path.
Signed-off-by Andrey Albershteyn <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>[djwong: fix braces]Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/xfs_file.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-)fs/xfs/xfs_file.c +2
-1@@ -281,7 +281,8 @@ xfs_file_dax_read(struct kiocb *iocb, struct iov_iter *to) { - struct xfs_inode *ip = XFS_I(iocb->ki_filp->f_mapping->host); + struct inode *inode = iocb->ki_filp->f_mapping->host; +struct xfs_inode *ip =XFS_I (inode);ssize_t ret =0 ;trace_xfs_file_dax_read (iocb, to);
fs/xfs/xfs_file.c xfs_file_read_iter( · line 338
Quoted 5 lines
fs/xfs/xfs_file.c +1
-1@@ -334,10 +335,18 @@ xfs_file_read_iter(if (IS_DAX (inode)) ret =xfs_file_dax_read (iocb, to); -else if (iocb->ki_flags &IOCB_DIRECT ) +else if (iocb->ki_flags &IOCB_DIRECT && !fsverity_active (inode))
Brackets missing
Quoted 17 lines
fs/xfs/xfs_file.c +9
-1ret =xfs_file_dio_read (iocb, to); - else + else { +/* +* In case fs-verity is enabled, we also fallback to the +* buffered read from the direct read path. Therefore, +* IOCB_DIRECT is set and need to be cleared (see +* generic_file_read_iter()) +*/ + iocb->ki_flags &= ~IOCB_DIRECT ; ret =xfs_file_buffered_read (iocb, to); + }if (ret >0 )XFS_STATS_ADD (mp, xs_read_bytes, ret);
Signature · 1 line
- Andrey
Re: [PATCH 24/40] xfs: disable direct read path for fs-verity files
Quoted 31 lines · Andrey Albershteyn
Quoted 30 lines · Darrick J. Wong
From: Andrey Albershteyn <[email protected]>
The direct path is not supported on verity files. Attempts to use direct I/O path on such files should fall back to buffered I/O path.
Signed-off-by Andrey Albershteyn <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>[djwong: fix braces]Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/xfs_file.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-)fs/xfs/xfs_file.c +2
-1@@ -281,7 +281,8 @@ xfs_file_dax_read(struct kiocb *iocb, struct iov_iter *to) { - struct xfs_inode *ip = XFS_I(iocb->ki_filp->f_mapping->host); + struct inode *inode = iocb->ki_filp->f_mapping->host; +struct xfs_inode *ip =XFS_I (inode);ssize_t ret =0 ;trace_xfs_file_dax_read (iocb, to);@@ -334,10 +335,18 @@ xfs_file_read_iter(
Quoted 6 lines
fs/xfs/xfs_file.c xfs_file_read_iter( · line 338
Quoted 4 lines
fs/xfs/xfs_file.c +1
-1if (IS_DAX (inode)) ret =xfs_file_dax_read (iocb, to); -else if (iocb->ki_flags &IOCB_DIRECT ) +else if (iocb->ki_flags &IOCB_DIRECT && !fsverity_active (inode))Brackets missing
Oops, will fix that. Thanks!
--D
Quoted 22 lines
Quoted 17 lines
fs/xfs/xfs_file.c +9
-1ret =xfs_file_dio_read (iocb, to); - else + else { +/* +* In case fs-verity is enabled, we also fallback to the +* buffered read from the direct read path. Therefore, +* IOCB_DIRECT is set and need to be cleared (see +* generic_file_read_iter()) +*/ + iocb->ki_flags &= ~IOCB_DIRECT ; ret =xfs_file_buffered_read (iocb, to); + }if (ret >0 )XFS_STATS_ADD (mp, xs_read_bytes, ret);Signature · 1 line
- Andrey
PATCH 25/40 xfs: widen flags argument to the xfs_iflags_* helpers
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
xfs_inode.i_flags is an unsigned long, so make these helpers take that as the flags argument instead of unsigned short. This is needed for the next patch.
--- fs/xfs/xfs_inode.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
fs/xfs/xfs_inode.h +7 -7
@@ -207,13 +207,13 @@ xfs_new_eof(struct xfs_inode *ip, xfs_fsize_t new_size)* i_flags helper functions */ static inline void -__xfs_iflags_set (xfs_inode_t *ip,unsigned short flags) +__xfs_iflags_set (xfs_inode_t *ip,unsigned long flags) { ip->i_flags |= flags; }static inline void -xfs_iflags_set (xfs_inode_t *ip,unsigned short flags) +xfs_iflags_set (xfs_inode_t *ip,unsigned long flags) {spin_lock (&ip->i_flags_lock);__xfs_iflags_set (ip, flags);
@@ -221,7 +221,7 @@ xfs_iflags_set(xfs_inode_t *ip, unsigned short flags) }static inline void -xfs_iflags_clear (xfs_inode_t *ip,unsigned short flags) +xfs_iflags_clear (xfs_inode_t *ip,unsigned long flags) {spin_lock (&ip->i_flags_lock); ip->i_flags &= ~flags;
@@ -229,13 +229,13 @@ xfs_iflags_clear(xfs_inode_t *ip, unsigned short flags) }static inline int -__xfs_iflags_test (xfs_inode_t *ip,unsigned short flags) +__xfs_iflags_test (xfs_inode_t *ip,unsigned long flags) {return (ip->i_flags & flags); }static inline int -xfs_iflags_test (xfs_inode_t *ip,unsigned short flags) +xfs_iflags_test (xfs_inode_t *ip,unsigned long flags) {int ret;spin_lock (&ip->i_flags_lock);
@@ -245,7 +245,7 @@ xfs_iflags_test(xfs_inode_t *ip, unsigned short flags) }static inline int -xfs_iflags_test_and_clear (xfs_inode_t *ip,unsigned short flags) +xfs_iflags_test_and_clear (xfs_inode_t *ip,unsigned long flags) {int ret;
@@ -258,7 +258,7 @@ xfs_iflags_test_and_clear(xfs_inode_t *ip, unsigned short flags) }static inline int -xfs_iflags_test_and_set (xfs_inode_t *ip,unsigned short flags) +xfs_iflags_test_and_set (xfs_inode_t *ip,unsigned long flags) {int ret;
PATCH 26/40 xfs: add fs-verity support
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Add integration with fs-verity. The XFS store fs-verity metadata in the extended file attributes. The metadata consist of verity descriptor and Merkle tree blocks.
The descriptor is stored under "vdesc" extended attribute. The Merkle tree blocks are stored under binary indexes which are offsets into the Merkle tree.
When fs-verity is enabled on an inode, the XFS_IVERITY_CONSTRUCTION flag is set meaning that the Merkle tree is being build. The initialization ends with storing of verity descriptor and setting inode on-disk flag (XFS_DIFLAG2_VERITY).
The verification on read is done in read path of iomap.
--- fs/xfs/Makefile | 1 fs/xfs/libxfs/xfs_attr.c | 13 + fs/xfs/libxfs/xfs_da_format.h | 32 +++ fs/xfs/libxfs/xfs_ondisk.h | 4 fs/xfs/xfs_icache.c | 4 fs/xfs/xfs_inode.h | 5 fs/xfs/xfs_super.c | 12 + fs/xfs/xfs_trace.h | 32 +++ fs/xfs/xfs_verity.c | 468 +++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_verity.h | 20 ++ 10 files changed, 591 insertions(+) create mode 100644 fs/xfs/xfs_verity.c create mode 100644 fs/xfs/xfs_verity.h
fs/xfs/Makefile +1 -0
@@ -130,6 +130,7 @@ xfs-$(CONFIG_XFS_POSIX_ACL) += xfs_acl.o xfs-$(CONFIG_SYSCTL) += xfs_sysctl.o xfs-$(CONFIG_COMPAT) += xfs_ioctl32.o xfs-$(CONFIG_EXPORTFS_BLOCK_OPS) += xfs_pnfs.o +xfs-$(CONFIG_FS_VERITY) += xfs_verity.o # notify failure ifeq ($(CONFIG_MEMORY_FAILURE),y)
fs/xfs/libxfs/xfs_attr.c +13 -0
@@ -27,6 +27,7 @@#include "xfs_attr_item.h" #include "xfs_xattr.h" #include "xfs_parent.h" +#include "xfs_verity.h" struct kmem_cache *xfs_attr_intent_cache;
@@ -1524,6 +1525,18 @@ xfs_attr_namecheck(if (flags &XFS_ATTR_PARENT )return xfs_parent_namecheck (mp, name, length, flags); +if (flags &XFS_ATTR_VERITY ) { +/* Merkle tree pages are stored under u64 indexes */ +if (length ==sizeof (struct xfs_verity_merkle_key )) +return true; + +/* Verity descriptor blocks are held in a named attribute. */ +if (length ==XFS_VERITY_DESCRIPTOR_NAME_LEN ) +return true; + +return false; + } +/* * MAXNAMELEN includes the trailing null, but (name/length) leave it * out, so use >= for the length check.
fs/xfs/libxfs/xfs_da_format.h +32 -0
@@ -914,4 +914,36 @@ struct xfs_parent_name_rec {*/ #define XFS_PARENT_DIRENT_NAME_MAX_SIZE (MAXNAMELEN - 1) +/* +* fs-verity attribute name format +* +* Merkle tree blocks are stored under extended attributes of the inode. The +* name of the attributes are byte offsets into merkle tree. +*/ +struct xfs_verity_merkle_key { +__be64 vi_merkleoff; +}; + +static inline void +xfs_verity_merkle_key_to_disk ( +struct xfs_verity_merkle_key *key, +uint64_t offset) +{ + key->vi_merkleoff =cpu_to_be64 (offset); +} + +static inline uint64_t +xfs_verity_merkle_key_from_disk ( +const void *attr_name) +{ +const struct xfs_verity_merkle_key *key = attr_name; + +return be64_to_cpu (key->vi_merkleoff); +} + + +/* ondisk xattr name used for the fsverity descriptor */ +#define XFS_VERITY_DESCRIPTOR_NAME "vdesc" +#define XFS_VERITY_DESCRIPTOR_NAME_LEN (sizeof(XFS_VERITY_DESCRIPTOR_NAME) - 1) +#endif /* __XFS_DA_FORMAT_H__ */
fs/xfs/libxfs/xfs_ondisk.h +4 -0
@@ -194,6 +194,10 @@ xfs_check_ondisk_structs(void)XFS_CHECK_VALUE (XFS_DQ_BIGTIME_EXPIRY_MIN <<XFS_DQ_BIGTIME_SHIFT ,4 );XFS_CHECK_VALUE (XFS_DQ_BIGTIME_EXPIRY_MAX <<XFS_DQ_BIGTIME_SHIFT ,16299260424LL ); + +/* fs-verity xattrs */ + XFS_CHECK_STRUCT_SIZE(struct xfs_verity_merkle_key, 8); + XFS_CHECK_VALUE(sizeof(XFS_VERITY_DESCRIPTOR_NAME), 6); }#endif /* __XFS_ONDISK_H */
fs/xfs/xfs_icache.c +4 -0
@@ -25,6 +25,7 @@#include "xfs_ag.h" #include "xfs_log_priv.h" #include "xfs_health.h" +#include "xfs_verity.h" #include <linux/iversion.h>
@@ -115,6 +116,7 @@ xfs_inode_alloc(spin_lock_init (&ip->i_ioend_lock); ip->i_next_unlinked =NULLAGINO ; ip->i_prev_unlinked =0 ; +xfs_verity_cache_init (ip);return ip; }
@@ -126,6 +128,8 @@ xfs_inode_free_callback( struct inode *inode = container_of(head, struct inode, i_rcu);struct xfs_inode *ip =XFS_I (inode); +xfs_verity_cache_destroy (ip); +switch (VFS_I (ip)->i_mode &S_IFMT ) {case S_IFREG :case S_IFDIR :
fs/xfs/xfs_inode.h +5 -0
@@ -92,6 +92,9 @@ typedef struct xfs_inode {spinlock_t i_ioend_lock;struct work_struct i_ioend_work;struct list_head i_ioend_list; +#ifdef CONFIG_FS_VERITY +struct xarray i_merkle_blocks; +#endif } xfs_inode_t;static inline bool xfs_inode_on_unlinked_list (const struct xfs_inode *ip)
@@ -361,6 +364,8 @@ static inline bool xfs_inode_has_large_extent_counts(struct xfs_inode *ip)*/ #define XFS_IREMAPPING (1U << 15) +#define XFS_VERITY_CONSTRUCTION (1U << 16)/* merkle tree construction */ +/* All inode state flags related to inode reclaim. */ #define XFS_ALL_IRECLAIM_FLAGS (XFS_IRECLAIMABLE | \ XFS_IRECLAIM | \
fs/xfs/xfs_super.c +12 -0
@@ -30,6 +30,7 @@#include "xfs_filestream.h" #include "xfs_quota.h" #include "xfs_sysfs.h" +#include "xfs_verity.h" #include "xfs_ondisk.h" #include "xfs_rmap_item.h" #include "xfs_refcount_item.h"
@@ -666,6 +667,8 @@ xfs_fs_destroy_inode(XFS_STATS_INC (ip->i_mount, vn_rele);XFS_STATS_INC (ip->i_mount, vn_remove);fsverity_cleanup_inode (inode); +if (IS_VERITY (inode)) +xfs_verity_cache_drop (ip);xfs_inode_mark_reclaimable (ip); }
@@ -1521,6 +1524,11 @@ xfs_fs_fill_super( sb->s_quota_types =QTYPE_MASK_USR |QTYPE_MASK_GRP |QTYPE_MASK_PRJ ;#endif sb->s_op = &xfs_super_operations; +#ifdef CONFIG_FS_VERITY + error =fsverity_set_ops (sb, &xfs_verity_ops); +if (error) +return error; +#endif /* * Delay mount work if the debug hook is set. This is debug
@@ -1730,6 +1738,10 @@ xfs_fs_fill_super( goto out_filestream_unmount; } +if (xfs_has_verity (mp)) +xfs_alert (mp, +"EXPERIMENTAL fs-verity feature in use. Use at your own risk!" ); + error =xfs_mountfs (mp);if (error) goto out_filestream_unmount;
fs/xfs/xfs_trace.h +32 -0
@@ -4767,6 +4767,38 @@ DEFINE_XFBTREE_FREESP_EVENT(xfbtree_alloc_block);DEFINE_XFBTREE_FREESP_EVENT (xfbtree_free_block);#endif /* CONFIG_XFS_BTREE_IN_MEM */ +#ifdef CONFIG_FS_VERITY +DECLARE_EVENT_CLASS (xfs_verity_cache_class, + TP_PROTO(struct xfs_inode *ip, unsigned long key, unsigned long caller_ip), +TP_ARGS (ip, key, caller_ip), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, ino) + __field(unsigned long, key) + __field(void *, caller_ip) + ), +TP_fast_assign ( + __entry->dev = ip->i_mount->m_super->s_dev; + __entry->ino = ip->i_ino; + __entry->key = key; + __entry->caller_ip = (void *)caller_ip; + ), +TP_printk ("dev %d:%d ino 0x%llx key 0x%lx caller %pS" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->ino, + __entry->key, + __entry->caller_ip) +) + +#define DEFINE_XFS_VERITY_CACHE_EVENT (name) \ +DEFINE_EVENT(xfs_verity_cache_class, name, \ + TP_PROTO(struct xfs_inode *ip, unsigned long key, unsigned long caller_ip), \ + TP_ARGS(ip, key, caller_ip)) +DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_load); +DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_store); +DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_drop); +#endif /* CONFIG_XFS_VERITY */ +#endif /* _TRACE_XFS_H */ #undef TRACE_INCLUDE_PATH
fs/xfs/xfs_verity.c new file +468 -0
468 lines not on this page · raw message
fs/xfs/xfs_verity.h new file +20 -0
@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2022 Red Hat, Inc. +*/ +#ifndef __XFS_VERITY_H__ +#define __XFS_VERITY_H__ + +#ifdef CONFIG_FS_VERITY +void xfs_verity_cache_init (struct xfs_inode *ip); +void xfs_verity_cache_drop (struct xfs_inode *ip); +void xfs_verity_cache_destroy (struct xfs_inode *ip); + +extern const struct fsverity_operations xfs_verity_ops; +#else +# define xfs_verity_cache_init (ip) ((void)0) +# define xfs_verity_cache_drop (ip) ((void)0) +# define xfs_verity_cache_destroy (ip) ((void)0) +#endif /* CONFIG_FS_VERITY */ + +#endif /* __XFS_VERITY_H__ */
Re: [PATCH 26/40] xfs: add fs-verity support
Just skimming over the series from the little I've followed from the last rounds (sorry, to busy with various projects):
fs/xfs/xfs_inode.h typedef struct xfs_inode { · line 97
Quoted 9 lines
fs/xfs/xfs_inode.h +3
-0@@ -92,6 +92,9 @@ typedef struct xfs_inode {spinlock_t i_ioend_lock;struct work_struct i_ioend_work;struct list_head i_ioend_list; +#ifdef CONFIG_FS_VERITY +struct xarray i_merkle_blocks; +#endif
This looks like very much a blocker to me. Adding a 16 byte field to struct inode that is used just for a few read-only-ish files on select few file systems doesn't seem very efficient. Given that we very rarely update it and thus concurrency on the write side doesn't matter much, is there any way we could get a away with a fs-wide lookup data structure and avoid this?
Re: [PATCH 26/40] xfs: add fs-verity support
Quoted 19 lines · Christoph Hellwig
Just skimming over the series from the little I've followed from the last rounds (sorry, to busy with various projects):
fs/xfs/xfs_inode.h typedef struct xfs_inode { · line 97
Quoted 9 lines
fs/xfs/xfs_inode.h +3
-0@@ -92,6 +92,9 @@ typedef struct xfs_inode {spinlock_t i_ioend_lock;struct work_struct i_ioend_work;struct list_head i_ioend_list; +#ifdef CONFIG_FS_VERITY +struct xarray i_merkle_blocks; +#endif This looks like very much a blocker to me. Adding a 16 byte field to struct inode that is used just for a few read-only-ish files on select few file systems doesn't seem very efficient. Given that we very rarely update it and thus concurrency on the write side doesn't matter much, is there any way we could get a away with a fs-wide lookup data structure and avoid this?
Only if you can hand a 128-bit key to an xarray. ;)
But in all seriousness, we could have a per-AG xarray that maps xfs_agino_t to this xarray of merkle blocks. That would be nice in that we don't have to touch xfs_icache.c for the shrinker at all.
--D
Re: [PATCH 26/40] xfs: add fs-verity support
Quoted 6 lines · Darrick J. Wong
Quoted 4 lines
select few file systems doesn't seem very efficient. Given that we very rarely update it and thus concurrency on the write side doesn't matter much, is there any way we could get a away with a fs-wide lookup data structure and avoid this?
Only if you can hand a 128-bit key to an xarray. ;)
That's why I said lookup data structure and not xarray. It would probably work with an rthashtable.
Quoted 3 lines
But in all seriousness, we could have a per-AG xarray that maps
xfs_agino_tto this xarray of merkle blocks. That would be nice in that we don't have to touchxfs_icache.cfor the shrinker at all.
I have to admit I haven't read the code enough to even know from what to what it maps. I'll try to get a bit deeper into the code, time permitting.
Re: [PATCH 26/40] xfs: add fs-verity support
Quoted 10 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
Quoted 4 lines
select few file systems doesn't seem very efficient. Given that we very rarely update it and thus concurrency on the write side doesn't matter much, is there any way we could get a away with a fs-wide lookup data structure and avoid this?
Only if you can hand a 128-bit key to an xarray. ;)
That's why I said lookup data structure and not xarray. It would probably work with an rthashtable.
Heh. Well willy gave me the idea to use an xarray so I'd then know how to use an xarray. :)
Quoted 7 lines
Quoted 3 lines
But in all seriousness, we could have a per-AG xarray that maps
xfs_agino_tto this xarray of merkle blocks. That would be nice in that we don't have to touchxfs_icache.cfor the shrinker at all.I have to admit I haven't read the code enough to even know from what to what it maps. I'll try to get a bit deeper into the code, time permitting.
fsverity flattens the blocks of the merkle tree into a linear u64 byte-address space. The accesses are in those same units, which is why I end up shifting so that the xarray entries for adjacent blocks are contiguous. Kind of like what the address_space does.
--D
PATCH 27/40 xfs: create a per-mount shrinker for verity inodes merkle tree blocks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a shrinker for an entire filesystem that will walk the inodes looking for inodes that are caching merkle tree blocks, and invoke shrink functions on that cache. The actual details of shrinking merkle tree caches are left for subsequent patches.
--- fs/xfs/xfs_mount.c | 10 ++++++- fs/xfs/xfs_mount.h | 6 ++++ fs/xfs/xfs_trace.h | 20 +++++++++++++ fs/xfs/xfs_verity.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_verity.h | 5 +++ 5 files changed, 117 insertions(+), 1 deletion(-)
fs/xfs/xfs_mount.c +9 -1
@@ -34,6 +34,7 @@#include "xfs_health.h" #include "xfs_trace.h" #include "xfs_ag.h" +#include "xfs_verity.h" #include "scrub/stats.h" static DEFINE_MUTEX (xfs_uuid_table_mutex);
@@ -813,6 +814,10 @@ xfs_mountfs(if (error) goto out_fail_wait; + error =xfs_verity_register_shrinker (mp); +if (error) + goto out_inodegc_shrinker; +/* * Log's mount-time initialization. The first part of recovery can place * some items on the AIL, to be handled when recovery is finished or
@@ -823,7 +828,7 @@ xfs_mountfs( XFS_FSB_TO_BB(mp, sbp->sb_logblocks));if (error) {xfs_warn (mp,"log mount failed" ); - goto out_inodegc_shrinker; + goto out_verity_shrinker; }/* Enable background inode inactivation workers. */
@@ -1018,6 +1023,8 @@ xfs_mountfs(xfs_unmount_flush_inodes (mp); out_log_dealloc:xfs_log_mount_cancel (mp); + out_verity_shrinker: +xfs_verity_unregister_shrinker (mp); out_inodegc_shrinker:shrinker_free (mp->m_inodegc_shrinker); out_fail_wait:
@@ -1100,6 +1107,7 @@ xfs_unmountfs(#if defined(DEBUG )xfs_errortag_clearall (mp);#endif +xfs_verity_unregister_shrinker (mp);shrinker_free (mp->m_inodegc_shrinker);xfs_free_perag (mp);
fs/xfs/xfs_mount.h +6 -0
@@ -255,6 +255,12 @@ typedef struct xfs_mount {/* Hook to feed dirent updates to an active online repair. */ struct xfs_hooks m_dir_update_hooks; + +#ifdef CONFIG_FS_VERITY +/* shrinker and cached blocks count for merkle trees */ +struct shrinker *m_verity_shrinker; +struct percpu_counter m_verity_blocks; +#endif } xfs_mount_t;#define M_IGEO (mp) (&(mp)->m_ino_geo)
fs/xfs/xfs_trace.h +20 -0
@@ -4797,6 +4797,26 @@ DEFINE_EVENT(xfs_verity_cache_class, name, \DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_load);DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_store);DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_drop); + +TRACE_EVENT (xfs_verity_shrinker_count, + TP_PROTO(struct xfs_mount *mp, unsigned long long count, + unsigned long caller_ip), +TP_ARGS (mp, count, caller_ip), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(unsigned long long, count) + __field(void *, caller_ip) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->count = count; + __entry->caller_ip = (void *)caller_ip; + ), +TP_printk ("dev %d:%d count %llu caller %pS" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->count, + __entry->caller_ip) +)#endif /* CONFIG_XFS_VERITY */ #endif /* _TRACE_XFS_H */
fs/xfs/xfs_verity.c +77 -0
89 lines not on this page · raw message
fs/xfs/xfs_verity.h +5 -0
@@ -10,11 +10,16 @@ void xfs_verity_cache_init(struct xfs_inode *ip);void xfs_verity_cache_drop (struct xfs_inode *ip);void xfs_verity_cache_destroy (struct xfs_inode *ip); +int xfs_verity_register_shrinker (struct xfs_mount *mp); +void xfs_verity_unregister_shrinker (struct xfs_mount *mp); +extern const struct fsverity_operations xfs_verity_ops;#else # define xfs_verity_cache_init (ip) ((void)0)# define xfs_verity_cache_drop (ip) ((void)0)# define xfs_verity_cache_destroy (ip) ((void)0) +# define xfs_verity_register_shrinker (mp) (0) +# define xfs_verity_unregister_shrinker (mp) ((void)0)#endif /* CONFIG_FS_VERITY */ #endif /* __XFS_VERITY_H__ */
PATCH 28/40 xfs: create an icache tag for files with cached merkle tree blocks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a radix tree tag for the inode cache so that merkle tree block shrinkers can find verity inodes quickly.
--- fs/xfs/xfs_icache.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_icache.h | 8 +++++ fs/xfs/xfs_trace.h | 23 ++++++++++++++ fs/xfs/xfs_verity.c | 30 ++++++++++++++++++- fs/xfs/xfs_verity.h | 4 +++ 5 files changed, 145 insertions(+), 1 deletion(-)
fs/xfs/xfs_icache.c +81 -0
@@ -35,6 +35,8 @@#define XFS_ICI_RECLAIM_TAG 0/* Inode has speculative preallocations (posteof or cow) to clean. */ #define XFS_ICI_BLOCKGC_TAG 1 +/* Inode has incore merkle tree blocks */ +#define XFS_ICI_VERITY_TAG 2/* * The goal for walking incore inodes. These can correspond with incore inode
@@ -44,6 +46,7 @@ enum xfs_icwalk_goal {/* Goals directly associated with tagged inodes. */ XFS_ICWALK_BLOCKGC =XFS_ICI_BLOCKGC_TAG ,XFS_ICWALK_RECLAIM =XFS_ICI_RECLAIM_TAG , + XFS_ICWALK_VERITY = XFS_ICI_VERITY_TAG, }; static int xfs_icwalk(struct xfs_mount *mp,
@@ -1606,6 +1609,7 @@ xfs_icwalk_igrab( {switch (goal) {case XFS_ICWALK_BLOCKGC : +case XFS_ICWALK_VERITY :return xfs_blockgc_igrab (ip);case XFS_ICWALK_RECLAIM :return xfs_reclaim_igrab (ip, icw);
@@ -1634,6 +1638,9 @@ xfs_icwalk_process_inode(case XFS_ICWALK_RECLAIM :xfs_reclaim_inode (ip, pag);break ; +case XFS_ICWALK_VERITY : + error =xfs_verity_scan_inode (ip, icw); +break ; }return error; }
@@ -1750,6 +1757,80 @@ xfs_icwalk_ag(return last_error; } +#ifdef CONFIG_FS_VERITY +/* Mark this inode as having cached merkle tree blocks */ +void +xfs_inode_set_verity_tag ( +struct xfs_inode *ip) +{ +struct xfs_mount *mp = ip->i_mount; +struct xfs_perag *pag; + + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ip->i_ino)); +if (!pag) +return ; + +spin_lock (&pag->pag_ici_lock); +xfs_perag_set_inode_tag (pag,XFS_INO_TO_AGINO (mp, ip->i_ino), +XFS_ICI_VERITY_TAG ); +spin_unlock (&pag->pag_ici_lock); +xfs_perag_put (pag); +} + +/* Mark this inode as not having cached merkle tree blocks */ +void +xfs_inode_clear_verity_tag ( +struct xfs_inode *ip) +{ +struct xfs_mount *mp = ip->i_mount; +struct xfs_perag *pag; + + pag =xfs_perag_get (mp,XFS_INO_TO_AGNO (mp, ip->i_ino)); +if (!pag) +return ; + +spin_lock (&pag->pag_ici_lock); +xfs_perag_clear_inode_tag (pag,XFS_INO_TO_AGINO (mp, ip->i_ino), +XFS_ICI_VERITY_TAG ); +spin_unlock (&pag->pag_ici_lock); +xfs_perag_put (pag); +} + +/* Walk all the verity inodes in the filesystem. */ +int +xfs_icwalk_verity ( +struct xfs_mount *mp, +struct xfs_icwalk *icw) +{ +struct xfs_perag *pag; +xfs_agnumber_t agno =0 ; +int error =0 ; + +for_each_perag_tag (mp, agno, pag,XFS_ICWALK_VERITY ) { + error =xfs_icwalk_ag (pag,XFS_ICWALK_VERITY , icw); +if (error) +break ; + +if ((icw->icw_flags &XFS_ICWALK_FLAG_SCAN_LIMIT ) && + icw->icw_scan_limit <=0 ) { +xfs_perag_rele (pag); +break ; + } + } + +return error; +} + +/* Stop a verity incore walk scan. */ +void +xfs_icwalk_verity_stop ( +struct xfs_icwalk *icw) +{ + icw->icw_flags |=XFS_ICWALK_FLAG_SCAN_LIMIT ; + icw->icw_scan_limit =-1 ; +} +#endif /* CONFIG_FS_VERITY */ +/* Walk all incore inodes to achieve a given goal. */ static int xfs_icwalk(
fs/xfs/xfs_icache.h +8 -0
@@ -81,4 +81,12 @@ void xfs_inodegc_stop(struct xfs_mount *mp);void xfs_inodegc_start (struct xfs_mount *mp);int xfs_inodegc_register_shrinker (struct xfs_mount *mp); +#ifdef CONFIG_FS_VERITY +int xfs_icwalk_verity (struct xfs_mount *mp,struct xfs_icwalk *icw); +void xfs_icwalk_verity_stop (struct xfs_icwalk *icw); + +void xfs_inode_set_verity_tag (struct xfs_inode *ip); +void xfs_inode_clear_verity_tag (struct xfs_inode *ip); +#endif /* CONFIG_FS_VERITY */ +#endif
fs/xfs/xfs_trace.h +23 -0
@@ -4817,6 +4817,29 @@ TRACE_EVENT(xfs_verity_shrinker_count, __entry->count, __entry->caller_ip) ) + +TRACE_EVENT (xfs_verity_shrinker_scan, + TP_PROTO(struct xfs_mount *mp, unsigned long scanned, + unsigned long freed, unsigned long caller_ip), +TP_ARGS (mp, scanned, freed, caller_ip), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(unsigned long, scanned) + __field(unsigned long, freed) + __field(void *, caller_ip) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->scanned = scanned; + __entry->freed = freed; + __entry->caller_ip = (void *)caller_ip; + ), +TP_printk ("dev %d:%d scanned %lu freed %lu caller %pS" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->scanned, + __entry->freed, + __entry->caller_ip) +)#endif /* CONFIG_XFS_VERITY */ #endif /* _TRACE_XFS_H */
fs/xfs/xfs_verity.c +29 -1
@@ -226,18 +226,46 @@ xfs_verity_shrinker_count(return min_t (s64,ULONG_MAX , count); } +struct xfs_verity_scan { +struct xfs_icwalk icw; +struct shrink_control *sc; + +unsigned long scanned; +unsigned long freed; +}; + +/* Scan an inode as part of a verity scan. */ +int +xfs_verity_scan_inode ( +struct xfs_inode *ip, +struct xfs_icwalk *icw) +{ +xfs_irele (ip); +return 0 ; +} +/* Actually try to reclaim merkle tree blocks. */ static unsigned long xfs_verity_shrinker_scan (struct shrinker *shrink,struct shrink_control *sc) { +struct xfs_verity_scan vs = { + .sc = sc, + };struct xfs_mount *mp = shrink->private_data; +int error;if (!xfs_has_verity (mp))return SHRINK_STOP ; -return 0 ; + error =xfs_icwalk_verity (mp, &vs.icw); +if (error) +xfs_alert (mp,"%s: verity scan failed, error %d" , __func__, + error); + +trace_xfs_verity_shrinker_scan (mp, vs.scanned, vs.freed, _RET_IP_); +return vs.freed; }/* Register a shrinker so we can release cached merkle tree blocks. */
fs/xfs/xfs_verity.h +4 -0
@@ -13,6 +13,9 @@ void xfs_verity_cache_destroy(struct xfs_inode *ip);int xfs_verity_register_shrinker (struct xfs_mount *mp);void xfs_verity_unregister_shrinker (struct xfs_mount *mp); +struct xfs_icwalk ; +int xfs_verity_scan_inode (struct xfs_inode *ip,struct xfs_icwalk *icw); +extern const struct fsverity_operations xfs_verity_ops;#else # define xfs_verity_cache_init (ip) ((void)0)
@@ -20,6 +23,7 @@ extern const struct fsverity_operations xfs_verity_ops;# define xfs_verity_cache_destroy (ip) ((void)0)# define xfs_verity_register_shrinker (mp) (0)# define xfs_verity_unregister_shrinker (mp) ((void)0) +# define xfs_verity_scan_inode (ip, icw) (0)#endif /* CONFIG_FS_VERITY */ #endif /* __XFS_VERITY_H__ */
PATCH 29/40 xfs: shrink verity blob cache
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add some shrinkers so that reclaim can free cached merkle tree blocks when memory is tight. We add a shrinkref variable to bias reclaim against freeing the upper levels of the merkle tree in the hope of maintaining read performance.
--- fs/xfs/xfs_trace.h | 1 + fs/xfs/xfs_verity.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 88 insertions(+)
fs/xfs/xfs_trace.h +1 -0
@@ -4797,6 +4797,7 @@ DEFINE_EVENT(xfs_verity_cache_class, name, \DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_load);DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_store);DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_drop); +DEFINE_XFS_VERITY_CACHE_EVENT (xfs_verity_cache_reclaim); TRACE_EVENT(xfs_verity_shrinker_count, TP_PROTO(struct xfs_mount *mp, unsigned long long count,
fs/xfs/xfs_verity.c +87 -0
153 lines not on this page · raw message
PATCH 30/40 xfs: clean up stale fsverity metadata before starting
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Before we let fsverity begin writing merkle tree blocks to the file, let's perform a minor effort to clean up any stale metadata from a previous attempt to enable fsverity. This can only happen if the system crashes /and/ the file shrinks, which is unlikely. But we could do a better job of cleaning up anyway.
--- fs/xfs/xfs_verity.c | 42 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 40 insertions(+), 2 deletions(-)
fs/xfs/xfs_verity.c +40 -2
@@ -413,6 +413,44 @@ xfs_verity_get_descriptor(return args.valuelen; } +/* +* Clear out old fsverity metadata before we start building a new one. This +* could happen if, say, we crashed while building fsverity data. +*/ +static int +xfs_verity_drop_old_metadata ( +struct xfs_inode *ip, +u64 new_tree_size, +unsigned int tree_blocksize) +{ +struct xfs_verity_merkle_key name; +struct xfs_da_args args = { + .dp = ip, + .whichfork =XFS_ATTR_FORK , + .attr_filter =XFS_ATTR_VERITY , + .op_flags =XFS_DA_OP_REMOVE , + .name = (const uint8_t *)&name, + .namelen =sizeof (struct xfs_verity_merkle_key ), +/* NULL value make xfs_attr_set remove the attr */ + .value =NULL , + }; +u64 offset; +int error =0 ; + +/* +* Delete as many merkle tree blocks in increasing blkno order until we +* don't find any more. That ought to be good enough for avoiding +* dead bloat without excessive runtime. +*/ +for (offset = new_tree_size; !error; offset += tree_blocksize) { +xfs_verity_merkle_key_to_disk (&name, offset); + error =xfs_attr_set (&args); + } +if (error == -ENOATTR ) +return 0 ; +return error; +} + static int xfs_verity_begin_enable( struct file *filp,
@@ -421,7 +459,6 @@ xfs_verity_begin_enable( {struct inode *inode =file_inode (filp);struct xfs_inode *ip =XFS_I (inode); -int error =0 ;xfs_assert_ilocked (ip,XFS_IOLOCK_EXCL );
@@ -431,7 +468,8 @@ xfs_verity_begin_enable(if (xfs_iflags_test_and_set (ip,XFS_VERITY_CONSTRUCTION ))return -EBUSY ; -return error; +return xfs_verity_drop_old_metadata (ip, merkle_tree_size, + tree_blocksize); } static int
Re: [PATCH 30/40] xfs: clean up stale fsverity metadata before starting
Quoted 9 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Before we let fsverity begin writing merkle tree blocks to the file, let's perform a minor effort to clean up any stale metadata from a previous attempt to enable fsverity. This can only happen if the system crashes /and/ the file shrinks, which is unlikely. But we could do a better job of cleaning up anyway.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good to me:
Quoted 73 lines
--- fs/xfs/xfs_verity.c | 42 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 40 insertions(+), 2 deletions(-)fs/xfs/xfs_verity.c +40
-2@@ -413,6 +413,44 @@ xfs_verity_get_descriptor(return args.valuelen; } +/* +* Clear out old fsverity metadata before we start building a new one. This +* could happen if, say, we crashed while building fsverity data. +*/ +static int +xfs_verity_drop_old_metadata ( +struct xfs_inode *ip, +u64 new_tree_size, +unsigned int tree_blocksize) +{ +struct xfs_verity_merkle_key name; +struct xfs_da_args args = { + .dp = ip, + .whichfork =XFS_ATTR_FORK , + .attr_filter =XFS_ATTR_VERITY , + .op_flags =XFS_DA_OP_REMOVE , + .name = (const uint8_t *)&name, + .namelen =sizeof (struct xfs_verity_merkle_key ), +/* NULL value make xfs_attr_set remove the attr */ + .value =NULL , + }; +u64 offset; +int error =0 ; + +/* +* Delete as many merkle tree blocks in increasing blkno order until we +* don't find any more. That ought to be good enough for avoiding +* dead bloat without excessive runtime. +*/ +for (offset = new_tree_size; !error; offset += tree_blocksize) { +xfs_verity_merkle_key_to_disk (&name, offset); + error =xfs_attr_set (&args); + } +if (error == -ENOATTR ) +return 0 ; +return error; +} + static int xfs_verity_begin_enable( struct file *filp,@@ -421,7 +459,6 @@ xfs_verity_begin_enable( {struct inode *inode =file_inode (filp);struct xfs_inode *ip =XFS_I (inode); -int error =0 ;xfs_assert_ilocked (ip,XFS_IOLOCK_EXCL );@@ -431,7 +468,8 @@ xfs_verity_begin_enable(if (xfs_iflags_test_and_set (ip,XFS_VERITY_CONSTRUCTION ))return -EBUSY ; -return error; +return xfs_verity_drop_old_metadata (ip, merkle_tree_size, + tree_blocksize); } static int
Signature · 1 line
- Andrey
PATCH 31/40 xfs: better reporting and error handling in xfs_drop_merkle_tree
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
xfs_drop_merkle_tree is responsible for removing the fsverity metadata after a failed attempt to enable fsverity for a file. However, if the enablement process fails before the verity descriptor is written to the file, the cleanup function will trip the WARN_ON. The error code in that case is ENOATTR, which isn't worth logging about.
Fix that return code handling, fix the tree block removal loop not to return early with ENOATTR, and improve the logging so that we actually capture what kind of error occurred.
--- fs/xfs/xfs_verity.c | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-)
fs/xfs/xfs_verity.c +18 -7
@@ -472,15 +472,14 @@ xfs_verity_begin_enable( tree_blocksize); } +/* Try to remove all the fsverity metadata after a failed enablement. */ static int -xfs_drop_merkle_tree ( +xfs_verity_drop_incomplete_tree (struct xfs_inode *ip,u64 merkle_tree_size,unsigned int tree_blocksize) {struct xfs_verity_merkle_key name; -int error =0 ; -u64 offset =0 ;struct xfs_da_args args = { .dp = ip, .whichfork =XFS_ATTR_FORK ,
@@ -491,6 +490,8 @@ xfs_drop_merkle_tree(/* NULL value make xfs_attr_set remove the attr */ .value = NULL, }; +u64 offset; +int error;if (!merkle_tree_size)return 0 ;
@@ -498,6 +499,8 @@ xfs_drop_merkle_tree(for (offset =0 ; offset < merkle_tree_size; offset += tree_blocksize) {xfs_verity_merkle_key_to_disk (&name, offset); error =xfs_attr_set (&args); +if (error == -ENOATTR ) + error =0 ;if (error)return error; }
@@ -505,7 +508,8 @@ xfs_drop_merkle_tree( args.name = (const uint8_t *)XFS_VERITY_DESCRIPTOR_NAME ; args.namelen =XFS_VERITY_DESCRIPTOR_NAME_LEN ; error =xfs_attr_set (&args); - +if (error == -ENOATTR ) +return 0 ;return error; }
@@ -564,9 +568,16 @@ xfs_verity_end_enable( inode->i_flags |=S_VERITY ; out: -if (error) -WARN_ON_ONCE (xfs_drop_merkle_tree (ip, merkle_tree_size, - tree_blocksize)); +if (error) { +int error2; + + error2 =xfs_verity_drop_incomplete_tree (ip, merkle_tree_size, + tree_blocksize); +if (error2) +xfs_alert (ip->i_mount, +"ino 0x%llx failed to clean up new fsverity metadata, err %d" , + ip->i_ino, error2); + }xfs_iflags_clear (ip,XFS_VERITY_CONSTRUCTION );return error;
Re: [PATCH 31/40] xfs: better reporting and error handling in xfs_drop_merkle_tree
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
xfs_drop_merkle_treeis responsible for removing the fsverity metadata after a failed attempt to enable fsverity for a file. However, if the enablement process fails before the verity descriptor is written to the file, the cleanup function will trip theWARN_ON. The error code in that case is ENOATTR, which isn't worth logging about.
Quoted 5 lines
Fix that return code handling, fix the tree block removal loop not to return early with ENOATTR, and improve the logging so that we actually capture what kind of error occurred.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good to me:
Quoted 76 lines
--- fs/xfs/xfs_verity.c | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-)fs/xfs/xfs_verity.c +18
-7@@ -472,15 +472,14 @@ xfs_verity_begin_enable( tree_blocksize); } +/* Try to remove all the fsverity metadata after a failed enablement. */ static int -xfs_drop_merkle_tree ( +xfs_verity_drop_incomplete_tree (struct xfs_inode *ip,u64 merkle_tree_size,unsigned int tree_blocksize) {struct xfs_verity_merkle_key name; -int error =0 ; -u64 offset =0 ;struct xfs_da_args args = { .dp = ip, .whichfork =XFS_ATTR_FORK ,@@ -491,6 +490,8 @@ xfs_drop_merkle_tree(/* NULL value make xfs_attr_set remove the attr */ .value = NULL, }; +u64 offset; +int error;if (!merkle_tree_size)return 0 ;@@ -498,6 +499,8 @@ xfs_drop_merkle_tree(for (offset =0 ; offset < merkle_tree_size; offset += tree_blocksize) {xfs_verity_merkle_key_to_disk (&name, offset); error =xfs_attr_set (&args); +if (error == -ENOATTR ) + error =0 ;if (error)return error; }@@ -505,7 +508,8 @@ xfs_drop_merkle_tree( args.name = (const uint8_t *)XFS_VERITY_DESCRIPTOR_NAME ; args.namelen =XFS_VERITY_DESCRIPTOR_NAME_LEN ; error =xfs_attr_set (&args); - +if (error == -ENOATTR ) +return 0 ;return error; }@@ -564,9 +568,16 @@ xfs_verity_end_enable( inode->i_flags |=S_VERITY ; out: -if (error) -WARN_ON_ONCE (xfs_drop_merkle_tree (ip, merkle_tree_size, - tree_blocksize)); +if (error) { +int error2; + + error2 =xfs_verity_drop_incomplete_tree (ip, merkle_tree_size, + tree_blocksize); +if (error2) +xfs_alert (ip->i_mount, +"ino 0x%llx failed to clean up new fsverity metadata, err %d" , + ip->i_ino, error2); + }xfs_iflags_clear (ip,XFS_VERITY_CONSTRUCTION );return error;
Signature · 1 line
- Andrey
PATCH 32/40 xfs: make scrub aware of verity dinode flag
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
fs-verity adds new inode flag which causes scrub to fail as it is not yet known.
--- fs/xfs/scrub/attr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/xfs/scrub/attr.c +1 -1
@@ -494,7 +494,7 @@ xchk_xattr_rec(/* Retrieve the entry and check it. */ hash =be32_to_cpu (ent->hashval); badflags = ~(XFS_ATTR_LOCAL |XFS_ATTR_ROOT |XFS_ATTR_SECURE | -XFS_ATTR_INCOMPLETE |XFS_ATTR_PARENT ); +XFS_ATTR_INCOMPLETE |XFS_ATTR_PARENT |XFS_ATTR_VERITY );if ((ent->flags & badflags) !=0 )xchk_da_set_corrupt (ds, level);if (ent->flags &XFS_ATTR_LOCAL ) {
PATCH 33/40 xfs: add fs-verity ioctls
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Add fs-verity ioctls to enable, dump metadata (descriptor and Merkle tree pages) and obtain file's digest.
--- fs/xfs/xfs_ioctl.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
fs/xfs/xfs_ioctl.c +16 -0
@@ -43,6 +43,7 @@#include <linux/mount.h> #include <linux/namei.h> #include <linux/fileattr.h> +#include <linux/fsverity.h> /* * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
@@ -2174,6 +2175,21 @@ xfs_file_ioctl(return error; } +case FS_IOC_ENABLE_VERITY : +if (!xfs_has_verity (mp)) +return -EOPNOTSUPP ; +return fsverity_ioctl_enable (filp, arg); + +case FS_IOC_MEASURE_VERITY : +if (!xfs_has_verity (mp)) +return -EOPNOTSUPP ; +return fsverity_ioctl_measure (filp, arg); + +case FS_IOC_READ_VERITY_METADATA : +if (!xfs_has_verity (mp)) +return -EOPNOTSUPP ; +return fsverity_ioctl_read_metadata (filp, arg); +default :return -ENOTTY ; }
PATCH 34/40 xfs: advertise fs-verity being available on filesystem
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Advertise that this filesystem supports fsverity.
--- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_sb.c | 2 ++ 2 files changed, 3 insertions(+)
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -239,6 +239,7 @@ typedef struct xfs_fsop_resblks {#define XFS_FSOP_GEOM_FLAGS_BIGTIME (1 << 21)/* 64-bit nsec timestamps */ #define XFS_FSOP_GEOM_FLAGS_INOBTCNT (1 << 22)/* inobt btree counter */ #define XFS_FSOP_GEOM_FLAGS_NREXT64 (1 << 23)/* large extent counters */ +#define XFS_FSOP_GEOM_FLAGS_VERITY (1 << 24)/* fs-verity */ /* * Minimum and maximum sizes need for growth checks.
fs/xfs/libxfs/xfs_sb.c +2 -0
@@ -1260,6 +1260,8 @@ xfs_fs_geometry( }if (xfs_has_large_extent_counts (mp)) geo->flags |=XFS_FSOP_GEOM_FLAGS_NREXT64 ; +if (xfs_has_verity (mp)) + geo->flags |=XFS_FSOP_GEOM_FLAGS_VERITY ; geo->rtsectsize = sbp->sb_blocksize; geo->dirblocksize =xfs_dir2_dirblock_bytes (sbp);
PATCH 35/40 xfs: teach online repair to evaluate fsverity xattrs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Teach online repair to check for unused fsverity metadata and purge it on reconstruction.
--- fs/xfs/scrub/attr.c | 102 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/attr.h | 4 ++ fs/xfs/scrub/common.c | 27 +++++++++++++ 3 files changed, 133 insertions(+)
fs/xfs/scrub/attr.c +102 -0
@@ -21,6 +21,8 @@#include "scrub/dabtree.h" #include "scrub/attr.h" +#include <linux/fsverity.h> +/* Free the buffers linked from the xattr buffer. */ static void xchk_xattr_buf_cleanup(
@@ -135,6 +137,91 @@ xchk_setup_xattr(return xchk_setup_inode_contents (sc,0 ); } +#ifdef CONFIG_FS_VERITY +/* Extract merkle tree geometry from incore information. */ +static int +xchk_xattr_extract_verity ( +struct xfs_scrub *sc) +{ +struct xchk_xattr_buf *ab = sc->buf; + +/* setup should have allocated the buffer */ +if (!ab) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +return fsverity_merkle_tree_geometry (VFS_I (sc->ip), + &ab->merkle_blocksize, &ab->merkle_tree_size); +} + +/* Check the merkle tree xattrs. */ +STATIC void +xchk_xattr_verity ( +struct xfs_scrub *sc, +xfs_dablk_t blkno, +const unsigned char *name, +unsigned int namelen, +unsigned int valuelen) +{ +struct xchk_xattr_buf *ab = sc->buf; + +/* Non-verity filesystems should never have verity xattrs. */ +if (!xfs_has_verity (sc->mp)) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } + +/* +* Any verity metadata on a non-verity file are leftovers from a +* previous attempt to enable verity. +*/ +if (!IS_VERITY (VFS_I (sc->ip))) { +xchk_ino_set_preen (sc, sc->ip->i_ino); +return ; + } + +switch (namelen) { +case sizeof (struct xfs_verity_merkle_key ): +/* Oversized blocks are not allowed */ +if (valuelen > ab->merkle_blocksize) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } +break ; +case XFS_VERITY_DESCRIPTOR_NAME_LEN : +/* Has to match the descriptor xattr name */ +if (memcmp (name,XFS_VERITY_DESCRIPTOR_NAME , namelen)) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); + } +return ; +default : +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } + +/* +* Merkle tree blocks beyond the end of the tree are leftovers from +* a previous failed attempt to enable verity. +*/ +if (xfs_verity_merkle_key_from_disk (name) >= ab->merkle_tree_size) +xchk_ino_set_preen (sc, sc->ip->i_ino); +} +#else +# define xchk_xattr_extract_verity (sc) (0) + +static void +xchk_xattr_verity ( +struct xfs_scrub *sc, +xfs_dablk_t blkno, +const unsigned char *name, +unsigned int namelen) +{ +/* Should never see verity xattrs when verity is not enabled. */ +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +} +#endif /* CONFIG_FS_VERITY */ +/* Extended Attributes */ struct xchk_xattr {
@@ -194,6 +281,15 @@ xchk_xattr_listent( goto fail_xref; } +/* Check verity xattr geometry */ +if (flags &XFS_ATTR_VERITY ) { +xchk_xattr_verity (sx->sc, args.blkno, name, namelen, valuelen); +if (sx->sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT ) { + context->seen_enough =1 ; +return ; + } + } +/* Does this name make sense? */ if (!xfs_attr_namecheck (sx->sc->mp, name, namelen, flags)) {xchk_fblock_set_corrupt (sx->sc,XFS_ATTR_FORK , args.blkno);
@@ -611,6 +707,12 @@ xchk_xattr(if (error)return error; +if (IS_VERITY (VFS_I (sc->ip))) { + error =xchk_xattr_extract_verity (sc); +if (error) +return error; + } +/* Check the physical structure of the xattr. */ if (sc->ip->i_af.if_format ==XFS_DINODE_FMT_LOCAL ) error =xchk_xattr_check_sf (sc);
fs/xfs/scrub/attr.h +4 -0
@@ -19,6 +19,10 @@ struct xchk_xattr_buf {/* Memory buffer used to extract xattr values. */ void *value;size_t value_sz; + +/* Geometry of the merkle tree attached to this verity file. */ +u64 merkle_tree_size; + unsigned int merkle_blocksize; };#endif /* __XFS_SCRUB_ATTR_H__ */
fs/xfs/scrub/common.c +27 -0
@@ -37,6 +37,8 @@#include "scrub/repair.h" #include "scrub/health.h" +#include <linux/fsverity.h> +/* Common code for the metadata scrubbers. */ /*
@@ -1073,6 +1075,25 @@ xchk_irele(xfs_irele (ip); } +#ifdef CONFIG_FS_VERITY +/* +* Make sure the fsverity information is attached, so we don't have to do that +* later after taking locks. +*/ +static inline int +xchk_setup_fsverity ( +struct xfs_scrub *sc) +{ +unsigned int dontcare; +u64 alsodontcare; + +return fsverity_merkle_tree_geometry (VFS_I (sc->ip), + &dontcare, &alsodontcare); +} +#else +# define xchk_setup_fsverity (sc) (0) +#endif +/* * Set us up to scrub metadata mapped by a file's fork. Callers must not use * this to operate on user-accessible regular file data because the MMAPLOCK is
@@ -1092,6 +1113,12 @@ xchk_setup_inode_contents(/* Lock the inode so the VFS cannot touch this file. */ xchk_ilock (sc,XFS_IOLOCK_EXCL ); +if (IS_VERITY (VFS_I (sc->ip))) { + error =xchk_setup_fsverity (sc); +if (error) + goto out; + } + error =xchk_trans_alloc (sc, resblks);if (error) goto out;
Re: [PATCH 35/40] xfs: teach online repair to evaluate fsverity xattrs
Quoted 124 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Teach online repair to check for unused fsverity metadata and purge it on reconstruction.
Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/scrub/attr.c | 102 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/attr.h | 4 ++ fs/xfs/scrub/common.c | 27 +++++++++++++ 3 files changed, 133 insertions(+)fs/xfs/scrub/attr.c +89
-0@@ -21,6 +21,8 @@#include "scrub/dabtree.h" #include "scrub/attr.h" +#include <linux/fsverity.h> +/* Free the buffers linked from the xattr buffer. */ static void xchk_xattr_buf_cleanup(@@ -135,6 +137,91 @@ xchk_setup_xattr(return xchk_setup_inode_contents (sc,0 ); } +#ifdef CONFIG_FS_VERITY +/* Extract merkle tree geometry from incore information. */ +static int +xchk_xattr_extract_verity ( +struct xfs_scrub *sc) +{ +struct xchk_xattr_buf *ab = sc->buf; + +/* setup should have allocated the buffer */ +if (!ab) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +return fsverity_merkle_tree_geometry (VFS_I (sc->ip), + &ab->merkle_blocksize, &ab->merkle_tree_size); +} + +/* Check the merkle tree xattrs. */ +STATIC void +xchk_xattr_verity ( +struct xfs_scrub *sc, +xfs_dablk_t blkno, +const unsigned char *name, +unsigned int namelen, +unsigned int valuelen) +{ +struct xchk_xattr_buf *ab = sc->buf; + +/* Non-verity filesystems should never have verity xattrs. */ +if (!xfs_has_verity (sc->mp)) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } + +/* +* Any verity metadata on a non-verity file are leftovers from a +* previous attempt to enable verity. +*/ +if (!IS_VERITY (VFS_I (sc->ip))) { +xchk_ino_set_preen (sc, sc->ip->i_ino); +return ; + } + +switch (namelen) { +case sizeof (struct xfs_verity_merkle_key ): +/* Oversized blocks are not allowed */ +if (valuelen > ab->merkle_blocksize) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } +break ; +case XFS_VERITY_DESCRIPTOR_NAME_LEN : +/* Has to match the descriptor xattr name */ +if (memcmp (name,XFS_VERITY_DESCRIPTOR_NAME , namelen)) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); + } +return ; +default : +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } + +/* +* Merkle tree blocks beyond the end of the tree are leftovers from +* a previous failed attempt to enable verity. +*/ +if (xfs_verity_merkle_key_from_disk (name) >= ab->merkle_tree_size) +xchk_ino_set_preen (sc, sc->ip->i_ino); +} +#else +# define xchk_xattr_extract_verity (sc) (0) + +static void +xchk_xattr_verity ( +struct xfs_scrub *sc, +xfs_dablk_t blkno, +const unsigned char *name, +unsigned int namelen) +{ +/* Should never see verity xattrs when verity is not enabled. */ +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +} +#endif /* CONFIG_FS_VERITY */ +/* Extended Attributes */ struct xchk_xattr {@@ -194,6 +281,15 @@ xchk_xattr_listent( goto fail_xref; } +/* Check verity xattr geometry */ +if (flags &XFS_ATTR_VERITY ) {
fs/xfs/scrub/attr.c xchk_xattr_listent( · line 295
Quoted 10 lines
fs/xfs/scrub/attr.c +7
-0+xchk_xattr_verity (sx->sc, args.blkno, name, namelen, valuelen); +if (sx->sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT ) { + context->seen_enough =1 ; +return ; + } + } +/* Does this name make sense? */ if (!xfs_attr_namecheck (sx->sc->mp, name, namelen, flags)) {xchk_fblock_set_corrupt (sx->sc,XFS_ATTR_FORK , args.blkno);
Would it be better to check verity after xfs_attr_namecheck()? Invalid name seems to be a more basic corruption.
Signature · 1 line
- Andrey
Re: [PATCH 35/40] xfs: teach online repair to evaluate fsverity xattrs
Quoted 123 lines · Andrey Albershteyn
Quoted 122 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Teach online repair to check for unused fsverity metadata and purge it on reconstruction.
Signed-off-by Darrick J. Wong <[email protected]>--- fs/xfs/scrub/attr.c | 102 +++++++++++++++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/attr.h | 4 ++ fs/xfs/scrub/common.c | 27 +++++++++++++ 3 files changed, 133 insertions(+)fs/xfs/scrub/attr.c +87
-0@@ -21,6 +21,8 @@#include "scrub/dabtree.h" #include "scrub/attr.h" +#include <linux/fsverity.h> +/* Free the buffers linked from the xattr buffer. */ static void xchk_xattr_buf_cleanup(@@ -135,6 +137,91 @@ xchk_setup_xattr(return xchk_setup_inode_contents (sc,0 ); } +#ifdef CONFIG_FS_VERITY +/* Extract merkle tree geometry from incore information. */ +static int +xchk_xattr_extract_verity ( +struct xfs_scrub *sc) +{ +struct xchk_xattr_buf *ab = sc->buf; + +/* setup should have allocated the buffer */ +if (!ab) { +ASSERT (0 ); +return -EFSCORRUPTED ; + } + +return fsverity_merkle_tree_geometry (VFS_I (sc->ip), + &ab->merkle_blocksize, &ab->merkle_tree_size); +} + +/* Check the merkle tree xattrs. */ +STATIC void +xchk_xattr_verity ( +struct xfs_scrub *sc, +xfs_dablk_t blkno, +const unsigned char *name, +unsigned int namelen, +unsigned int valuelen) +{ +struct xchk_xattr_buf *ab = sc->buf; + +/* Non-verity filesystems should never have verity xattrs. */ +if (!xfs_has_verity (sc->mp)) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } + +/* +* Any verity metadata on a non-verity file are leftovers from a +* previous attempt to enable verity. +*/ +if (!IS_VERITY (VFS_I (sc->ip))) { +xchk_ino_set_preen (sc, sc->ip->i_ino); +return ; + } + +switch (namelen) { +case sizeof (struct xfs_verity_merkle_key ): +/* Oversized blocks are not allowed */ +if (valuelen > ab->merkle_blocksize) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } +break ; +case XFS_VERITY_DESCRIPTOR_NAME_LEN : +/* Has to match the descriptor xattr name */ +if (memcmp (name,XFS_VERITY_DESCRIPTOR_NAME , namelen)) { +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); + } +return ; +default : +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +return ; + } + +/* +* Merkle tree blocks beyond the end of the tree are leftovers from +* a previous failed attempt to enable verity. +*/ +if (xfs_verity_merkle_key_from_disk (name) >= ab->merkle_tree_size) +xchk_ino_set_preen (sc, sc->ip->i_ino); +} +#else +# define xchk_xattr_extract_verity (sc) (0) + +static void +xchk_xattr_verity ( +struct xfs_scrub *sc, +xfs_dablk_t blkno, +const unsigned char *name, +unsigned int namelen) +{ +/* Should never see verity xattrs when verity is not enabled. */ +xchk_fblock_set_corrupt (sc,XFS_ATTR_FORK , blkno); +} +#endif /* CONFIG_FS_VERITY */ +/* Extended Attributes */ struct xchk_xattr {@@ -194,6 +281,15 @@ xchk_xattr_listent( goto fail_xref; }
Quoted 15 lines
fs/xfs/scrub/attr.c xchk_xattr_listent( · line 295
Quoted 12 lines
fs/xfs/scrub/attr.c +9
-0+/* Check verity xattr geometry */ +if (flags &XFS_ATTR_VERITY ) { +xchk_xattr_verity (sx->sc, args.blkno, name, namelen, valuelen); +if (sx->sc->sm->sm_flags &XFS_SCRUB_OFLAG_CORRUPT ) { + context->seen_enough =1 ; +return ; + } + } +/* Does this name make sense? */ if (!xfs_attr_namecheck (sx->sc->mp, name, namelen, flags)) {xchk_fblock_set_corrupt (sx->sc,XFS_ATTR_FORK , args.blkno);Would it be better to check verity after
xfs_attr_namecheck()? Invalid name seems to be a more basic corruption.
Yeah, that could be changed easily. Done.
--D
Quoted 4 lines
Signature · 1 line
- Andrey
PATCH 36/40 xfs: don't store trailing zeroes of merkle tree blocks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
As a minor space optimization, don't store trailing zeroes of merkle tree blocks to reduce space consumption and copying overhead. This really only affects the rightmost blocks at each level of the tree.
--- fs/xfs/xfs_verity.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
fs/xfs/xfs_verity.c +6 -5
@@ -622,11 +622,6 @@ xfs_verity_read_merkle(if (error) goto out_new_mk; -if (!args.valuelen) { - error = -ENODATA ; - goto out_new_mk; - } - mk =xfs_verity_cache_store (ip, key, new_mk);if (mk != new_mk) {/*
@@ -681,6 +676,12 @@ xfs_verity_write_merkle( .value = (void *)buf, .valuelen = size, }; +const char *p = buf + size -1 ; + +/* Don't store trailing zeroes. */ +while (p >= (const char *)buf && *p ==0 ) + p--; + args.valuelen = p - (const char *)buf +1 ;xfs_verity_merkle_key_to_disk (&name, pos);return xfs_attr_set (&args);
Re: [PATCH 36/40] xfs: don't store trailing zeroes of merkle tree blocks
Quoted 7 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
As a minor space optimization, don't store trailing zeroes of merkle tree blocks to reduce space consumption and copying overhead. This really only affects the rightmost blocks at each level of the tree.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good to me:
Quoted 35 lines
--- fs/xfs/xfs_verity.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)fs/xfs/xfs_verity.c +6
-5@@ -622,11 +622,6 @@ xfs_verity_read_merkle(if (error) goto out_new_mk; -if (!args.valuelen) { - error = -ENODATA ; - goto out_new_mk; - } - mk =xfs_verity_cache_store (ip, key, new_mk);if (mk != new_mk) {/* @@ -681,6 +676,12 @@ xfs_verity_write_merkle( .value = (void *)buf, .valuelen = size, }; +const char *p = buf + size -1 ; + +/* Don't store trailing zeroes. */ +while (p >= (const char *)buf && *p ==0 ) + p--; + args.valuelen = p - (const char *)buf +1 ;xfs_verity_merkle_key_to_disk (&name, pos);return xfs_attr_set (&args);
Signature · 1 line
- Andrey
PATCH 37/40 xfs: create separate name hash function for xattrs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new hashing function for extended attribute names. The next patch needs this so it can modify the hash strategy for verity xattrs.
--- fs/xfs/libxfs/xfs_attr.c | 16 ++++++++++++++-- fs/xfs/libxfs/xfs_attr.h | 3 +++ fs/xfs/libxfs/xfs_attr_leaf.c | 4 ++-- fs/xfs/scrub/attr.c | 8 +++++--- fs/xfs/xfs_attr_item.c | 3 ++- fs/xfs/xfs_attr_list.c | 3 ++- 6 files changed, 28 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_attr.c +14 -2
@@ -238,6 +238,16 @@ xfs_attr_get_ilocked(return xfs_attr_node_get (args); } +/* Compute hash for an extended attribute name. */ +xfs_dahash_t +xfs_attr_hashname ( +unsigned int attr_flags, +const uint8_t *name, +unsigned int namelen) +{ +return xfs_da_hashname (name, namelen); +} +/* * Retrieve an extended attribute by name, and its value if requested. *
@@ -268,7 +278,8 @@ xfs_attr_get( args->geo = args->dp->i_mount->m_attr_geo; args->whichfork =XFS_ATTR_FORK ; - args->hashval =xfs_da_hashname (args->name, args->namelen); + args->hashval =xfs_attr_hashname (args->attr_filter, args->name, + args->namelen);/* Entirely possible to look up a name which doesn't exist */ args->op_flags =XFS_DA_OP_OKNOENT ;
@@ -942,7 +953,8 @@ xfs_attr_set( args->geo = mp->m_attr_geo; args->whichfork =XFS_ATTR_FORK ; - args->hashval =xfs_da_hashname (args->name, args->namelen); + args->hashval =xfs_attr_hashname (args->attr_filter, args->name, + args->namelen);/* * We have no control over the attribute names that userspace passes us
fs/xfs/libxfs/xfs_attr.h +3 -0
@@ -619,4 +619,7 @@ extern struct kmem_cache *xfs_attr_intent_cache;int __init xfs_attr_intent_init_cache (void );void xfs_attr_intent_destroy_cache (void ); +xfs_dahash_t xfs_attr_hashname (unsigned int attr_flags, +const uint8_t *name_string,unsigned int name_length); +#endif /* __XFS_ATTR_H__ */
fs/xfs/libxfs/xfs_attr_leaf.c +2 -2
@@ -911,8 +911,8 @@ xfs_attr_shortform_to_leaf( nargs.namelen = sfe->namelen; nargs.value = &sfe->nameval[nargs.namelen]; nargs.valuelen = sfe->valuelen; - nargs.hashval =xfs_da_hashname (sfe->nameval, - sfe->namelen); + nargs.hashval =xfs_attr_hashname (sfe->flags, sfe->nameval, + sfe->namelen); nargs.attr_filter = sfe->flags &XFS_ATTR_NSP_ONDISK_MASK ; error =xfs_attr3_leaf_lookup_int (bp, &nargs);/* set a->index */ ASSERT (error == -ENOATTR );
fs/xfs/scrub/attr.c +5 -3
@@ -253,7 +253,6 @@ xchk_xattr_listent( .dp = context->dp, .name = name, .namelen = namelen, - .hashval = xfs_da_hashname(name, namelen), .trans = context->tp, .valuelen = valuelen, };
@@ -263,6 +262,7 @@ xchk_xattr_listent( sx = container_of(context, struct xchk_xattr, context); ab = sx->sc->buf; + args.hashval =xfs_attr_hashname (flags, name, namelen);if (xchk_should_terminate (sx->sc, &error)) { context->seen_enough = error;
@@ -600,7 +600,8 @@ xchk_xattr_rec(xchk_da_set_corrupt (ds, level); goto out; } - calc_hash =xfs_da_hashname (lentry->nameval, lentry->namelen); + calc_hash =xfs_attr_hashname (ent->flags, lentry->nameval, + lentry->namelen); }else { rentry = (struct xfs_attr_leaf_name_remote *) (((char *)bp->b_addr) + nameidx);
@@ -608,7 +609,8 @@ xchk_xattr_rec(xchk_da_set_corrupt (ds, level); goto out; } - calc_hash =xfs_da_hashname (rentry->name, rentry->namelen); + calc_hash =xfs_attr_hashname (ent->flags, rentry->name, + rentry->namelen); }if (calc_hash != hash)xchk_da_set_corrupt (ds, level);
fs/xfs/xfs_attr_item.c +2 -1
@@ -536,7 +536,8 @@ xfs_attri_recover_work( args->whichfork =XFS_ATTR_FORK ; args->name = nv->name.i_addr; args->namelen = nv->name.i_len; - args->hashval =xfs_da_hashname (args->name, args->namelen); + args->hashval =xfs_attr_hashname (attrp->alfi_attr_filter, args->name, + args->namelen); args->attr_filter = attrp->alfi_attr_filter &XFS_ATTRI_FILTER_MASK ; args->op_flags =XFS_DA_OP_RECOVERY |XFS_DA_OP_OKNOENT |XFS_DA_OP_LOGGED ;
fs/xfs/xfs_attr_list.c +2 -1
@@ -135,7 +135,8 @@ xfs_attr_shortform_list( } sbp->entno = i; - sbp->hash =xfs_da_hashname (sfe->nameval, sfe->namelen); + sbp->hash =xfs_attr_hashname (sfe->flags, sfe->nameval, + sfe->namelen); sbp->name = sfe->nameval; sbp->namelen = sfe->namelen;/* These are bytes, and both on-disk, don't endian-flip */
Re: [PATCH 37/40] xfs: create separate name hash function for xattrs
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Create a new hashing function for extended attribute names. The next patch needs this so it can modify the hash strategy for verity xattrs.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good to me:
Quoted 147 lines
--- fs/xfs/libxfs/xfs_attr.c | 16 ++++++++++++++-- fs/xfs/libxfs/xfs_attr.h | 3 +++ fs/xfs/libxfs/xfs_attr_leaf.c | 4 ++-- fs/xfs/scrub/attr.c | 8 +++++--- fs/xfs/xfs_attr_item.c | 3 ++- fs/xfs/xfs_attr_list.c | 3 ++- 6 files changed, 28 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +14
-2@@ -238,6 +238,16 @@ xfs_attr_get_ilocked(return xfs_attr_node_get (args); } +/* Compute hash for an extended attribute name. */ +xfs_dahash_t +xfs_attr_hashname ( +unsigned int attr_flags, +const uint8_t *name, +unsigned int namelen) +{ +return xfs_da_hashname (name, namelen); +} +/* * Retrieve an extended attribute by name, and its value if requested. * @@ -268,7 +278,8 @@ xfs_attr_get( args->geo = args->dp->i_mount->m_attr_geo; args->whichfork =XFS_ATTR_FORK ; - args->hashval =xfs_da_hashname (args->name, args->namelen); + args->hashval =xfs_attr_hashname (args->attr_filter, args->name, + args->namelen);/* Entirely possible to look up a name which doesn't exist */ args->op_flags =XFS_DA_OP_OKNOENT ;@@ -942,7 +953,8 @@ xfs_attr_set( args->geo = mp->m_attr_geo; args->whichfork =XFS_ATTR_FORK ; - args->hashval =xfs_da_hashname (args->name, args->namelen); + args->hashval =xfs_attr_hashname (args->attr_filter, args->name, + args->namelen);/* * We have no control over the attribute names that userspace passes us fs/xfs/libxfs/xfs_attr.h +3
-0@@ -619,4 +619,7 @@ extern struct kmem_cache *xfs_attr_intent_cache;int __init xfs_attr_intent_init_cache (void );void xfs_attr_intent_destroy_cache (void ); +xfs_dahash_t xfs_attr_hashname (unsigned int attr_flags, +const uint8_t *name_string,unsigned int name_length); +#endif /* __XFS_ATTR_H__ */ fs/xfs/libxfs/xfs_attr_leaf.c +2
-2@@ -911,8 +911,8 @@ xfs_attr_shortform_to_leaf( nargs.namelen = sfe->namelen; nargs.value = &sfe->nameval[nargs.namelen]; nargs.valuelen = sfe->valuelen; - nargs.hashval =xfs_da_hashname (sfe->nameval, - sfe->namelen); + nargs.hashval =xfs_attr_hashname (sfe->flags, sfe->nameval, + sfe->namelen); nargs.attr_filter = sfe->flags &XFS_ATTR_NSP_ONDISK_MASK ; error =xfs_attr3_leaf_lookup_int (bp, &nargs);/* set a->index */ ASSERT (error == -ENOATTR );fs/xfs/scrub/attr.c +5
-3@@ -253,7 +253,6 @@ xchk_xattr_listent( .dp = context->dp, .name = name, .namelen = namelen, - .hashval = xfs_da_hashname(name, namelen), .trans = context->tp, .valuelen = valuelen, };@@ -263,6 +262,7 @@ xchk_xattr_listent( sx = container_of(context, struct xchk_xattr, context); ab = sx->sc->buf; + args.hashval =xfs_attr_hashname (flags, name, namelen);if (xchk_should_terminate (sx->sc, &error)) { context->seen_enough = error;@@ -600,7 +600,8 @@ xchk_xattr_rec(xchk_da_set_corrupt (ds, level); goto out; } - calc_hash =xfs_da_hashname (lentry->nameval, lentry->namelen); + calc_hash =xfs_attr_hashname (ent->flags, lentry->nameval, + lentry->namelen); }else { rentry = (struct xfs_attr_leaf_name_remote *) (((char *)bp->b_addr) + nameidx);@@ -608,7 +609,8 @@ xchk_xattr_rec(xchk_da_set_corrupt (ds, level); goto out; } - calc_hash =xfs_da_hashname (rentry->name, rentry->namelen); + calc_hash =xfs_attr_hashname (ent->flags, rentry->name, + rentry->namelen); }if (calc_hash != hash)xchk_da_set_corrupt (ds, level);fs/xfs/xfs_attr_item.c +2
-1@@ -536,7 +536,8 @@ xfs_attri_recover_work( args->whichfork =XFS_ATTR_FORK ; args->name = nv->name.i_addr; args->namelen = nv->name.i_len; - args->hashval =xfs_da_hashname (args->name, args->namelen); + args->hashval =xfs_attr_hashname (attrp->alfi_attr_filter, args->name, + args->namelen); args->attr_filter = attrp->alfi_attr_filter &XFS_ATTRI_FILTER_MASK ; args->op_flags =XFS_DA_OP_RECOVERY |XFS_DA_OP_OKNOENT |XFS_DA_OP_LOGGED ;fs/xfs/xfs_attr_list.c +2
-1@@ -135,7 +135,8 @@ xfs_attr_shortform_list( } sbp->entno = i; - sbp->hash =xfs_da_hashname (sfe->nameval, sfe->namelen); + sbp->hash =xfs_attr_hashname (sfe->flags, sfe->nameval, + sfe->namelen); sbp->name = sfe->nameval; sbp->namelen = sfe->namelen;/* These are bytes, and both on-disk, don't endian-flip */
Signature · 1 line
- Andrey
PATCH 38/40 xfs: use merkle tree offset as attr hash
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
I was exploring the fsverity metadata with xfs_db after creating a 220MB verity file, and I noticed the following in the debugger output:
entries[0-75] = [hashval,nameidx,incomplete,root,secure,local,parent,verity] 0:[0,4076,0,0,0,0,0,1]
1:[0,1472,0,0,0,1,0,1]
2:[0x800,4056,0,0,0,0,0,1]
3:[0x800,4036,0,0,0,0,0,1]
...
72:[0x12000,2716,0,0,0,0,0,1]
73:[0x12000,2696,0,0,0,0,0,1]
74:[0x12800,2676,0,0,0,0,0,1]
75:[0x12800,2656,0,0,0,0,0,1]
...
nvlist[0].merkle_off = 0x18000
nvlist[1].merkle_off = 0
nvlist[2].merkle_off = 0x19000
nvlist[3].merkle_off = 0x1000
...
nvlist[71].merkle_off = 0x5b000
nvlist[72].merkle_off = 0x44000
nvlist[73].merkle_off = 0x5c000
nvlist[74].merkle_off = 0x45000
nvlist[75].merkle_off = 0x5d000
Within just this attr leaf block, there are 76 attr entries, but only 38 distinct hash values. There are 415 merkle tree blocks for this file, but we already have hash collisions. This isn't good performance from the standard da hash function because we're mostly shifting and rolling zeroes around.
However, we don't even have to do that much work -- the merkle tree block keys are themslves u64 values. Truncate that value to 32 bits (the size of xfs_dahash_t) and use that for the hash. We won't have any collisions between merkle tree blocks until that tree grows to 2^32nd blocks. On a 4k block filesystem, we won't hit that unless the file contains more than 2^49 bytes, assuming sha256.
As a side effect, the keys for merkle tree blocks get written out in roughly sequential order, though I didn't observe any change in performance.
--- fs/xfs/libxfs/xfs_attr.c | 7 +++++++ fs/xfs/libxfs/xfs_da_format.h | 2 ++ 2 files changed, 9 insertions(+)
fs/xfs/libxfs/xfs_attr.c +7 -0
@@ -245,6 +245,13 @@ xfs_attr_hashname(const uint8_t *name, unsigned int namelen) { + if ((attr_flags & XFS_ATTR_VERITY) && + namelen == sizeof(struct xfs_verity_merkle_key)) { + uint64_t off = xfs_verity_merkle_key_from_disk(name); + +return off >>XFS_VERITY_MIN_MERKLE_BLOCKLOG ; + } +return xfs_da_hashname (name, namelen); }
fs/xfs/libxfs/xfs_da_format.h +2 -0
@@ -946,4 +946,6 @@ xfs_verity_merkle_key_from_disk(#define XFS_VERITY_DESCRIPTOR_NAME "vdesc"#define XFS_VERITY_DESCRIPTOR_NAME_LEN (sizeof(XFS_VERITY_DESCRIPTOR_NAME) - 1) +#define XFS_VERITY_MIN_MERKLE_BLOCKLOG (10) +#endif /* __XFS_DA_FORMAT_H__ */
Re: [PATCH 38/40] xfs: use merkle tree offset as attr hash
Quoted 40 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
I was exploring the fsverity metadata with
xfs_dbafter creating a 220MB verity file, and I noticed the following in the debugger output:entries[0-75] = [hashval,nameidx,incomplete,root,secure,local,parent,verity] 0:[0,4076,0,0,0,0,0,1]
1:[0,1472,0,0,0,1,0,1]
2:[0x800,4056,0,0,0,0,0,1]
3:[0x800,4036,0,0,0,0,0,1]
...
72:[0x12000,2716,0,0,0,0,0,1]
73:[0x12000,2696,0,0,0,0,0,1]
74:[0x12800,2676,0,0,0,0,0,1]
75:[0x12800,2656,0,0,0,0,0,1]
...
nvlist[0].merkle_off =0x18000
nvlist[1].merkle_off = 0
nvlist[2].merkle_off =0x19000
nvlist[3].merkle_off =0x1000
...
nvlist[71].merkle_off =0x5b000
nvlist[72].merkle_off =0x44000
nvlist[73].merkle_off =0x5c000
nvlist[74].merkle_off =0x45000
nvlist[75].merkle_off =0x5d000Within just this attr leaf block, there are 76 attr entries, but only 38 distinct hash values. There are 415 merkle tree blocks for this file, but we already have hash collisions. This isn't good performance from the standard da hash function because we're mostly shifting and rolling zeroes around.
However, we don't even have to do that much work -- the merkle tree block keys are themslves u64 values. Truncate that value to 32 bits (the size of
xfs_dahash_t) and use that for the hash. We won't have any collisions between merkle tree blocks until that tree grows to 2^32nd blocks. On a 4k block filesystem, we won't hit that unless the file contains more than 2^49 bytes, assuming sha256.
Quoted 5 lines
As a side effect, the keys for merkle tree blocks get written out in roughly sequential order, though I didn't observe any change in performance.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good to me:
Quoted 36 lines
--- fs/xfs/libxfs/xfs_attr.c | 7 +++++++ fs/xfs/libxfs/xfs_da_format.h | 2 ++ 2 files changed, 9 insertions(+)fs/xfs/libxfs/xfs_attr.c +7
-0@@ -245,6 +245,13 @@ xfs_attr_hashname(const uint8_t *name, unsigned int namelen) { + if ((attr_flags & XFS_ATTR_VERITY) && + namelen == sizeof(struct xfs_verity_merkle_key)) { + uint64_t off = xfs_verity_merkle_key_from_disk(name); + +return off >>XFS_VERITY_MIN_MERKLE_BLOCKLOG ; + } +return xfs_da_hashname (name, namelen); }fs/xfs/libxfs/xfs_da_format.h +2
-0@@ -946,4 +946,6 @@ xfs_verity_merkle_key_from_disk(#define XFS_VERITY_DESCRIPTOR_NAME "vdesc"#define XFS_VERITY_DESCRIPTOR_NAME_LEN (sizeof(XFS_VERITY_DESCRIPTOR_NAME) - 1) +#define XFS_VERITY_MIN_MERKLE_BLOCKLOG (10) +#endif /* __XFS_DA_FORMAT_H__ */
Signature · 1 line
- Andrey
PATCH 39/40 xfs: don't bother storing merkle tree blocks for zeroed data blocks
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Now that fsverity tells our merkle tree io functions about what a hash of a data block full of zeroes looks like, we can use this information to avoid writing out merkle tree blocks for sparse regions of the file. For verified gold master images this can save quite a bit of overhead.
--- fs/xfs/xfs_verity.c | 37 ++++++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)
fs/xfs/xfs_verity.c +34 -3
@@ -619,6 +619,20 @@ xfs_verity_read_merkle(xfs_verity_merkle_key_to_disk (&name, block->offset); error =xfs_attr_get (&args); +if (error == -ENOATTR ) { +u8 *p; +unsigned int i; + +/* +* No attribute found. Synthesize a buffer full of the zero +* digests on the assumption that we elided them at write time. +*/ +for (i =0 , p = new_mk->data; + i < block->size; + i += req->digest_size, p += req->digest_size) +memcpy (p, req->zero_digest, req->digest_size); + error =0 ; + }if (error) goto out_new_mk;
@@ -676,12 +690,29 @@ xfs_verity_write_merkle( .value = (void *)buf, .valuelen = size, }; -const char *p = buf + size -1 ; +const char *p; +unsigned int i; -/* Don't store trailing zeroes. */ +/* +* If this is a block full of hashes of zeroed blocks, don't bother +* storing the block. We can synthesize them later. +*/ +for (i =0 , p = buf; + i < size; + i += req->digest_size, p += req->digest_size) +if (memcmp (p, req->zero_digest, req->digest_size)) +break ; +if (i == size) +return 0 ; + +/* +* Don't store trailing zeroes. Store at least one byte so that the +* block cannot be mistaken for an elided one. +*/ + p = buf + size -1 ;while (p >= (const char *)buf && *p ==0 ) p--; - args.valuelen = p - (const char *)buf +1 ; + args.valuelen =max (1 , p - (const char *)buf +1 );xfs_verity_merkle_key_to_disk (&name, pos);return xfs_attr_set (&args);
Re: [PATCH 39/40] xfs: don't bother storing merkle tree blocks for zeroed data blocks
Quoted 8 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Now that fsverity tells our merkle tree io functions about what a hash of a data block full of zeroes looks like, we can use this information to avoid writing out merkle tree blocks for sparse regions of the file. For verified gold master images this can save quite a bit of overhead.
Signed-off-by Darrick J. Wong <[email protected]>
Looks good to me:
Quoted 64 lines
--- fs/xfs/xfs_verity.c | 37 ++++++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)fs/xfs/xfs_verity.c +34
-3@@ -619,6 +619,20 @@ xfs_verity_read_merkle(xfs_verity_merkle_key_to_disk (&name, block->offset); error =xfs_attr_get (&args); +if (error == -ENOATTR ) { +u8 *p; +unsigned int i; + +/* +* No attribute found. Synthesize a buffer full of the zero +* digests on the assumption that we elided them at write time. +*/ +for (i =0 , p = new_mk->data; + i < block->size; + i += req->digest_size, p += req->digest_size) +memcpy (p, req->zero_digest, req->digest_size); + error =0 ; + }if (error) goto out_new_mk;@@ -676,12 +690,29 @@ xfs_verity_write_merkle( .value = (void *)buf, .valuelen = size, }; -const char *p = buf + size -1 ; +const char *p; +unsigned int i; -/* Don't store trailing zeroes. */ +/* +* If this is a block full of hashes of zeroed blocks, don't bother +* storing the block. We can synthesize them later. +*/ +for (i =0 , p = buf; + i < size; + i += req->digest_size, p += req->digest_size) +if (memcmp (p, req->zero_digest, req->digest_size)) +break ; +if (i == size) +return 0 ; + +/* +* Don't store trailing zeroes. Store at least one byte so that the +* block cannot be mistaken for an elided one. +*/ + p = buf + size -1 ;while (p >= (const char *)buf && *p ==0 ) p--; - args.valuelen = p - (const char *)buf +1 ; + args.valuelen =max (1 , p - (const char *)buf +1 );xfs_verity_merkle_key_to_disk (&name, pos);return xfs_attr_set (&args);
Signature · 1 line
- Andrey
PATCH 40/40 xfs: enable ro-compat fs-verity flag
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Finalize fs-verity integration in XFS by making kernel fs-verity aware with ro-compat flag.
--- fs/xfs/libxfs/xfs_format.h | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_format.h +5 -4
@@ -355,10 +355,11 @@ xfs_sb_has_compat_feature(#define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3)/* inobt block counts */ #define XFS_SB_FEAT_RO_COMPAT_VERITY (1 << 4)/* fs-verity */ #define XFS_SB_FEAT_RO_COMPAT_ALL \ - (XFS_SB_FEAT_RO_COMPAT_FINOBT | \ - XFS_SB_FEAT_RO_COMPAT_RMAPBT | \ - XFS_SB_FEAT_RO_COMPAT_REFLINK| \ - XFS_SB_FEAT_RO_COMPAT_INOBTCNT) + (XFS_SB_FEAT_RO_COMPAT_FINOBT | \ + XFS_SB_FEAT_RO_COMPAT_RMAPBT | \ + XFS_SB_FEAT_RO_COMPAT_REFLINK | \ + XFS_SB_FEAT_RO_COMPAT_INOBTCNT | \ + XFS_SB_FEAT_RO_COMPAT_VERITY)#define XFS_SB_FEAT_RO_COMPAT_UNKNOWN ~XFS_SB_FEAT_RO_COMPAT_ALLstatic inline bool xfs_sb_has_ro_compat_feature(
Eric Biggers
maintainerQuoted 6 lines · Darrick J. Wong
Hi all,
From Darrick J. Wong:
This v5.3 patchset builds upon v5.2 of Andrey's patchset to implement fsverity for XFS.
Is this ready for me to review, or is my feedback on v5 still being worked on? From a quick glance, not everything from my feedback has been addressed.
- Eric
Quoted 10 lines · Eric Biggers
Quoted 6 lines · Darrick J. Wong
Hi all,
From Darrick J. Wong:
This v5.3 patchset builds upon v5.2 of Andrey's patchset to implement fsverity for XFS.
Is this ready for me to review, or is my feedback on v5 still being worked on?
It's still being worked on. I figured it was time to push my work tree back to Andrey so everyone could see the results of me attempting to understand the fsverity patchset by working around in the codebase.
From your perspective, I suspect the most interesting patches will be 5, 6, 7+10+14, 11-13, and 15-17. For everyone on the XFS side, patches 27-39 are the most interesting since they change the caching strategy and slim down the ondisk format.
Quoted 2 lines
From a quick glance, not everything from my feedback has been addressed.
That's correct. I cleaned up the mechanics of passing merkle trees around, but I didn't address the comments about per-sb workqueues, fsverity tracepoints, or whether or not iomap should allocate biosets. Roughly, here's what I did in the generic code:
I fixed the FS_XFLAG_VERITY handling so that you can't clear it via FS_IOC_FSSETXATTR.
I also rewrote and augmented the "drop dead merkle tree" functions in xfs_verity to clean out incomplete trees when ->end_enable tells us we failed; and to clean out extra blocks in the ->begin_enable just in case the file shrank since a failed attempt to enable fsverity.
As for online repair, the "fsverity: expose merkle tree geometry to callers" enables the kernel to do some basic online checking that there aren't excessive merkle tree blocks and that fsverity can read the descriptor. In my djwong-wtf tree, xfs_scrub gains the ability to read the entire file into the pagecache (and hence validate the verity info) via MADV_POPULATE READ, and now it has a patch to read the entire merkle tree/descriptor/signature just to make sure those can actually be read.
Most of the things you gave feedback about in "fsverity: support block-based Merkle tree caching" I think I cleaned up in "fsverity: fix "support block-based Merkle tree caching"" and "fsverity: rely on cached block callers to retain verified state". I kept those separate so that Andrey could see what I did, though they really ought to be merged into the main support patch.
Note that I greatly expanded the usage of struct fsverity_blockbuf and changed the verified flag handling so that the invalidation function was no longer necessary.
--D
Quoted 1 line
- Eric
[fix tinguely email addr]
Quoted 21 lines · Darrick J. Wong
Quoted 10 lines · Eric Biggers
Quoted 6 lines · Darrick J. Wong
Hi all,
From Darrick J. Wong:
This v5.3 patchset builds upon v5.2 of Andrey's patchset to implement fsverity for XFS.
Is this ready for me to review, or is my feedback on v5 still being worked on?
It's still being worked on. I figured it was time to push my work tree back to Andrey so everyone could see the results of me attempting to understand the fsverity patchset by working around in the codebase.
From your perspective, I suspect the most interesting patches will be 5, 6, 7+10+14, 11-13, and 15-17. For everyone on the XFS side, patches 27-39 are the most interesting since they change the caching strategy and slim down the ondisk format.
Quoted 6 lines
Quoted 2 lines
From a quick glance, not everything from my feedback has been addressed.
That's correct. I cleaned up the mechanics of passing merkle trees around, but I didn't address the comments about per-sb workqueues, fsverity tracepoints, or whether or not iomap should allocate biosets.
That perhaps wasn't quite clear enough -- I'm curious to see what Andrey has to say about that part (patches 8, 9, 18) of the patchset.
--D
Quoted 33 lines
Roughly, here's what I did in the generic code:
I fixed the
FS_XFLAG_VERITYhandling so that you can't clear it viaFS_IOC_FSSETXATTR.I also rewrote and augmented the "drop dead merkle tree" functions in
xfs_verityto clean out incomplete trees when ->end_enable tells us we failed; and to clean out extra blocks in the ->begin_enable just in case the file shrank since a failed attempt to enable fsverity.As for online repair, the "fsverity: expose merkle tree geometry to callers" enables the kernel to do some basic online checking that there aren't excessive merkle tree blocks and that fsverity can read the descriptor. In my djwong-wtf tree,
xfs_scrubgains the ability to read the entire file into the pagecache (and hence validate the verity info) viaMADV_POPULATEREAD, and now it has a patch to read the entire merkle tree/descriptor/signature just to make sure those can actually be read.Most of the things you gave feedback about in "fsverity: support block-based Merkle tree caching" I think I cleaned up in "fsverity: fix "support block-based Merkle tree caching"" and "fsverity: rely on cached block callers to retain verified state". I kept those separate so that Andrey could see what I did, though they really ought to be merged into the main support patch.
Note that I greatly expanded the usage of struct
fsverity_blockbufand changed the verified flag handling so that the invalidation function was no longer necessary.--D
Quoted 1 line
- Eric
Quoted 27 lines · Darrick J. Wong
[fix tinguely email addr]
Quoted 24 lines · Darrick J. Wong
Quoted 10 lines · Eric Biggers
Quoted 6 lines · Darrick J. Wong
Hi all,
From Darrick J. Wong:
This v5.3 patchset builds upon v5.2 of Andrey's patchset to implement fsverity for XFS.
Is this ready for me to review, or is my feedback on v5 still being worked on?
It's still being worked on. I figured it was time to push my work tree back to Andrey so everyone could see the results of me attempting to understand the fsverity patchset by working around in the codebase.
From your perspective, I suspect the most interesting patches will be 5, 6, 7+10+14, 11-13, and 15-17. For everyone on the XFS side, patches 27-39 are the most interesting since they change the caching strategy and slim down the ondisk format.
Quoted 2 lines
From a quick glance, not everything from my feedback has been addressed.
Quoted 6 lines
Quoted 3 lines
That's correct. I cleaned up the mechanics of passing merkle trees around, but I didn't address the comments about per-sb workqueues, fsverity tracepoints, or whether or not iomap should allocate biosets.
That perhaps wasn't quite clear enough -- I'm curious to see what Andrey has to say about that part (patches 8, 9, 18) of the patchset.
The per-sb workqueue can be used for other fs, which should be doable (also I will rename it, as generic name came from the v2 when I thought it would be used for more stuff than just verity)
For tracepoints, I will add all the changes suggested by Eric, the signature tracepoints could be probably dropped.
For bioset allocation, I will look into this if there's good way to allocate only for verity inodes, if it's not complicate things too much. Make sense for systems which won't use fsverity but have FS_VERITY=y.
Signature · 1 line
- Andrey
Quoted 32 lines · Andrey Albershteyn
Quoted 31 lines · Darrick J. Wong
[fix tinguely email addr]
Quoted 27 lines · Darrick J. Wong
Quoted 10 lines · Eric Biggers
Quoted 6 lines · Darrick J. Wong
Hi all,
From Darrick J. Wong:
This v5.3 patchset builds upon v5.2 of Andrey's patchset to implement fsverity for XFS.
Is this ready for me to review, or is my feedback on v5 still being worked on?
It's still being worked on. I figured it was time to push my work tree back to Andrey so everyone could see the results of me attempting to understand the fsverity patchset by working around in the codebase.
From your perspective, I suspect the most interesting patches will be 5, 6, 7+10+14, 11-13, and 15-17. For everyone on the XFS side, patches 27-39 are the most interesting since they change the caching strategy and slim down the ondisk format.
Quoted 2 lines
From a quick glance, not everything from my feedback has been addressed.
That's correct. I cleaned up the mechanics of passing merkle trees around, but I didn't address the comments about per-sb workqueues, fsverity tracepoints, or whether or not iomap should allocate biosets.
Quoted 6 lines
Quoted 2 lines
That perhaps wasn't quite clear enough -- I'm curious to see what Andrey has to say about that part (patches 8, 9, 18) of the patchset.
The per-sb workqueue can be used for other fs, which should be doable (also I will rename it, as generic name came from the v2 when I thought it would be used for more stuff than just verity)
<nod>
Quoted 2 lines
For tracepoints, I will add all the changes suggested by Eric, the signature tracepoints could be probably dropped.
I hacked up a bunch of tracepoint changes which I've attached below. Note the use of print_hex_str so that the digest comes out like:
a0fcdf17f6d49b47
instead of
a0 fc df 17 f6 d4 9b 47
So that it's an exact match for what the fsverity tool emits. I also turned the _ASCEND and _DESCEND trace arguments into separate tracepoints.
Also, if you ever want to have a tracepoint that stores an int value but turns that into a string in TP_printk, you should use __print_symbolic and not open-code the logic. For bitflags, it's __print_flags. None of that is documented anywhere.
Quoted 4 lines
For bioset allocation, I will look into this if there's good way to allocate only for verity inodes, if it's not complicate things too much. Make sense for systems which won't use fsverity but have FS_VERITY=y.
I'd imagine it's more or less a clone of sb_init_dio_done_wq that can be called from iomap_read_bio_alloc when
(fsverity_active() && !sb->s_read_done_wq).
Something I just noticed -- shouldn't we be calling verity from iomap_read_folio_sync as well?
--D
fs/verity/enable.c +3 -2
@@ -232,7 +232,7 @@ static int enable_verity(struct file *filp,if (err) goto out; -trace_fsverity_enable (inode, desc, ¶ms); +trace_fsverity_enable (inode, ¶ms);/* * Start enabling verity on this file, serialized by the inode lock.
@@ -263,7 +263,6 @@ static int enable_verity(struct file *filp,fsverity_err (inode,"Error %d building Merkle tree" , err); goto rollback; } -trace_fsverity_tree_done (inode, desc, ¶ms);/* * Create the fsverity_info. Don't bother trying to save work by
@@ -278,6 +277,8 @@ static int enable_verity(struct file *filp, goto rollback; } +trace_fsverity_tree_done (inode, vi, ¶ms); +/* * Tell the filesystem to finish enabling verity on the file. * Serialized with ->begin_enable_verity() by the inode lock.
fs/verity/signature.c +0 -2
@@ -53,8 +53,6 @@ int fsverity_verify_signature(const struct fsverity_info *vi,struct fsverity_formatted_digest *d;int err; -trace_fsverity_verify_signature (inode, signature, sig_size); -if (sig_size ==0 ) {if (fsverity_require_signatures) { fsverity_err(inode,
fs/verity/verify.c +8 -5
@@ -122,7 +122,9 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,/* Byte offset of the wanted hash relative to @addr */ unsigned int hoffset; } hblocks[FS_VERITY_MAX_LEVELS ]; -trace_fsverity_verify_block (inode, data_pos); + +trace_fsverity_verify_data_block (inode, params, data_pos); +/* * The index of the previous level's block within that level; also the * index of that block's hash within the current level.
@@ -195,8 +197,9 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,if (is_hash_block_verified (inode, block, hblock_idx)) {memcpy (_want_hash, block->kaddr + hoffset, hsize); want_hash = _want_hash; -trace_fsverity_merkle_tree_block_verified (inode, - block,FSVERITY_TRACE_DIR_ASCEND ); +trace_fsverity_merkle_hit (inode, data_pos, hblock_pos, + level, + hoffset >> params->log_digestsize);fsverity_drop_merkle_tree_block (inode, block); goto descend; }
@@ -231,8 +234,8 @@ verify_data_block(struct inode *inode, struct fsverity_info *vi,SetPageChecked ((struct page *)block->context);memcpy (_want_hash, haddr + hoffset, hsize); want_hash = _want_hash; -trace_fsverity_merkle_tree_block_verified (inode, block, -FSVERITY_TRACE_DIR_DESCEND ); +trace_fsverity_verify_merkle_block (inode, block->offset, + level, hoffset >> params->log_digestsize);fsverity_drop_merkle_tree_block (inode, block); }
include/trace/events/fsverity.h +58 -78
197 lines not on this page · raw message
PATCH 1/1 fs-verity support for XFS
In reply to Darrick J. WongHi all,
From Darrick J. Wong:
This v5.3 patchset builds upon v5.2 of Andrey's patchset to implement fsverity for XFS.
The biggest thing that I didn't like in the v5 patchset is the abuse of the data device's buffer cache to store the incore version of the merkle tree blocks. Not only do verity state flags end up in xfs_buf, but the double-alloc flag wastes memory and doesn't remain internally consistent if the xattrs shift around.
I replaced all of that with a per-inode xarray that indexes incore merkle tree blocks. For cache hits, this dramatically reduces the amount of work that xfs has to do to feed fsverity. The per-block overhead is much lower (8 bytes instead of ~300 for xfs_bufs), and we no longer have to entertain layering violations in the buffer cache. I also added a per-filesystem shrinker so that reclaim can cull cached merkle tree blocks, starting with the leaf tree nodes.
I've also rolled in some changes recommended by the fsverity maintainer, fixed some organization and naming problems in the xfs code, fixed a collision in the xfs_inode iflags, and improved dead merkle tree cleanup per the discussion of the v5 series. At this point I'm happy enough with this code to start integrating and testing it in my trees, so it's time to send it out a coherent patchset for comments.
For v5.3, I've added bits and pieces of online and offline repair support, reduced the size of partially filled merkle tree blocks by removing trailing zeroes, changed the xattr hash function to better avoid collisions between merkle tree keys, made the fsverity invalidation bitmap unnecessary, and made it so that we can save space on sparse verity files by not storing merkle tree blocks that hash totally zeroed data blocks.
From Andrey Albershteyn:
Here's v5 of my patchset of adding fs-verity support to XFS.
This implementation uses extended attributes to store fs-verity metadata. The Merkle tree blocks are stored in the remote extended attributes. The names are offsets into the tree.
A few key points of this patchset:
- fs-verity can work with Merkle tree blocks based caching (xfs) and PAGE caching (ext4, f2fs, btrfs)
- iomap does fs-verity verification
- In XFS, fs-verity metadata is stored in extended attributes
- per-sb workqueue for verification processing
- Inodes with fs-verity have new on-disk diflag
- xfs_attr_get() can return a buffer with an extended attribute
- xfs_buf can allocate double space for Merkle tree blocks. Part of the space is used to store the extended attribute data without leaf headers
- xfs_buf tracks verified status of merkle tree blocks
The patchset consists of five parts:
- [1]: fs-verity spinlock removal pending in fsverity/for-next
- [2..4]: Parent pointers adding binary xattr names
- [5]: Expose FS_XFLAG_VERITY for fs-verity files
- [6..9]: Changes to fs-verity core
- [10]: Integrate fs-verity to iomap
- [11-24]: Add fs-verity support to XFS
Testing:
The patchset is tested with xfstests -g verity on xfs_1k, xfs_4k, xfs_1k_quota, xfs_4k_quota, ext4_4k, and ext4_4k_quota. With KMEMLEAK and KASAN enabled. More testing on the way.
Changes from V4:
- Mainly fs-verity changes; removed unnecessary functions
- Replace XFS workqueue with per-sb workqueue created in fsverity_set_ops()
- Drop patch with readahead calculation in bytes
Changes from V3:
- redone changes to fs-verity core as previous version had an issue on ext4
- add blocks invalidation interface to fs-verity
- move memory ordering primitives out of block status check to fs read block function
- add fs-verity verification to iomap instead of general post read processing
Changes from V2:
- FS_XFLAG_VERITY extended attribute flag
- Change fs-verity to use Merkle tree blocks instead of expecting PAGE references from filesystem
- Change approach in iomap to filesystem provided bio_set and submit_io instead of just callouts to filesystem
- Add possibility for xfs_buf allocate more space for fs-verity extended attributes
- Make xfs_attr module to copy fs-verity blocks inside the xfs_buf, so XFS can get data without leaf headers
- Add Merkle tree removal for error path
- Makae scrub aware of new dinode flag
Changes from V1:
- Added parent pointer patches for easier testing
- Many issues and refactoring points fixed from the V1 review
- Adjusted for recent changes in fs-verity core (folios, non-4k)
- Dropped disabling of large folios
- Completely new fsverity patches (fix, callout, log_blocksize)
- Change approach to verification in iomap to the same one as in write path. Callouts to fs instead of direct fs-verity use.
- New XFS workqueue for post read folio verification
- xfs_attr_get() can return underlying xfs_buf
- xfs_bufs are marked with XBF_VERITY_CHECKED to track verified blocks
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=fsverity-xfs
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=fsverity-xfs
---
Commits in this patchset:
* xfsprogs: add parent pointer support to attribute code
* xfsprogs: define parent pointer xattr format
* xfsprogs: Add xfs_verify_pptr
* fs: add FS_XFLAG_VERITY for verity files
* xfs: add attribute type for fs-verity
* xfs: add fs-verity ro-compat flag
* xfs: add inode on-disk VERITY flag
* xfs: add fs-verity support
* xfs: advertise fs-verity being available on filesystem
* xfs: create separate name hash function for xattrs
* xfs: use merkle tree offset as attr hash
* xfs: enable ro-compat fs-verity flag
* libfrog: add fsverity to xfs_report_geom output
* xfs_db: introduce attr_modify command
* xfs_db: make attr_set/remove/modify be able to handle fs-verity attrs
* man: document attr_modify command
* xfs_db: dump verity features and metadata
* xfs_db: dump merkle tree data
* xfs_repair: junk fsverity xattrs when unnecessary
* mkfs.xfs: add verity parameter
--- db/attr.c | 94 +++++++++++++++++++ db/attrset.c | 226 +++++++++++++++++++++++++++++++++++++++++++++- db/attrshort.c | 22 ++++ db/hash.c | 4 - db/metadump.c | 26 +++-- db/sb.c | 2 db/write.c | 2 db/write.h | 1 include/linux.h | 4 + include/xfs_mount.h | 2 libfrog/fsgeom.c | 4 + libxfs/libxfs_api_defs.h | 2 libxfs/xfs_attr.c | 86 ++++++++++++++++-- libxfs/xfs_attr.h | 6 + libxfs/xfs_attr_leaf.c | 4 - libxfs/xfs_da_format.h | 80 ++++++++++++++++ libxfs/xfs_format.h | 14 ++- libxfs/xfs_fs.h | 1 libxfs/xfs_log_format.h | 2 libxfs/xfs_ondisk.h | 4 + libxfs/xfs_sb.c | 4 + man/man8/mkfs.xfs.8.in | 4 + man/man8/xfs_db.8 | 34 +++++++ mkfs/xfs_mkfs.c | 19 +++- repair/attr_repair.c | 52 +++++++++-- 25 files changed, 651 insertions(+), 48 deletions(-)
PATCH 1/20 xfsprogs: add parent pointer support to attribute code
From: Allison Henderson <[email protected]>
Source kernel commit: 403a9dc2804baec57eb03a9c4ae14ba811f091e5
Add the new parent attribute type. XFS_ATTR_PARENT is used only for parent pointer entries; it uses reserved blocks like XFS_ATTR_ROOT.
--- libxfs/xfs_attr.c | 4 +++- libxfs/xfs_da_format.h | 5 ++++- libxfs/xfs_log_format.h | 1 + 3 files changed, 8 insertions(+), 2 deletions(-)
libxfs/xfs_attr.c +3 -1
@@ -922,11 +922,13 @@ xfs_attr_set(struct xfs_inode *dp = args->dp;struct xfs_mount *mp = dp->i_mount;struct xfs_trans_res tres; -bool rsvd = (args->attr_filter &XFS_ATTR_ROOT ); +bool rsvd;int error, local;int rmt_blks =0 ;unsigned int total; + rsvd = (args->attr_filter & (XFS_ATTR_ROOT |XFS_ATTR_PARENT )) !=0 ; +if (xfs_is_shutdown (dp->i_mount))return -EIO ;
libxfs/xfs_da_format.h +4 -1
@@ -714,12 +714,15 @@ struct xfs_attr3_leafblock {#define XFS_ATTR_LOCAL_BIT 0/* attr is stored locally */ #define XFS_ATTR_ROOT_BIT 1/* limit access to trusted attrs */ #define XFS_ATTR_SECURE_BIT 2/* limit access to secure attrs */ +#define XFS_ATTR_PARENT_BIT 3/* parent pointer attrs */ #define XFS_ATTR_INCOMPLETE_BIT 7/* attr in middle of create/delete */ #define XFS_ATTR_LOCAL (1u << XFS_ATTR_LOCAL_BIT)#define XFS_ATTR_ROOT (1u << XFS_ATTR_ROOT_BIT)#define XFS_ATTR_SECURE (1u << XFS_ATTR_SECURE_BIT) +#define XFS_ATTR_PARENT (1u << XFS_ATTR_PARENT_BIT)#define XFS_ATTR_INCOMPLETE (1u << XFS_ATTR_INCOMPLETE_BIT) -#define XFS_ATTR_NSP_ONDISK_MASK (XFS_ATTR_ROOT | XFS_ATTR_SECURE) +#define XFS_ATTR_NSP_ONDISK_MASK \ + (XFS_ATTR_ROOT | XFS_ATTR_SECURE | XFS_ATTR_PARENT)/* * Alignment for namelist and valuelist entries (since they are mixed
libxfs/xfs_log_format.h +1 -0
@@ -974,6 +974,7 @@ struct xfs_icreate_log {*/ #define XFS_ATTRI_FILTER_MASK (XFS_ATTR_ROOT | \ XFS_ATTR_SECURE | \ + XFS_ATTR_PARENT | \ XFS_ATTR_INCOMPLETE)/*
PATCH 2/20 xfsprogs: define parent pointer xattr format
In reply to Darrick J. WongFrom: Allison Henderson <[email protected]>
Source kernel commit: 655e7fb23dc155b37a2eeadf2c854def053980bf
We need to define the parent pointer attribute format before we start adding support for it into all the code that needs to use it. The EA format we will use encodes the following information:
name={parent inode #, parent inode generation, dirent offset} value={dirent filename}
The inode/gen gives all the information we need to reliably identify the parent without requiring child->parent lock ordering, and allows userspace to do pathname component level reconstruction without the kernel ever needing to verify the parent itself as part of ioctl calls.
By using the dirent offset in the EA name, we have a method of knowing the exact parent pointer EA we need to modify/remove in rename/unlink without an unbound EA name search.
By keeping the dirent name in the value, we have enough information to be able to validate and reconstruct damaged directory trees. While the diroffset of a filename alone is not unique enough to identify the child, the {diroffset,filename,child_inode} tuple is sufficient. That is, if the diroffset gets reused and points to a different filename, we can detect that from the contents of EA. If a link of the same name is created, then we can check whether it points at the same inode as the parent EA we current have.
--- libxfs/xfs_da_format.h | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
libxfs/xfs_da_format.h +25 -0
@@ -878,4 +878,29 @@ static inline unsigned int xfs_dir2_dirblock_bytes(struct xfs_sb *sbp)xfs_failaddr_t xfs_da3_blkinfo_verify (struct xfs_buf *bp,struct xfs_da3_blkinfo *hdr3); +/* +* Parent pointer attribute format definition +* +* EA name encodes the parent inode number, generation and the offset of +* the dirent that points to the child inode. The EA value contains the +* same name as the dirent in the parent directory. +*/ +struct xfs_parent_name_rec { +__be64 p_ino; +__be32 p_gen; +__be32 p_diroffset; +}; + +/* +* incore version of the above, also contains name pointers so callers +* can pass/obtain all the parent pointer information in a single structure +*/ +struct xfs_parent_name_irec { +xfs_ino_t p_ino; +uint32_t p_gen; +xfs_dir2_dataptr_t p_diroffset; +const char *p_name; +uint8_t p_namelen; +}; +#endif /* __XFS_DA_FORMAT_H__ */
PATCH 3/20 xfsprogs: Add xfs_verify_pptr
In reply to Darrick J. WongFrom: Allison Henderson <[email protected]>
Source kernel commit: 27e62618672464a8c011ee180878c711a6faed73
Attribute names of parent pointers are not strings. So we need to modify attr_namecheck to verify parent pointer records when the XFS_ATTR_PARENT flag is set.
--- libxfs/xfs_attr.c | 47 ++++++++++++++++++++++++++++++++++++++++++++--- libxfs/xfs_attr.h | 3 ++- libxfs/xfs_da_format.h | 8 ++++++++ repair/attr_repair.c | 19 ++++++++++++------- 4 files changed, 66 insertions(+), 11 deletions(-)
libxfs/xfs_attr.c +44 -3
@@ -1510,9 +1510,33 @@ xfs_attr_node_get(return error; } -/* Returns true if the attribute entry name is valid. */ -bool -xfs_attr_namecheck ( +/* +* Verify parent pointer attribute is valid. +* Return true on success or false on failure +*/ +STATIC bool +xfs_verify_pptr ( +struct xfs_mount *mp, +const struct xfs_parent_name_rec *rec) +{ +xfs_ino_t p_ino; +xfs_dir2_dataptr_t p_diroffset; + + p_ino =be64_to_cpu (rec->p_ino); + p_diroffset =be32_to_cpu (rec->p_diroffset); + +if (!xfs_verify_ino (mp, p_ino)) +return false; + +if (p_diroffset >XFS_DIR2_MAX_DATAPTR ) +return false; + +return true; +} + +/* Returns true if the string attribute entry name is valid. */ +static bool +xfs_str_attr_namecheck (const void *name,size_t length) {
@@ -1527,6 +1551,23 @@ xfs_attr_namecheck(return !memchr (name,0 , length); } +/* Returns true if the attribute entry name is valid. */ +bool +xfs_attr_namecheck ( +struct xfs_mount *mp, +const void *name, +size_t length, +int flags) +{ +if (flags &XFS_ATTR_PARENT ) { +if (length !=sizeof (struct xfs_parent_name_rec )) +return false; +return xfs_verify_pptr (mp, (struct xfs_parent_name_rec *)name); + } + +return xfs_str_attr_namecheck (name, length); +} +int __init xfs_attr_intent_init_cache (void ) {
libxfs/xfs_attr.h +2 -1
@@ -547,7 +547,8 @@ int xfs_attr_get(struct xfs_da_args *args);int xfs_attr_set (struct xfs_da_args *args);int xfs_attr_set_iter (struct xfs_attr_intent *attr);int xfs_attr_remove_iter (struct xfs_attr_intent *attr); -bool xfs_attr_namecheck (const void *name,size_t length); +bool xfs_attr_namecheck (struct xfs_mount *mp,const void *name,size_t length, +int flags);int xfs_attr_calc_size (struct xfs_da_args *args,int *local);void xfs_init_attr_trans (struct xfs_da_args *args,struct xfs_trans_res *tres,unsigned int *total);
libxfs/xfs_da_format.h +8 -0
@@ -757,6 +757,14 @@ xfs_attr3_leaf_name(xfs_attr_leafblock_t *leafp, int idx)return &((char *)leafp)[be16_to_cpu (entries[idx].nameidx)]; } +static inline int +xfs_attr3_leaf_flags (xfs_attr_leafblock_t *leafp,int idx) +{ +struct xfs_attr_leaf_entry *entries =xfs_attr3_leaf_entryp (leafp); + +return entries[idx].flags; +} +static inline xfs_attr_leaf_name_remote_t *xfs_attr3_leaf_name_remote (xfs_attr_leafblock_t *leafp,int idx) {
repair/attr_repair.c +12 -7
@@ -292,8 +292,9 @@ process_shortform_attr( }/* namecheck checks for null chars in attr names. */ -if (!libxfs_attr_namecheck (currententry->nameval, - currententry->namelen)) { +if (!libxfs_attr_namecheck (mp, currententry->nameval, + currententry->namelen, + currententry->flags)) {do_warn (_ ("entry contains illegal character in shortform attribute name\n" )); junkit =1 ;
@@ -469,12 +470,14 @@ process_leaf_attr_local( xfs_dablk_t da_bno, xfs_ino_t ino) { -xfs_attr_leaf_name_local_t *local; +xfs_attr_leaf_name_local_t *local; +int flags; local =xfs_attr3_leaf_name_local (leaf, i); + flags =xfs_attr3_leaf_flags (leaf, i);if (local->namelen ==0 || - !libxfs_attr_namecheck (local->nameval, - local->namelen)) { + !libxfs_attr_namecheck (mp, local->nameval, + local->namelen, flags)) {do_warn (_ ("attribute entry %d in attr block %u, inode %" PRIu64" has bad name (namelen = %d)\n" ), i, da_bno, ino, local->namelen);
@@ -525,12 +528,14 @@ process_leaf_attr_remote( {xfs_attr_leaf_name_remote_t *remotep;char * value; +int flags; remotep =xfs_attr3_leaf_name_remote (leaf, i); + flags =xfs_attr3_leaf_flags (leaf, i); if (remotep->namelen == 0 || - !libxfs_attr_namecheck(remotep->name, - remotep->namelen) || + !libxfs_attr_namecheck(mp, remotep->name, + remotep->namelen, flags) || be32_to_cpu(entry->hashval) != libxfs_da_hashname((unsigned char *)&remotep->name[0], remotep->namelen) ||
PATCH 4/20 fs: add FS_XFLAG_VERITY for verity files
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Add extended attribute FS_XFLAG_VERITY for inodes with fs-verity enabled.
--- include/linux.h | 4 ++++ 1 file changed, 4 insertions(+)
include/linux.h +4 -0
@@ -249,6 +249,10 @@ struct fsxattr {#define FS_XFLAG_COWEXTSIZE 0x00010000/* CoW extent size allocator hint */ #endif +#ifndef FS_XFLAG_VERITY +#define FS_XFLAG_VERITY 0x00020000/* fs-verity enabled */ +#endif +/* * Reminder: anything added to this file will be compiled into downstream * userspace projects!
PATCH 5/20 xfs: add attribute type for fs-verity
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
The Merkle tree blocks and descriptor are stored in the extended attributes of the inode. Add new attribute type for fs-verity metadata. Add XFS_ATTR_INTERNAL_MASK to skip parent pointer and fs-verity attributes as those are only for internal use. While we're at it add a few comments in relevant places that internally visible attributes are not suppose to be handled via interface defined in xfs_xattr.c.
--- libxfs/xfs_da_format.h | 10 +++++++++- libxfs/xfs_log_format.h | 1 + 2 files changed, 10 insertions(+), 1 deletion(-)
libxfs/xfs_da_format.h +9 -1
@@ -715,14 +715,22 @@ struct xfs_attr3_leafblock {#define XFS_ATTR_ROOT_BIT 1/* limit access to trusted attrs */ #define XFS_ATTR_SECURE_BIT 2/* limit access to secure attrs */ #define XFS_ATTR_PARENT_BIT 3/* parent pointer attrs */ +#define XFS_ATTR_VERITY_BIT 4/* verity merkle tree and descriptor */ #define XFS_ATTR_INCOMPLETE_BIT 7/* attr in middle of create/delete */ #define XFS_ATTR_LOCAL (1u << XFS_ATTR_LOCAL_BIT)#define XFS_ATTR_ROOT (1u << XFS_ATTR_ROOT_BIT)#define XFS_ATTR_SECURE (1u << XFS_ATTR_SECURE_BIT)#define XFS_ATTR_PARENT (1u << XFS_ATTR_PARENT_BIT) +#define XFS_ATTR_VERITY (1u << XFS_ATTR_VERITY_BIT)#define XFS_ATTR_INCOMPLETE (1u << XFS_ATTR_INCOMPLETE_BIT)#define XFS_ATTR_NSP_ONDISK_MASK \ - (XFS_ATTR_ROOT | XFS_ATTR_SECURE | XFS_ATTR_PARENT) + (XFS_ATTR_ROOT | XFS_ATTR_SECURE | XFS_ATTR_PARENT | \ + XFS_ATTR_VERITY) + +/* +* Internal attributes not exposed to the user +*/ +#define XFS_ATTR_INTERNAL_MASK (XFS_ATTR_PARENT | XFS_ATTR_VERITY)/* * Alignment for namelist and valuelist entries (since they are mixed
libxfs/xfs_log_format.h +1 -0
@@ -975,6 +975,7 @@ struct xfs_icreate_log {#define XFS_ATTRI_FILTER_MASK (XFS_ATTR_ROOT | \ XFS_ATTR_SECURE | \ XFS_ATTR_PARENT | \ + XFS_ATTR_VERITY | \ XFS_ATTR_INCOMPLETE)/*
PATCH 6/20 xfs: add fs-verity ro-compat flag
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
To mark inodes with fs-verity enabled the new XFS_DIFLAG2_VERITY flag will be added in further patch. This requires ro-compat flag to let older kernels know that fs with fs-verity can not be modified.
--- include/xfs_mount.h | 2 ++ libxfs/xfs_format.h | 1 + libxfs/xfs_sb.c | 2 ++ 3 files changed, 5 insertions(+)
include/xfs_mount.h +2 -0
@@ -169,6 +169,7 @@ typedef struct xfs_mount {#define XFS_FEAT_BIGTIME (1ULL << 24)/* large timestamps */ #define XFS_FEAT_NEEDSREPAIR (1ULL << 25)/* needs xfs_repair */ #define XFS_FEAT_NREXT64 (1ULL << 26)/* large extent counters */ +#define XFS_FEAT_VERITY (1ULL << 27)/* fs-verity */ #define __XFS_HAS_FEAT (name,NAME ) \ static inline bool xfs_has_ ## name (struct xfs_mount *mp) \
@@ -213,6 +214,7 @@ __XFS_HAS_FEAT(inobtcounts, INOBTCNT) __XFS_HAS_FEAT(bigtime, BIGTIME) __XFS_HAS_FEAT(needsrepair, NEEDSREPAIR) __XFS_HAS_FEAT(large_extent_counts, NREXT64) +__XFS_HAS_FEAT (verity,VERITY ) /* Kernel mount features that we don't support */#define __XFS_UNSUPP_FEAT (name) \
libxfs/xfs_format.h +1 -0
@@ -353,6 +353,7 @@ xfs_sb_has_compat_feature(#define XFS_SB_FEAT_RO_COMPAT_RMAPBT (1 << 1)/* reverse map btree */ #define XFS_SB_FEAT_RO_COMPAT_REFLINK (1 << 2)/* reflinked files */ #define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3)/* inobt block counts */ +#define XFS_SB_FEAT_RO_COMPAT_VERITY (1 << 4)/* fs-verity */ #define XFS_SB_FEAT_RO_COMPAT_ALL \ (XFS_SB_FEAT_RO_COMPAT_FINOBT | \ XFS_SB_FEAT_RO_COMPAT_RMAPBT | \
libxfs/xfs_sb.c +2 -0
@@ -161,6 +161,8 @@ xfs_sb_version_to_features( features |=XFS_FEAT_REFLINK ;if (sbp->sb_features_ro_compat &XFS_SB_FEAT_RO_COMPAT_INOBTCNT ) features |=XFS_FEAT_INOBTCNT ; +if (sbp->sb_features_ro_compat &XFS_SB_FEAT_RO_COMPAT_VERITY ) + features |=XFS_FEAT_VERITY ;if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_FTYPE ) features |=XFS_FEAT_FTYPE ;if (sbp->sb_features_incompat &XFS_SB_FEAT_INCOMPAT_SPINODES )
PATCH 7/20 xfs: add inode on-disk VERITY flag
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Source kernel commit: ff6c7e66f70cb7239fcc6a1011f47132091d679e
Add flag to mark inodes which have fs-verity enabled on them (i.e. descriptor exist and tree is built).
--- libxfs/xfs_format.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
libxfs/xfs_format.h +3 -1
@@ -1085,16 +1085,18 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)#define XFS_DIFLAG2_COWEXTSIZE_BIT 2/* copy on write extent size hint */ #define XFS_DIFLAG2_BIGTIME_BIT 3/* big timestamps */ #define XFS_DIFLAG2_NREXT64_BIT 4/* large extent counters */ +#define XFS_DIFLAG2_VERITY_BIT 5/* inode sealed by fsverity */ #define XFS_DIFLAG2_DAX (1 << XFS_DIFLAG2_DAX_BIT)#define XFS_DIFLAG2_REFLINK (1 << XFS_DIFLAG2_REFLINK_BIT)#define XFS_DIFLAG2_COWEXTSIZE (1 << XFS_DIFLAG2_COWEXTSIZE_BIT)#define XFS_DIFLAG2_BIGTIME (1 << XFS_DIFLAG2_BIGTIME_BIT)#define XFS_DIFLAG2_NREXT64 (1 << XFS_DIFLAG2_NREXT64_BIT) +#define XFS_DIFLAG2_VERITY (1 << XFS_DIFLAG2_VERITY_BIT)#define XFS_DIFLAG2_ANY \ (XFS_DIFLAG2_DAX | XFS_DIFLAG2_REFLINK | XFS_DIFLAG2_COWEXTSIZE | \ - XFS_DIFLAG2_BIGTIME | XFS_DIFLAG2_NREXT64) + XFS_DIFLAG2_BIGTIME | XFS_DIFLAG2_NREXT64 | XFS_DIFLAG2_VERITY)static inline bool xfs_dinode_has_bigtime (const struct xfs_dinode *dip) {
PATCH 8/20 xfs: add fs-verity support
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Add integration with fs-verity. The XFS store fs-verity metadata in the extended file attributes. The metadata consist of verity descriptor and Merkle tree blocks.
The descriptor is stored under "vdesc" extended attribute. The Merkle tree blocks are stored under binary indexes which are offsets into the Merkle tree.
When fs-verity is enabled on an inode, the XFS_IVERITY_CONSTRUCTION flag is set meaning that the Merkle tree is being build. The initialization ends with storing of verity descriptor and setting inode on-disk flag (XFS_DIFLAG2_VERITY).
The verification on read is done in read path of iomap.
--- libxfs/xfs_attr.c | 12 ++++++++++++ libxfs/xfs_da_format.h | 32 ++++++++++++++++++++++++++++++++ libxfs/xfs_ondisk.h | 4 ++++ 3 files changed, 48 insertions(+)
libxfs/xfs_attr.c +12 -0
@@ -1565,6 +1565,18 @@ xfs_attr_namecheck(return xfs_verify_pptr (mp, (struct xfs_parent_name_rec *)name); } +if (flags &XFS_ATTR_VERITY ) { +/* Merkle tree pages are stored under u64 indexes */ +if (length ==sizeof (struct xfs_verity_merkle_key )) +return true; + +/* Verity descriptor blocks are held in a named attribute. */ +if (length ==XFS_VERITY_DESCRIPTOR_NAME_LEN ) +return true; + +return false; + } +return xfs_str_attr_namecheck (name, length); }
libxfs/xfs_da_format.h +32 -0
@@ -919,4 +919,36 @@ struct xfs_parent_name_irec { uint8_t p_namelen; }; +/* +* fs-verity attribute name format +* +* Merkle tree blocks are stored under extended attributes of the inode. The +* name of the attributes are byte offsets into merkle tree. +*/ +struct xfs_verity_merkle_key { +__be64 vi_merkleoff; +}; + +static inline void +xfs_verity_merkle_key_to_disk ( +struct xfs_verity_merkle_key *key, +uint64_t offset) +{ + key->vi_merkleoff =cpu_to_be64 (offset); +} + +static inline uint64_t +xfs_verity_merkle_key_from_disk ( +const void *attr_name) +{ +const struct xfs_verity_merkle_key *key = attr_name; + +return be64_to_cpu (key->vi_merkleoff); +} + + +/* ondisk xattr name used for the fsverity descriptor */ +#define XFS_VERITY_DESCRIPTOR_NAME "vdesc" +#define XFS_VERITY_DESCRIPTOR_NAME_LEN (sizeof(XFS_VERITY_DESCRIPTOR_NAME) - 1) +#endif /* __XFS_DA_FORMAT_H__ */
libxfs/xfs_ondisk.h +4 -0
@@ -194,6 +194,10 @@ xfs_check_ondisk_structs(void)XFS_CHECK_VALUE (XFS_DQ_BIGTIME_EXPIRY_MIN <<XFS_DQ_BIGTIME_SHIFT ,4 );XFS_CHECK_VALUE (XFS_DQ_BIGTIME_EXPIRY_MAX <<XFS_DQ_BIGTIME_SHIFT ,16299260424LL ); + +/* fs-verity xattrs */ + XFS_CHECK_STRUCT_SIZE(struct xfs_verity_merkle_key, 8); + XFS_CHECK_VALUE(sizeof(XFS_VERITY_DESCRIPTOR_NAME), 6); }#endif /* __XFS_ONDISK_H */
PATCH 9/20 xfs: advertise fs-verity being available on filesystem
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Advertise that this filesystem supports fsverity.
--- libxfs/xfs_fs.h | 1 + libxfs/xfs_sb.c | 2 ++ 2 files changed, 3 insertions(+)
libxfs/xfs_fs.h +1 -0
@@ -239,6 +239,7 @@ typedef struct xfs_fsop_resblks {#define XFS_FSOP_GEOM_FLAGS_BIGTIME (1 << 21)/* 64-bit nsec timestamps */ #define XFS_FSOP_GEOM_FLAGS_INOBTCNT (1 << 22)/* inobt btree counter */ #define XFS_FSOP_GEOM_FLAGS_NREXT64 (1 << 23)/* large extent counters */ +#define XFS_FSOP_GEOM_FLAGS_VERITY (1 << 24)/* fs-verity */ /* * Minimum and maximum sizes need for growth checks.
libxfs/xfs_sb.c +2 -0
@@ -1258,6 +1258,8 @@ xfs_fs_geometry( }if (xfs_has_large_extent_counts (mp)) geo->flags |=XFS_FSOP_GEOM_FLAGS_NREXT64 ; +if (xfs_has_verity (mp)) + geo->flags |=XFS_FSOP_GEOM_FLAGS_VERITY ; geo->rtsectsize = sbp->sb_blocksize; geo->dirblocksize =xfs_dir2_dirblock_bytes (sbp);
PATCH 10/20 xfs: create separate name hash function for xattrs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Create a new hashing function for extended attribute names. The next patch needs this so it can modify the hash strategy for verity xattrs.
--- db/hash.c | 4 ++-- db/metadump.c | 26 +++++++++++++++----------- libxfs/libxfs_api_defs.h | 1 + libxfs/xfs_attr.c | 16 ++++++++++++++-- libxfs/xfs_attr.h | 3 +++ libxfs/xfs_attr_leaf.c | 4 ++-- repair/attr_repair.c | 9 ++++++--- 7 files changed, 43 insertions(+), 20 deletions(-)
db/hash.c +2 -2
@@ -73,7 +73,7 @@ hash_f(if (use_dir2_hash) hashval =libxfs_dir2_hashname (mp, &xname);else - hashval =libxfs_da_hashname (xname.name, xname.len); + hashval =libxfs_attr_hashname (0 , xname.name, xname.len);dbprintf ("0x%x\n" , hashval); }
@@ -306,7 +306,7 @@ collide_xattrs(unsigned long i;int error; - old_hash =libxfs_da_hashname ((uint8_t *)name, namelen); + old_hash =libxfs_attr_hashname (0 , (uint8_t *)name, namelen);if (fd >=0 ) {/*
db/metadump.c +15 -11
@@ -823,6 +823,7 @@ handle_duplicate_name(xfs_dahash_t hash, size_t name_len, unsigned char *name)static inline xfs_dahash_t dirattr_hashname (bool is_dirent, +unsigned int attr_flags,const uint8_t *name,int namelen) {
@@ -835,12 +836,13 @@ dirattr_hashname(return libxfs_dir2_hashname (mp, &xname); } -return libxfs_da_hashname (name, namelen); +return libxfs_attr_hashname (attr_flags, name, namelen); }static void generate_obfuscated_name (xfs_ino_t ino, +unsigned int attr_flags,int namelen,unsigned char *name) {
@@ -866,9 +868,9 @@ generate_obfuscated_name(/* Obfuscate the name (if possible) */ - hash =dirattr_hashname (ino !=0 , name, namelen); + hash =dirattr_hashname (ino !=0 , attr_flags, name, namelen);obfuscate_name (hash, namelen, name, ino !=0 ); -ASSERT (hash ==dirattr_hashname (ino !=0 , name, namelen)); +ASSERT (hash ==dirattr_hashname (ino !=0 , attr_flags, name, namelen));/* * Make sure the name is not something already seen. If we
@@ -945,7 +947,7 @@ process_sf_dir(if (metadump.obfuscate)generate_obfuscated_name (libxfs_dir2_sf_get_ino (mp, sfp, sfep), - namelen, &sfep->name[0 ]); +0 , namelen, &sfep->name[0 ]); sfep = (xfs_dir2_sf_entry_t *)((char *)sfep +libxfs_dir2_sf_entsize (mp, sfp, namelen));
@@ -1071,8 +1073,8 @@ process_sf_attr( }if (metadump.obfuscate) { -generate_obfuscated_name (0 , asfep->namelen, - &asfep->nameval[0 ]); +generate_obfuscated_name (0 , asfep->flags, + asfep->namelen, &asfep->nameval[0 ]);memset (&asfep->nameval[asfep->namelen],'v' , asfep->valuelen); }
@@ -1283,7 +1285,7 @@ process_dir_data_block(if (metadump.obfuscate)generate_obfuscated_name (be64_to_cpu (dep->inumber), - dep->namelen, &dep->name[0 ]); +0 , dep->namelen, &dep->name[0 ]); dir_offset += length; ptr += length;/* Zero the unused space after name, up to the tag */
@@ -1452,8 +1454,9 @@ process_attr_block(break ; }if (metadump.obfuscate) { -generate_obfuscated_name (0 , local->namelen, - &local->nameval[0 ]); +generate_obfuscated_name (0 , entry->flags, + local->namelen, + &local->nameval[0 ]);memset (&local->nameval[local->namelen],'v' ,be16_to_cpu (local->valuelen)); }
@@ -1475,8 +1478,9 @@ process_attr_block(break ; }if (metadump.obfuscate) { -generate_obfuscated_name (0 , remote->namelen, - &remote->name[0 ]); +generate_obfuscated_name (0 , entry->flags, + remote->namelen, + &remote->name[0 ]);add_remote_vals (be32_to_cpu (remote->valueblk),be32_to_cpu (remote->valuelen)); }
libxfs/libxfs_api_defs.h +1 -0
@@ -44,6 +44,7 @@#define xfs_attr_set libxfs_attr_set#define xfs_attr_sf_firstentry libxfs_attr_sf_firstentry#define xfs_attr_shortform_verify libxfs_attr_shortform_verify +#define xfs_attr_hashname libxfs_attr_hashname#define __xfs_bmap_add_free __libxfs_bmap_add_free#define xfs_bmap_validate_extent libxfs_bmap_validate_extent
libxfs/xfs_attr.c +14 -2
@@ -234,6 +234,16 @@ xfs_attr_get_ilocked(return xfs_attr_node_get (args); } +/* Compute hash for an extended attribute name. */ +xfs_dahash_t +xfs_attr_hashname ( +unsigned int attr_flags, +const uint8_t *name, +unsigned int namelen) +{ +return xfs_da_hashname (name, namelen); +} +/* * Retrieve an extended attribute by name, and its value if requested. *
@@ -264,7 +274,8 @@ xfs_attr_get( args->geo = args->dp->i_mount->m_attr_geo; args->whichfork =XFS_ATTR_FORK ; - args->hashval =xfs_da_hashname (args->name, args->namelen); + args->hashval =xfs_attr_hashname (args->attr_filter, args->name, + args->namelen);/* Entirely possible to look up a name which doesn't exist */ args->op_flags =XFS_DA_OP_OKNOENT ;
@@ -938,7 +949,8 @@ xfs_attr_set( args->geo = mp->m_attr_geo; args->whichfork =XFS_ATTR_FORK ; - args->hashval =xfs_da_hashname (args->name, args->namelen); + args->hashval =xfs_attr_hashname (args->attr_filter, args->name, + args->namelen);/* * We have no control over the attribute names that userspace passes us
libxfs/xfs_attr.h +3 -0
@@ -619,4 +619,7 @@ extern struct kmem_cache *xfs_attr_intent_cache;int __init xfs_attr_intent_init_cache (void );void xfs_attr_intent_destroy_cache (void ); +xfs_dahash_t xfs_attr_hashname (unsigned int attr_flags, +const uint8_t *name_string,unsigned int name_length); +#endif /* __XFS_ATTR_H__ */
libxfs/xfs_attr_leaf.c +2 -2
@@ -909,8 +909,8 @@ xfs_attr_shortform_to_leaf( nargs.namelen = sfe->namelen; nargs.value = &sfe->nameval[nargs.namelen]; nargs.valuelen = sfe->valuelen; - nargs.hashval =xfs_da_hashname (sfe->nameval, - sfe->namelen); + nargs.hashval =xfs_attr_hashname (sfe->flags, sfe->nameval, + sfe->namelen); nargs.attr_filter = sfe->flags &XFS_ATTR_NSP_ONDISK_MASK ; error =xfs_attr3_leaf_lookup_int (bp, &nargs);/* set a->index */ ASSERT (error == -ENOATTR );
repair/attr_repair.c +6 -3
@@ -492,8 +492,10 @@ process_leaf_attr_local(* ordering anyway in case both the name value and the * hashvalue were wrong but matched. Unlikely, however. */ -if (be32_to_cpu (entry->hashval) !=libxfs_da_hashname ( - &local->nameval[0 ], local->namelen) || +if (be32_to_cpu (entry->hashval) != +libxfs_attr_hashname (entry->flags, + &local->nameval[0 ], + local->namelen) ||be32_to_cpu (entry->hashval) < last_hashval) { do_warn( _("bad hashvalue for attribute entry %d in attr block %u, inode %" PRIu64 "\n"),
@@ -537,7 +539,8 @@ process_leaf_attr_remote( !libxfs_attr_namecheck (mp, remotep->name, remotep->namelen, flags) ||be32_to_cpu (entry->hashval) != -libxfs_da_hashname ((unsigned char *)&remotep->name[0 ], +libxfs_attr_hashname (entry->flags, + (unsigned char *)&remotep->name[0 ], remotep->namelen) ||be32_to_cpu (entry->hashval) < last_hashval || be32_to_cpu(remotep->valueblk) == 0) {
PATCH 11/20 xfs: use merkle tree offset as attr hash
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
I was exploring the fsverity metadata with xfs_db after creating a 220MB verity file, and I noticed the following in the debugger output:
entries[0-75] = [hashval,nameidx,incomplete,root,secure,local,parent,verity] 0:[0,4076,0,0,0,0,0,1]
1:[0,1472,0,0,0,1,0,1]
2:[0x800,4056,0,0,0,0,0,1]
3:[0x800,4036,0,0,0,0,0,1]
...
72:[0x12000,2716,0,0,0,0,0,1]
73:[0x12000,2696,0,0,0,0,0,1]
74:[0x12800,2676,0,0,0,0,0,1]
75:[0x12800,2656,0,0,0,0,0,1]
...
nvlist[0].merkle_off = 0x18000
nvlist[1].merkle_off = 0
nvlist[2].merkle_off = 0x19000
nvlist[3].merkle_off = 0x1000
...
nvlist[71].merkle_off = 0x5b000
nvlist[72].merkle_off = 0x44000
nvlist[73].merkle_off = 0x5c000
nvlist[74].merkle_off = 0x45000
nvlist[75].merkle_off = 0x5d000
Within just this attr leaf block, there are 76 attr entries, but only 38 distinct hash values. There are 415 merkle tree blocks for this file, but we already have hash collisions. This isn't good performance from the standard da hash function because we're mostly shifting and rolling zeroes around.
However, we don't even have to do that much work -- the merkle tree block keys are themslves u64 values. Truncate that value to 32 bits (the size of xfs_dahash_t) and use that for the hash. We won't have any collisions between merkle tree blocks until that tree grows to 2^32nd blocks. On a 4k block filesystem, we won't hit that unless the file contains more than 2^49 bytes, assuming sha256.
As a side effect, the keys for merkle tree blocks get written out in roughly sequential order, though I didn't observe any change in performance.
--- libxfs/xfs_attr.c | 7 +++++++ libxfs/xfs_da_format.h | 2 ++ 2 files changed, 9 insertions(+)
libxfs/xfs_attr.c +7 -0
@@ -241,6 +241,13 @@ xfs_attr_hashname(const uint8_t *name, unsigned int namelen) { + if ((attr_flags & XFS_ATTR_VERITY) && + namelen == sizeof(struct xfs_verity_merkle_key)) { + uint64_t off = xfs_verity_merkle_key_from_disk(name); + +return off >>XFS_VERITY_MIN_MERKLE_BLOCKLOG ; + } +return xfs_da_hashname (name, namelen); }
libxfs/xfs_da_format.h +2 -0
@@ -951,4 +951,6 @@ xfs_verity_merkle_key_from_disk(#define XFS_VERITY_DESCRIPTOR_NAME "vdesc"#define XFS_VERITY_DESCRIPTOR_NAME_LEN (sizeof(XFS_VERITY_DESCRIPTOR_NAME) - 1) +#define XFS_VERITY_MIN_MERKLE_BLOCKLOG (10) +#endif /* __XFS_DA_FORMAT_H__ */
PATCH 12/20 xfs: enable ro-compat fs-verity flag
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
Finalize fs-verity integration in XFS by making kernel fs-verity aware with ro-compat flag.
--- libxfs/xfs_format.h | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
libxfs/xfs_format.h +5 -4
@@ -355,10 +355,11 @@ xfs_sb_has_compat_feature(#define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3)/* inobt block counts */ #define XFS_SB_FEAT_RO_COMPAT_VERITY (1 << 4)/* fs-verity */ #define XFS_SB_FEAT_RO_COMPAT_ALL \ - (XFS_SB_FEAT_RO_COMPAT_FINOBT | \ - XFS_SB_FEAT_RO_COMPAT_RMAPBT | \ - XFS_SB_FEAT_RO_COMPAT_REFLINK| \ - XFS_SB_FEAT_RO_COMPAT_INOBTCNT) + (XFS_SB_FEAT_RO_COMPAT_FINOBT | \ + XFS_SB_FEAT_RO_COMPAT_RMAPBT | \ + XFS_SB_FEAT_RO_COMPAT_REFLINK | \ + XFS_SB_FEAT_RO_COMPAT_INOBTCNT | \ + XFS_SB_FEAT_RO_COMPAT_VERITY)#define XFS_SB_FEAT_RO_COMPAT_UNKNOWN ~XFS_SB_FEAT_RO_COMPAT_ALLstatic inline bool xfs_sb_has_ro_compat_feature(
PATCH 13/20 libfrog: add fsverity to xfs_report_geom output
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Announce the presence of fsverity on a filesystem.
--- libfrog/fsgeom.c | 4 ++++ 1 file changed, 4 insertions(+)
libfrog/fsgeom.c +4 -0
@@ -31,6 +31,7 @@ xfs_report_geom(int bigtime_enabled;int inobtcount;int nrext64; +int verity; isint = geo->logstart >0 ; lazycount = geo->flags &XFS_FSOP_GEOM_FLAGS_LAZYSB ?1 :0 ;
@@ -49,12 +50,14 @@ xfs_report_geom( bigtime_enabled = geo->flags &XFS_FSOP_GEOM_FLAGS_BIGTIME ?1 :0 ; inobtcount = geo->flags &XFS_FSOP_GEOM_FLAGS_INOBTCNT ?1 :0 ; nrext64 = geo->flags &XFS_FSOP_GEOM_FLAGS_NREXT64 ?1 :0 ; + verity = geo->flags &XFS_FSOP_GEOM_FLAGS_VERITY ?1 :0 ; printf(_( "meta-data=%-22s isize=%-6d agcount=%u, agsize=%u blks\n" " =%-22s sectsz=%-5u attr=%u, projid32bit=%u\n" " =%-22s crc=%-8u finobt=%u, sparse=%u, rmapbt=%u\n" " =%-22s reflink=%-4u bigtime=%u inobtcount=%u nrext64=%u\n" +" =%-22s verity=%u\n" "data =%-22s bsize=%-6u blocks=%llu, imaxpct=%u\n" " =%-22s sunit=%-6u swidth=%u blks\n" "naming =version %-14u bsize=%-6u ascii-ci=%d, ftype=%d\n"
@@ -65,6 +68,7 @@ xfs_report_geom("" , geo->sectsize, attrversion, projid32bit,"" , crcs_enabled, finobt_enabled, spinodes, rmapbt_enabled,"" , reflink_enabled, bigtime_enabled, inobtcount, nrext64, +"" , verity,"" , geo->blocksize, (unsigned long long )geo->datablocks, geo->imaxpct, "", geo->sunit, geo->swidth,
PATCH 14/20 xfs_db: introduce attr_modify command
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
This command allows for writing value over already existing value of inode's extended attribute. The difference from 'write' command is that extended attribute can be addressed by name and new value is written over old value.
The command also allows addressing via binary names (introduced by parent pointers). This can be done by specified name length (-m) and value in #hex format.
Example:
# Modify attribute with name #00000042 by overwriting 8 # bytes at offset 3 with value #0000000000FF00FF attr_modify -o 3 -m 4 -v 8 #42 #FF00FF
--- db/attrset.c | 202 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++- db/write.c | 2 - db/write.h | 1 3 files changed, 202 insertions(+), 3 deletions(-)
db/attrset.c +200 -2
@@ -16,10 +16,12 @@#include "field.h" #include "inode.h" #include "malloc.h" +#include "write.h" #include <sys/xattr.h> static int attr_set_f (int argc,char **argv);static int attr_remove_f (int argc,char **argv); +static int attr_modify_f (int argc,char **argv);static void attrset_help (void ); static const cmdinfo_t attr_set_cmd =
@@ -30,6 +32,11 @@ static const cmdinfo_t attr_remove_cmd = {"attr_remove" ,"aremove" , attr_remove_f,1 ,-1 ,0 ,N_ ("[-r|-s|-u] [-n] name" ), N_("remove the named attribute from the current inode"), attrset_help }; +static const cmdinfo_t attr_modify_cmd = + {"attr_modify" ,"amodify" , attr_modify_f,1 ,-1 ,0 , +N_ ("[-r|-s|-u] [-o n] [-v n] [-m n] name value" ), +N_ ("modify value of the named attribute of the current inode" ), + attrset_help };static void attrset_help (void )
@@ -38,8 +45,9 @@ attrset_help(void)"\n" " The 'attr_set' and 'attr_remove' commands provide interfaces for debugging\n" " the extended attribute allocation and removal code.\n" -" Both commands require an attribute name to be specified, and the attr_set\n" -" command allows an optional value length (-v) to be provided as well.\n" +" Both commands together with 'attr_modify' require an attribute name to be\n" +" specified. The attr_set and attr_modify commands allow an optional value\n" +" length (-v) to be provided as well.\n" " There are 4 namespace flags:\n" " -r -- 'root'\n" " -u -- 'user' (default)\n"
@@ -48,6 +56,9 @@ attrset_help(void)" For attr_set, these options further define the type of set operation:\n" " -C -- 'create' - create attribute, fail if it already exists\n" " -R -- 'replace' - replace attribute, fail if it does not exist\n" +" attr_modify command provides more of the following options:\n" +" -m -- 'name length' - specify length of the name (handy with binary names)\n" +" -o -- 'value offset' - offset new value within old attr's value\n" " The backward compatibility mode 'noattr2' can be emulated (-n) also.\n" "\n")); }
@@ -60,6 +71,7 @@ attrset_init(void)add_command (&attr_set_cmd);add_command (&attr_remove_cmd); +add_command (&attr_modify_cmd); } static int
@@ -263,3 +275,189 @@ attr_remove_f(libxfs_irele (args.dp);return 0 ; } + +static int +attr_modify_f ( +int argc, +char **argv) +{ +struct xfs_da_args args = { }; +int c; +int offset =0 ; +char *sp; +char *converted; +uint8_t *name; +int namelen =0 ; +uint8_t *value; +int valuelen =0 ; + +if (cur_typ ==NULL ) { +dbprintf (_ ("no current type\n" )); +return 0 ; + } + +if (cur_typ->typnm !=TYP_INODE ) { +dbprintf (_ ("current type is not inode\n" )); +return 0 ; + } + +while ((c =getopt (argc, argv,"rusnv:o:m:" )) !=EOF ) { +switch (c) { +/* namespaces */ +case 'r' : + args.attr_filter |=LIBXFS_ATTR_ROOT ; + args.attr_filter &= ~LIBXFS_ATTR_SECURE ; +break ; +case 'u' : + args.attr_filter &= ~(LIBXFS_ATTR_ROOT | +LIBXFS_ATTR_SECURE ); +break ; +case 's' : + args.attr_filter |=LIBXFS_ATTR_SECURE ; + args.attr_filter &= ~LIBXFS_ATTR_ROOT ; +break ; + +case 'n' : +/* +* We never touch attr2 these days; leave this here to +* avoid breaking scripts. +*/ +break ; + +case 'o' : + offset =strtol (optarg, &sp,0 ); +if (*sp !='\0' || offset <0 || offset >64 *1024 ) { +dbprintf (_ ("bad attr_modify offset %s\n" ), + optarg); +return 0 ; + } +break ; + +case 'v' : + valuelen =strtol (optarg, &sp,0 ); +if (*sp !='\0' || offset <0 || valuelen >64 *1024 ) { +dbprintf (_ ("bad attr_modify value len %s\n" ), + optarg); +return 0 ; + } +break ; + +case 'm' : + namelen =strtol (optarg, &sp,0 ); +if (*sp !='\0' || offset <0 || namelen >MAXNAMELEN ) { +dbprintf (_ ("bad attr_modify name len %s\n" ), + optarg); +return 0 ; + } +break ; + +default : +dbprintf (_ ("bad option for attr_modify command\n" )); +return 0 ; + } + } + +if (optind != argc -2 ) { +dbprintf (_ ("too few options for attr_modify\n" )); +return 0 ; + } + +if (namelen >=MAXNAMELEN ) { +dbprintf (_ ("name too long\n" )); +return 0 ; + } + +if (!namelen) { +if (argv[optind][0 ] =='#' ) + namelen =strlen (argv[optind])/2 ; +if (argv[optind][0 ] =='"' ) + namelen =strlen (argv[optind]) -2 ; + } + + name =xcalloc (namelen,sizeof (uint8_t )); + converted =convert_arg (argv[optind], (int )(namelen*8 )); +if (!converted) { +dbprintf (_ ("invalid name\n" )); + goto out_free_name; + } + +memcpy (name, converted, namelen); + args.name = (const uint8_t *)name; + args.namelen = namelen; + + optind++; + +if (valuelen >64 *1024 ) { +dbprintf (_ ("value too long\n" )); + goto out_free_name; + } + +if (!valuelen) { +if (argv[optind][0 ] =='#' ) + valuelen =strlen (argv[optind])/2 ; +if (argv[optind][0 ] =='"' ) + valuelen =strlen (argv[optind]) -2 ; + } + +if ((valuelen + offset) >64 *1024 ) { +dbprintf (_ ("offsetted value too long\n" )); + goto out_free_name; + } + + value =xcalloc (valuelen,sizeof (uint8_t )); + converted =convert_arg (argv[optind], (int )(valuelen*8 )); +if (!converted) { +dbprintf (_ ("invalid value\n" )); + goto out_free_value; + } +memcpy (value, converted, valuelen); + +if (libxfs_iget (mp,NULL , iocur_top->ino,0 , &args.dp)) { +dbprintf (_ ("failed to iget inode %llu\n" ), + (unsigned long long )iocur_top->ino); + goto out; + } + +if (libxfs_attr_get (&args)) { +dbprintf (_ ("failed to get attr '%s' from inode %llu\n" ), + args.name, (unsigned long long )iocur_top->ino); + goto out; + } + +if (valuelen + offset > args.valuelen) { +dbprintf (_ ("new value too long\n" )); + goto out; + } + +/* As args.valuelen is now set let's get args.value */ +if (libxfs_attr_get (&args)) { +dbprintf (_ ("failed to get attr '%s' from inode %llu\n" ), + args.name, (unsigned long long )iocur_top->ino); + goto out; + } + +/* modify value */ +memcpy ((uint8_t *)args.value + offset, value, valuelen); + + args.attr_flags =XATTR_REPLACE ; + args.attr_flags &= ~XATTR_CREATE ; +if (libxfs_attr_set (&args)) { +dbprintf (_ ("failed to set attr '%s' from inode %llu\n" ), + (unsigned char *)args.name, + (unsigned long long )iocur_top->ino); + goto out; + } + +/* refresh with updated inode contents */ +set_cur_inode (iocur_top->ino); + +out: +if (args.dp) +libxfs_irele (args.dp); +xfree (args.value); +out_free_value: +xfree (value); +out_free_name: +xfree (name); +return 0 ; +}
db/write.c +1 -1
@@ -511,7 +511,7 @@ convert_oct(* are adjusted in the buffer so that the first input bit is to be be written to * the first bit in the output. */ -static char * +char *convert_arg (char *arg,int bit_length)
db/write.h +1 -0
@@ -6,6 +6,7 @@struct field ; +extern char *convert_arg (char *arg,int bit_length);extern void write_init (void );extern void write_block (const field_t *fields,int argc,char **argv);extern void write_struct (const field_t *fields,int argc,char **argv);
PATCH 15/20 xfs_db: make attr_set/remove/modify be able to handle fs-verity attrs
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
--- db/attrset.c | 28 ++++++++++++++++++++++------ libxfs/libxfs_api_defs.h | 1 + 2 files changed, 23 insertions(+), 6 deletions(-)
db/attrset.c +22 -6
@@ -26,15 +26,15 @@ static void attrset_help(void);static const cmdinfo_t attr_set_cmd = {"attr_set" ,"aset" , attr_set_f,1 ,-1 ,0 , -N_ ("[-r|-s|-u] [-n] [-R|-C] [-v n] name" ), +N_ ("[-r|-s|-u|-f] [-n] [-R|-C] [-v n] name" ),N_ ("set the named attribute on the current inode" ), attrset_help };static const cmdinfo_t attr_remove_cmd = {"attr_remove" ,"aremove" , attr_remove_f,1 ,-1 ,0 , -N_ ("[-r|-s|-u] [-n] name" ), +N_ ("[-r|-s|-u|-f] [-n] name" ),N_ ("remove the named attribute from the current inode" ), attrset_help };static const cmdinfo_t attr_modify_cmd = {"attr_modify" ,"amodify" , attr_modify_f,1 ,-1 ,0 , -N_ ("[-r|-s|-u] [-o n] [-v n] [-m n] name value" ), +N_ ("[-r|-s|-u|-f] [-o n] [-v n] [-m n] name value" ),N_ ("modify value of the named attribute of the current inode" ), attrset_help };
@@ -52,6 +52,7 @@ attrset_help(void)" -r -- 'root'\n" " -u -- 'user' (default)\n" " -s -- 'secure'\n" +" -f -- 'fs-verity'\n" "\n" " For attr_set, these options further define the type of set operation:\n" " -C -- 'create' - create attribute, fail if it already exists\n"
@@ -92,7 +93,7 @@ attr_set_f(return 0 ; } -while ((c =getopt (argc, argv,"rusCRnv:" )) !=EOF ) { +while ((c =getopt (argc, argv,"rusfCRnv:" )) !=EOF ) {switch (c) {/* namespaces */ case 'r' :
@@ -107,6 +108,11 @@ attr_set_f( args.attr_filter |=LIBXFS_ATTR_SECURE ; args.attr_filter &= ~LIBXFS_ATTR_ROOT ;break ; +case 'f' : + args.attr_filter |=LIBXFS_ATTR_VERITY ; + args.attr_filter &= ~(LIBXFS_ATTR_ROOT | +LIBXFS_ATTR_SECURE ); +break ;/* modifiers */ case 'C' :
@@ -208,7 +214,7 @@ attr_remove_f(return 0 ; } -while ((c =getopt (argc, argv,"rusn" )) !=EOF ) { +while ((c =getopt (argc, argv,"rusfn" )) !=EOF ) {switch (c) {/* namespaces */ case 'r' :
@@ -223,6 +229,11 @@ attr_remove_f( args.attr_filter |=LIBXFS_ATTR_SECURE ; args.attr_filter &= ~LIBXFS_ATTR_ROOT ;break ; +case 'f' : + args.attr_filter |=LIBXFS_ATTR_VERITY ; + args.attr_filter &= ~(LIBXFS_ATTR_ROOT | +LIBXFS_ATTR_SECURE ); +break ;case 'n' :/*
@@ -301,7 +312,7 @@ attr_modify_f(return 0 ; } -while ((c =getopt (argc, argv,"rusnv:o:m:" )) !=EOF ) { +while ((c =getopt (argc, argv,"rusfnv:o:m:" )) !=EOF ) {switch (c) {/* namespaces */ case 'r' :
@@ -316,6 +327,11 @@ attr_modify_f( args.attr_filter |=LIBXFS_ATTR_SECURE ; args.attr_filter &= ~LIBXFS_ATTR_ROOT ;break ; +case 'f' : + args.attr_filter |=LIBXFS_ATTR_VERITY ; + args.attr_filter &= ~(LIBXFS_ATTR_ROOT | +LIBXFS_ATTR_SECURE ); +break ;case 'n' :/*
libxfs/libxfs_api_defs.h +1 -0
@@ -15,6 +15,7 @@*/ #define LIBXFS_ATTR_ROOT XFS_ATTR_ROOT#define LIBXFS_ATTR_SECURE XFS_ATTR_SECURE +#define LIBXFS_ATTR_VERITY XFS_ATTR_VERITY#define xfs_agfl_size libxfs_agfl_size#define xfs_agfl_walk libxfs_agfl_walk
PATCH 16/20 man: document attr_modify command
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Add some documentation for the new attr_modify command. I'm not sure all what this this supposed to do, but there needs to be /something/ to satisfy the documentation tests.
--- man/man8/xfs_db.8 | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+)
man/man8/xfs_db.8 +34 -0
@@ -184,6 +184,40 @@ Displays the length, free block count, per-AG reservation size, and per-AG reservation usage for a given AG. If no argument is given, display information for all AGs. .TP +.BI "attr_modify [\-r|\-u|\-s|\-f] [\-o n] [\-v n] [\-m n] name value +Modifies an extended attribute on the current file with the given name. + +If the +.B name +is a string that can be converted into an integer value, it will be. +.RS 1.0i +.TP 0.4i +.B \-r +Sets the attribute in the root namespace. +Only one namespace option can be specified. +.TP +.B \-u +Sets the attribute in the user namespace. +Only one namespace option can be specified. +.TP +.B \-s +Sets the attribute in the secure namespace. +Only one namespace option can be specified. +.TP +.B \-f +Sets the attribute in the verity namespace. +Only one namespace option can be specified. +.TP +.B \-m +Length of the attr name. +.TP +.B \-o +Offset into the attr value to place the new contents. +.TP +.B \-v +Length of the attr value. +.RE +.TP .BI "attr_remove [\-r|\-u|\-s] [\-n] " name Remove the specified extended attribute from the current file. .RS 1.0i
PATCH 17/20 xfs_db: dump verity features and metadata
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Teach the debugger how to decode the merkle tree block number in the attr name, and to display the fact that this is a verity filesystem.
--- db/sb.c | 2 ++ 1 file changed, 2 insertions(+)
db/sb.c +2 -0
@@ -706,6 +706,8 @@ version_string(strcat (s,",NEEDSREPAIR" );if (xfs_has_large_extent_counts (mp))strcat (s,",NREXT64" ); +if (xfs_has_verity (mp)) +strcat (s,",VERITY" );return s; }
PATCH 18/20 xfs_db: dump merkle tree data
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Teach the debugger to dump the specific fields in the fsverity xattr blocks.
--- db/attr.c | 94 +++++++++++++++++++++++++++++++++++++++++++++++++++++++- db/attrshort.c | 22 +++++++++++++ 2 files changed, 115 insertions(+), 1 deletion(-)
db/attr.c +93 -1
@@ -33,6 +33,9 @@ static int attr_remote_data_count(void *obj, int startoff);static int attr3_remote_hdr_count (void *obj,int startoff);static int attr3_remote_data_count (void *obj,int startoff); +static int attr_leaf_name_local_merkle_count (void *obj,int startoff); +static int attr_leaf_name_remote_merkle_count (void *obj,int startoff); +const field_t attr_hfld[] = { {"" ,FLDT_ATTR ,OI (0 ),C1 ,0 ,TYP_NONE }, {NULL }
@@ -82,6 +85,9 @@ const field_t attr_leaf_entry_flds[] = { {"local" ,FLDT_UINT1 ,OI (LEOFF (flags) +bitsz (uint8_t) -XFS_ATTR_LOCAL_BIT -1 ),C1 ,0 , TYP_NONE }, + { "verity", FLDT_UINT1, +OI (LEOFF (flags) +bitsz (uint8_t) -XFS_ATTR_VERITY_BIT -1 ),C1 ,0 , + TYP_NONE }, { "pad2", FLDT_UINT8X, OI(LEOFF(pad2)), C1, FLD_SKIPALL, TYP_NONE }, { NULL } };
@@ -108,6 +114,10 @@ const field_t attr_leaf_map_flds[] = {#define LNOFF (f) bitize(offsetof(xfs_attr_leaf_name_local_t, f))#define LVOFF (f) bitize(offsetof(xfs_attr_leaf_name_remote_t, f)) +#define MKLOFF (f) bitize(offsetof(xfs_attr_leaf_name_local_t, nameval) + \ + offsetof(struct xfs_verity_merkle_key, f)) +#define MKROFF (f) bitize(offsetof(xfs_attr_leaf_name_remote_t, name) + \ + offsetof(struct xfs_verity_merkle_key, f))const field_t attr_leaf_name_flds[] = { {"valuelen" ,FLDT_UINT16D ,OI (LNOFF (valuelen)), attr_leaf_name_local_count,FLD_COUNT ,TYP_NONE },
@@ -115,6 +125,8 @@ const field_t attr_leaf_name_flds[] = { attr_leaf_name_local_count, FLD_COUNT, TYP_NONE }, {"name" ,FLDT_CHARNS ,OI (LNOFF (nameval)), attr_leaf_name_local_name_count, FLD_COUNT, TYP_NONE }, + { "merkle_off", FLDT_UINT64X, OI(MKLOFF(vi_merkleoff)), + attr_leaf_name_local_merkle_count, FLD_COUNT, TYP_NONE }, { "value", FLDT_CHARNS, attr_leaf_name_local_value_offset, attr_leaf_name_local_value_count, FLD_COUNT|FLD_OFFSET, TYP_NONE }, { "valueblk", FLDT_UINT32X, OI(LVOFF(valueblk)),
@@ -125,6 +137,8 @@ const field_t attr_leaf_name_flds[] = { attr_leaf_name_remote_count, FLD_COUNT, TYP_NONE }, {"name" ,FLDT_CHARNS ,OI (LVOFF (name)), attr_leaf_name_remote_name_count, FLD_COUNT, TYP_NONE }, + { "merkle_off", FLDT_UINT64X, OI(MKROFF(vi_merkleoff)), + attr_leaf_name_remote_merkle_count, FLD_COUNT, TYP_NONE }, { NULL } };
@@ -258,7 +272,19 @@ __attr_leaf_name_local_count( struct xfs_attr_leaf_entry *e, int i) { -return (e->flags &XFS_ATTR_LOCAL ) !=0 ; +struct xfs_attr_leaf_name_local *l; + +if (!(e->flags &XFS_ATTR_LOCAL )) +return 0 ; + +if ((e->flags &XFS_ATTR_NSP_ONDISK_MASK ) ==XFS_ATTR_VERITY ) { + l =xfs_attr3_leaf_name_local (leaf, i); + +if (l->namelen ==sizeof (struct xfs_verity_merkle_key )) +return 0 ; + } + +return 1 ; } static int
@@ -270,6 +296,64 @@ attr_leaf_name_local_count( __attr_leaf_name_local_count); } +static int +__attr_leaf_name_local_merkle_count ( +struct xfs_attr_leafblock *leaf, +struct xfs_attr_leaf_entry *e, +int i) +{ +struct xfs_attr_leaf_name_local *l; + +if ((e->flags &XFS_ATTR_NSP_ONDISK_MASK ) !=XFS_ATTR_VERITY ) +return 0 ; +if (!(e->flags &XFS_ATTR_LOCAL )) +return 0 ; + + l =xfs_attr3_leaf_name_local (leaf, i); +if (l->namelen !=sizeof (struct xfs_verity_merkle_key )) +return 0 ; + +return 1 ; +} + +static int +attr_leaf_name_local_merkle_count ( +void *obj, +int startoff) +{ +return attr_leaf_entry_walk (obj, startoff, + __attr_leaf_name_local_merkle_count); +} + +static int +__attr_leaf_name_remote_merkle_count ( +struct xfs_attr_leafblock *leaf, +struct xfs_attr_leaf_entry *e, +int i) +{ +struct xfs_attr_leaf_name_remote *r; + +if ((e->flags &XFS_ATTR_NSP_ONDISK_MASK ) !=XFS_ATTR_VERITY ) +return 0 ; +if (e->flags &XFS_ATTR_LOCAL ) +return 0 ; + + r =xfs_attr3_leaf_name_remote (leaf, i); +if (r->namelen !=sizeof (struct xfs_verity_merkle_key )) +return 0 ; + +return 1 ; +} + +static int +attr_leaf_name_remote_merkle_count ( +void *obj, +int startoff) +{ +return attr_leaf_entry_walk (obj, startoff, + __attr_leaf_name_remote_merkle_count); +} + static int __attr_leaf_name_local_name_count( struct xfs_attr_leafblock *leaf,
@@ -282,6 +366,10 @@ __attr_leaf_name_local_name_count(return 0 ; l =xfs_attr3_leaf_name_local (leaf, i); +if ((e->flags &XFS_ATTR_NSP_ONDISK_MASK ) ==XFS_ATTR_VERITY && + l->namelen ==sizeof (struct xfs_verity_merkle_key )) +return 0 ; +return l->namelen; }
@@ -373,6 +461,10 @@ __attr_leaf_name_remote_name_count(return 0 ; r =xfs_attr3_leaf_name_remote (leaf, i); +if ((e->flags &XFS_ATTR_NSP_ONDISK_MASK ) ==XFS_ATTR_VERITY && + r->namelen ==sizeof (struct xfs_verity_merkle_key )) +return 0 ; +return r->namelen; }
db/attrshort.c +22 -0
@@ -13,6 +13,7 @@#include "attrshort.h" static int attr_sf_entry_name_count (void *obj,int startoff); +static int attr_sf_entry_merkle_count (void *obj,int startoff);static int attr_sf_entry_value_count (void *obj,int startoff);static int attr_sf_entry_value_offset (void *obj,int startoff,int idx);static int attr_shortform_list_count (void *obj,int startoff);
@@ -33,6 +34,8 @@ const field_t attr_sf_hdr_flds[] = { };#define EOFF (f) bitize(offsetof(struct xfs_attr_sf_entry, f)) +#define MKOFF (f) bitize(offsetof(struct xfs_attr_sf_entry, nameval) + \ + offsetof(struct xfs_verity_merkle_key, f))const field_t attr_sf_entry_flds[] = { {"namelen" ,FLDT_UINT8D ,OI (EOFF (namelen)),C1 ,0 ,TYP_NONE }, {"valuelen" ,FLDT_UINT8D ,OI (EOFF (valuelen)),C1 ,0 ,TYP_NONE },
@@ -43,13 +46,32 @@ const field_t attr_sf_entry_flds[] = { {"secure" ,FLDT_UINT1 ,OI (EOFF (flags) +bitsz (uint8_t) -XFS_ATTR_SECURE_BIT -1 ),C1 ,0 , TYP_NONE }, + { "verity", FLDT_UINT1, +OI (EOFF (flags) +bitsz (uint8_t) -XFS_ATTR_VERITY_BIT -1 ),C1 ,0 , + TYP_NONE }, { "name", FLDT_CHARNS, OI(EOFF(nameval)), attr_sf_entry_name_count, FLD_COUNT, TYP_NONE }, + { "merkle_off", FLDT_UINT32X, OI(MKOFF(vi_merkleoff)), + attr_sf_entry_merkle_count, FLD_COUNT, TYP_NONE }, { "value", FLDT_CHARNS, attr_sf_entry_value_offset, attr_sf_entry_value_count, FLD_COUNT|FLD_OFFSET, TYP_NONE }, { NULL } }; +static int +attr_sf_entry_merkle_count ( +void *obj, +int startoff) +{ +struct xfs_attr_sf_entry *e; + +ASSERT (bitoffs (startoff) ==0 ); + e = (struct xfs_attr_sf_entry *)((char *)obj +byteize (startoff)); +if ((e->flags &XFS_ATTR_NSP_ONDISK_MASK ) ==XFS_ATTR_VERITY ) +return 1 ; +return 0 ; +} + static int attr_sf_entry_name_count( void *obj,
PATCH 19/20 xfs_repair: junk fsverity xattrs when unnecessary
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Remove any fs-verity extended attributes when the filesystem doesn't support fs-verity.
--- repair/attr_repair.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
repair/attr_repair.c +24 -0
@@ -313,6 +313,13 @@ process_shortform_attr(NULL , currententry->namelen, currententry->valuelen); +if ((currententry->flags &XFS_ATTR_VERITY ) && + !xfs_has_verity (mp)) { +do_warn ( +_ ("verity metadata found on filesystem that doesn't support verity\n" )); + junkit |=1 ; + } + remainingspace = remainingspace -xfs_attr_sf_entsize (currententry);
@@ -513,6 +520,15 @@ process_leaf_attr_local(return -1 ; } } + +if ((entry->flags &XFS_ATTR_VERITY ) && !xfs_has_verity (mp)) { +do_warn ( +_ ("verity metadata found in attribute entry %d in attr block %u, inode %" + PRIu64" on filesystem that doesn't support verity\n" ), + i, da_bno, ino); +return -1 ; + } +return xfs_attr_leaf_entsize_local (local->namelen,be16_to_cpu (local->valuelen)); }
@@ -549,6 +565,14 @@ process_leaf_attr_remote(return -1 ; } +if ((entry->flags &XFS_ATTR_VERITY ) && !xfs_has_verity (mp)) { +do_warn ( +_ ("verity metadata found in attribute entry %d in attr block %u, inode %" + PRIu64" on filesystem that doesn't support verity\n" ), + i, da_bno, ino); +return -1 ; + } + value =malloc (be32_to_cpu (remotep->valuelen));if (value ==NULL ) { do_warn(
PATCH 20/20 mkfs.xfs: add verity parameter
In reply to Darrick J. WongFrom: Andrey Albershteyn <[email protected]>
fs-verity brings on-disk changes (inode flag). Add parameter to enable (default disabled) fs-verity flag in superblock. This will make newly create filesystem read-only for older kernels.
--- man/man8/mkfs.xfs.8.in | 4 ++++ mkfs/xfs_mkfs.c | 19 +++++++++++++++++-- 2 files changed, 21 insertions(+), 2 deletions(-)
man/man8/mkfs.xfs.8.in +4 -0
@@ -670,6 +670,10 @@ If the value is omitted, 1 is assumed. This feature will be enabled when possible. This feature is only available for filesystems formatted with -m crc=1. .TP +.BI verity[= value] +This flag activates verity support, which enables sealing of regular file data +with hashes and cryptographic signatures. +This feature is only available for filesystems formatted with -m crc=1. .RE .PP .PD 0
mkfs/xfs_mkfs.c +17 -2
@@ -90,6 +90,7 @@ enum {I_PROJID32BIT ,I_SPINODES ,I_NREXT64 , +I_VERITY , I_MAX_OPTS, };
@@ -469,6 +470,7 @@ static struct opt_params iopts = { [I_PROJID32BIT] = "projid32bit", [I_SPINODES] = "sparse", [I_NREXT64] = "nrext64", + [I_VERITY] = "verity", [I_MAX_OPTS ] =NULL , }, .subopt_params = {
@@ -523,7 +525,13 @@ static struct opt_params iopts = { .minval = 0, .maxval = 1, .defaultval = 1, - } + }, + { .index = I_VERITY, + .conflicts = { { NULL, LAST_CONFLICT } }, + .minval = 0, + .maxval = 1, + .defaultval = 1, + }, }, };
@@ -889,6 +897,7 @@ struct sb_feat_args {bool nodalign;bool nortalign;bool nrext64; +bool verity;/* XFS_SB_FEAT_RO_COMPAT_VERITY */ };struct cli_params {
@@ -1024,7 +1033,7 @@ usage( void ) sectsize=num,concurrency=num]\n\ /* force overwrite */ [-f]\n\ /* inode size */ [-i perblock=n|size=num,maxpct=n,attr=0|1|2,\n\ - projid32bit=0|1,sparse=0|1,nrext64=0|1]\n\ + projid32bit=0|1,sparse=0|1,nrext64=0|1,verity=0|1]\n\ /* no discard */ [-K]\n\ /* log subvol */ [-l agnum=n,internal,size=num,logdev=xxx,version=n\n\ sunit=value|su=num,sectsize=num,lazy-count=0|1,\n\
@@ -1722,6 +1731,9 @@ inode_opts_parser(case I_NREXT64 : cli->sb_feat.nrext64 =getnum (value, opts, subopt);break ; +case I_VERITY : + cli->sb_feat.verity =getnum (value, opts, subopt); +break ;default :return -EINVAL ; }
@@ -3478,6 +3490,8 @@ sb_set_features( sbp->sb_features_ro_compat |=XFS_SB_FEAT_RO_COMPAT_REFLINK ;if (fp->inobtcnt) sbp->sb_features_ro_compat |=XFS_SB_FEAT_RO_COMPAT_INOBTCNT ; +if (fp->verity) + sbp->sb_features_ro_compat |=XFS_SB_FEAT_RO_COMPAT_VERITY ;if (fp->bigtime) sbp->sb_features_incompat |=XFS_SB_FEAT_INCOMPAT_BIGTIME ;
@@ -4339,6 +4353,7 @@ main( .nortalign = false, .bigtime = true, .nrext64 = true, + .verity = false,/* * When we decide to enable a new feature by default, * please remember to update the mkfs conf files.
PATCH 1/1 fstests: fs-verity support for XFS
In reply to Darrick J. WongHi all,
From Darrick J. Wong:
This v5.3 patchset builds upon v5.2 of Andrey's patchset to implement fsverity for XFS.
The biggest thing that I didn't like in the v5 patchset is the abuse of the data device's buffer cache to store the incore version of the merkle tree blocks. Not only do verity state flags end up in xfs_buf, but the double-alloc flag wastes memory and doesn't remain internally consistent if the xattrs shift around.
I replaced all of that with a per-inode xarray that indexes incore merkle tree blocks. For cache hits, this dramatically reduces the amount of work that xfs has to do to feed fsverity. The per-block overhead is much lower (8 bytes instead of ~300 for xfs_bufs), and we no longer have to entertain layering violations in the buffer cache. I also added a per-filesystem shrinker so that reclaim can cull cached merkle tree blocks, starting with the leaf tree nodes.
I've also rolled in some changes recommended by the fsverity maintainer, fixed some organization and naming problems in the xfs code, fixed a collision in the xfs_inode iflags, and improved dead merkle tree cleanup per the discussion of the v5 series. At this point I'm happy enough with this code to start integrating and testing it in my trees, so it's time to send it out a coherent patchset for comments.
For v5.3, I've added bits and pieces of online and offline repair support, reduced the size of partially filled merkle tree blocks by removing trailing zeroes, changed the xattr hash function to better avoid collisions between merkle tree keys, made the fsverity invalidation bitmap unnecessary, and made it so that we can save space on sparse verity files by not storing merkle tree blocks that hash totally zeroed data blocks.
From Andrey Albershteyn:
Here's v5 of my patchset of adding fs-verity support to XFS.
This implementation uses extended attributes to store fs-verity metadata. The Merkle tree blocks are stored in the remote extended attributes. The names are offsets into the tree.
A few key points of this patchset:
- fs-verity can work with Merkle tree blocks based caching (xfs) and PAGE caching (ext4, f2fs, btrfs)
- iomap does fs-verity verification
- In XFS, fs-verity metadata is stored in extended attributes
- per-sb workqueue for verification processing
- Inodes with fs-verity have new on-disk diflag
- xfs_attr_get() can return a buffer with an extended attribute
- xfs_buf can allocate double space for Merkle tree blocks. Part of the space is used to store the extended attribute data without leaf headers
- xfs_buf tracks verified status of merkle tree blocks
The patchset consists of five parts:
- [1]: fs-verity spinlock removal pending in fsverity/for-next
- [2..4]: Parent pointers adding binary xattr names
- [5]: Expose FS_XFLAG_VERITY for fs-verity files
- [6..9]: Changes to fs-verity core
- [10]: Integrate fs-verity to iomap
- [11-24]: Add fs-verity support to XFS
Testing:
The patchset is tested with xfstests -g verity on xfs_1k, xfs_4k, xfs_1k_quota, xfs_4k_quota, ext4_4k, and ext4_4k_quota. With KMEMLEAK and KASAN enabled. More testing on the way.
Changes from V4:
- Mainly fs-verity changes; removed unnecessary functions
- Replace XFS workqueue with per-sb workqueue created in fsverity_set_ops()
- Drop patch with readahead calculation in bytes
Changes from V3:
- redone changes to fs-verity core as previous version had an issue on ext4
- add blocks invalidation interface to fs-verity
- move memory ordering primitives out of block status check to fs read block function
- add fs-verity verification to iomap instead of general post read processing
Changes from V2:
- FS_XFLAG_VERITY extended attribute flag
- Change fs-verity to use Merkle tree blocks instead of expecting PAGE references from filesystem
- Change approach in iomap to filesystem provided bio_set and submit_io instead of just callouts to filesystem
- Add possibility for xfs_buf allocate more space for fs-verity extended attributes
- Make xfs_attr module to copy fs-verity blocks inside the xfs_buf, so XFS can get data without leaf headers
- Add Merkle tree removal for error path
- Makae scrub aware of new dinode flag
Changes from V1:
- Added parent pointer patches for easier testing
- Many issues and refactoring points fixed from the V1 review
- Adjusted for recent changes in fs-verity core (folios, non-4k)
- Dropped disabling of large folios
- Completely new fsverity patches (fix, callout, log_blocksize)
- Change approach to verification in iomap to the same one as in write path. Callouts to fs instead of direct fs-verity use.
- New XFS workqueue for post read folio verification
- xfs_attr_get() can return underlying xfs_buf
- xfs_bufs are marked with XBF_VERITY_CHECKED to track verified blocks
If you're going to start using this code, I strongly recommend pulling from my git trees, which are linked below.
This has been running on the djcloud for months with no problems. Enjoy! Comments and questions are, as always, welcome.
--D
kernel git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfs-linux.git/log/?h=fsverity
xfsprogs git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfsprogs-dev.git/log/?h=fsverity
fstests git tree:
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=fsverity
---
Commits in this patchset:
* common/verity: enable fsverity for XFS
* xfs/{021,122}: adapt to fsverity xattrs
* common/populate: add verity files to populate xfs images
--- common/populate | 21 +++++++++++++++++++++ common/verity | 29 ++++++++++++++++++++++++++++- tests/xfs/021 | 3 +++ tests/xfs/122.out | 1 + 4 files changed, 53 insertions(+), 1 deletion(-)
PATCH 1/3 common/verity: enable fsverity for XFS
From: Andrey Albershteyn <[email protected]>
XFS supports verity and can be enabled for -g verity group.
--- common/verity | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-)
common/verity +28 -1
@@ -43,7 +43,16 @@ _require_scratch_verity() # The filesystem may be aware of fs-verity but have it disabled by # CONFIG_FS_VERITY=n. Detect support via sysfs. - if [ ! -e /sys/fs/$fstyp/features/verity ]; then + case $FSTYP in + xfs) + _scratch_unmount + _check_scratch_xfs_features VERITY &>>$seqres.full + _scratch_mount + ;; + *) + test -e /sys/fs/$fstyp/features/verity + esac + if [ ! $? ]; then _notrun "kernel $fstyp isn't configured with verity support" fi
@@ -201,6 +210,9 @@ _scratch_mkfs_verity() ext4|f2fs) _scratch_mkfs -O verity ;; + xfs) + _scratch_mkfs -i verity + ;; btrfs) _scratch_mkfs ;;
@@ -407,6 +419,21 @@ _fsv_scratch_corrupt_merkle_tree() done _scratch_mount ;; + xfs) + local ino=$(stat -c '%i' $file) + local attr_offset=$(( $offset % $FSV_BLOCK_SIZE )) + local attr_index=$(printf "%08d" $(( offset - attr_offset ))) + _scratch_unmount + # Attribute name is 8 bytes long (index of Merkle tree page) + _scratch_xfs_db -x -c "inode $ino" \ + -c "attr_modify -f -m 8 -o $attr_offset $attr_index \"BUG\"" \ + >>$seqres.full + # In case bsize == 4096 and merkle block size == 1024, by + # modifying attribute with 'attr_modify we can corrupt quota + # account. Let's repair it + _scratch_xfs_repair > $seqres.full 2>&1 + _scratch_mount + ;; *) _fail "_fsv_scratch_corrupt_merkle_tree() unimplemented on $FSTYP" ;;
PATCH 2/3 xfs/{021,122}: adapt to fsverity xattrs
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
Adjust these tests to accomdate the use of xattrs to store fsverity metadata.
--- tests/xfs/021 | 3 +++ tests/xfs/122.out | 1 + 2 files changed, 4 insertions(+)
tests/xfs/021 +3 -0
@@ -118,6 +118,7 @@ _scratch_xfs_db -r -c "inode $inum_1" -c "print a.sfattr" | \ perl -ne ' /\.secure/ && next; /\.parent/ && next; +/\.verity/ && next; print unless /^\d+:\[.*/;' echo "*** dump attributes (2)"
@@ -128,6 +129,7 @@ _scratch_xfs_db -r -c "inode $inum_2" -c "a a.bmx[0].startblock" -c print \ | perl -ne ' s/,secure//; s/,parent//; +s/,verity//; s/info.hdr/info/; /hdr.info.crc/ && next; /hdr.info.bno/ && next;
@@ -135,6 +137,7 @@ s/info.hdr/info/; /hdr.info.lsn/ && next; /hdr.info.owner/ && next; /\.parent/ && next; +/\.verity/ && next; s/^(hdr.info.magic =) 0x3bee/\1 0xfbee/; s/^(hdr.firstused =) (\d+)/\1 FIRSTUSED/; s/^(hdr.freemap\[0-2] = \[base,size]).*/\1 [FREEMAP..]/;
tests/xfs/122.out +1 -0
@@ -141,6 +141,7 @@ sizeof(struct xfs_scrub_vec) = 16 sizeof(struct xfs_scrub_vec_head) = 32 sizeof(struct xfs_swap_extent) = 64 sizeof(struct xfs_unmount_log_format) = 8 +sizeof(struct xfs_verity_merkle_key) = 8 sizeof(struct xfs_xmd_log_format) = 16 sizeof(struct xfs_xmi_log_format) = 80 sizeof(union xfs_rtword_raw) = 4
Re: [PATCH 2/3] xfs/{021,122}: adapt to fsverity xattrs
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Adjust these tests to accomdate the use of xattrs to store fsverity metadata.
Signed-off-by Darrick J. Wong <[email protected]>
Is it against one of pptrs branches? doesn't seem to apply on for-next
Quoted 47 lines
--- tests/xfs/021 | 3 +++ tests/xfs/122.out | 1 + 2 files changed, 4 insertions(+)tests/xfs/021 +3
-0@@ -118,6 +118,7 @@ _scratch_xfs_db -r -c "inode $inum_1" -c "print a.sfattr" | \ perl -ne ' /\.secure/ && next; /\.parent/ && next; +/\.verity/ && next; print unless /^\d+:\[.*/;' echo "*** dump attributes (2)"@@ -128,6 +129,7 @@ _scratch_xfs_db -r -c "inode $inum_2" -c "a a.bmx[0].startblock" -c print \ | perl -ne ' s/,secure//; s/,parent//; +s/,verity//; s/info.hdr/info/; /hdr.info.crc/ && next; /hdr.info.bno/ && next;@@ -135,6 +137,7 @@ s/info.hdr/info/; /hdr.info.lsn/ && next; /hdr.info.owner/ && next; /\.parent/ && next; +/\.verity/ && next; s/^(hdr.info.magic =) 0x3bee/\1 0xfbee/; s/^(hdr.firstused =) (\d+)/\1 FIRSTUSED/; s/^(hdr.freemap\[0-2] = \[base,size]).*/\1 [FREEMAP..]/;tests/xfs/122.out +1
-0@@ -141,6 +141,7 @@ sizeof(struct xfs_scrub_vec) = 16 sizeof(struct xfs_scrub_vec_head) = 32 sizeof(struct xfs_swap_extent) = 64 sizeof(struct xfs_unmount_log_format) = 8 +sizeof(struct xfs_verity_merkle_key) = 8 sizeof(struct xfs_xmd_log_format) = 16 sizeof(struct xfs_xmi_log_format) = 80 sizeof(union xfs_rtword_raw) = 4
Signature · 1 line
- Andrey
Re: [PATCH 2/3] xfs/{021,122}: adapt to fsverity xattrs
Quoted 10 lines · Andrey Albershteyn
Quoted 6 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Adjust these tests to accomdate the use of xattrs to store fsverity metadata.
Signed-off-by Darrick J. Wong <[email protected]>Is it against one of pptrs branches? doesn't seem to apply on for-next
See
https://git.kernel.org/cgit/linux/kernel/git/djwong/xfstests-dev.git/log/?h=fsverity
(as mentioned in the cover letter)
--D
Quoted 53 lines
Quoted 48 lines
--- tests/xfs/021 | 3 +++ tests/xfs/122.out | 1 + 2 files changed, 4 insertions(+)tests/xfs/021 +3
-0@@ -118,6 +118,7 @@ _scratch_xfs_db -r -c "inode $inum_1" -c "print a.sfattr" | \ perl -ne ' /\.secure/ && next; /\.parent/ && next; +/\.verity/ && next; print unless /^\d+:\[.*/;' echo "*** dump attributes (2)"@@ -128,6 +129,7 @@ _scratch_xfs_db -r -c "inode $inum_2" -c "a a.bmx[0].startblock" -c print \ | perl -ne ' s/,secure//; s/,parent//; +s/,verity//; s/info.hdr/info/; /hdr.info.crc/ && next; /hdr.info.bno/ && next;@@ -135,6 +137,7 @@ s/info.hdr/info/; /hdr.info.lsn/ && next; /hdr.info.owner/ && next; /\.parent/ && next; +/\.verity/ && next; s/^(hdr.info.magic =) 0x3bee/\1 0xfbee/; s/^(hdr.firstused =) (\d+)/\1 FIRSTUSED/; s/^(hdr.freemap\[0-2] = \[base,size]).*/\1 [FREEMAP..]/;tests/xfs/122.out +1
-0@@ -141,6 +141,7 @@ sizeof(struct xfs_scrub_vec) = 16 sizeof(struct xfs_scrub_vec_head) = 32 sizeof(struct xfs_swap_extent) = 64 sizeof(struct xfs_unmount_log_format) = 8 +sizeof(struct xfs_verity_merkle_key) = 8 sizeof(struct xfs_xmd_log_format) = 16 sizeof(struct xfs_xmi_log_format) = 80 sizeof(union xfs_rtword_raw) = 4Signature · 1 line
- Andrey
PATCH 3/3 common/populate: add verity files to populate xfs images
In reply to Darrick J. WongFrom: Darrick J. Wong <[email protected]>
If verity is enabled on a filesystem, we should create some sample verity files.
--- common/populate | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
common/populate +21 -0
@@ -520,6 +520,27 @@ _scratch_xfs_populate() { done fi + # verity merkle trees + is_verity="$(_xfs_has_feature "$SCRATCH_MNT" verity -v)" + if [ $is_verity -gt 0 ]; then + echo "+ fsverity" + + # Create a biggish file with all zeroes, because metadump + # won't preserve data blocks and we don't want the hashes to + # stop working for our sample fs. + for ((pos = 0, i = 88; pos < 23456789; pos += 234567, i++)); do + $XFS_IO_PROG -f -c "pwrite -S 0 $pos 234567" "$SCRATCH_MNT/verity" + done + + fsverity enable "$SCRATCH_MNT/verity" + + # Create a sparse file + $XFS_IO_PROG -f -c "pwrite -S 0 0 3" "$SCRATCH_MNT/sparse_verity" + truncate -s 23456789 "$SCRATCH_MNT/sparse_verity" + $XFS_IO_PROG -f -c "pwrite -S 0 23456789 3" "$SCRATCH_MNT/sparse_verity" + fsverity enable "$SCRATCH_MNT/sparse_verity" + fi + # Copy some real files (xfs tests, I guess...) echo "+ real files" test $fill -ne 0 && __populate_fill_fs "${SCRATCH_MNT}" 5
Quoted 5 lines · Darrick J. Wong
Note that metadump is kinda broken and
xfs_scrubmedia scans do not yet know how to read verity files. All that is actually fixed in the version that's lodged in my development trees, but since Andrey's base is the 6.9 for-next branch plus only a few of the parent pointers patches, none of that stuff was easy to port to make a short dev branch.
Maybe we'll need to put the verity work back and do a good review cycle on the parent pointers first?
Can you send out what your currently have?
Quoted 11 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
Note that metadump is kinda broken and
xfs_scrubmedia scans do not yet know how to read verity files. All that is actually fixed in the version that's lodged in my development trees, but since Andrey's base is the 6.9 for-next branch plus only a few of the parent pointers patches, none of that stuff was easy to port to make a short dev branch.Maybe we'll need to put the verity work back and do a good review cycle on the parent pointers first?
Can you send out what your currently have?
Ok, I'll do that tomorrow.
--D