fs-verity support for XFS with post EOF merkle tree
v19 cover fs-verity support for XFS with post EOF merkle tree
Hi all,
This is next revision of fsverity for XFS. Changes:
- Add guard to forbid use on Zoned devices
- Add a guard against using with LBS (compound pages no-go for fsverity)
- move IOMAP_F_FSVERITY to xfs_bmbt_to_iomap()
- Use I_VERITY_BUILDING instead of XFS inode flag
- Add guard against DAX during fsverity enable
- Change XFS_FSVERITY_LARGEST_FILE to macro for 32-bit kernel check
- Forbid opening too large fsverity files on 32-bit kernels
- xfs_free_eofblocks() doesn't depend on I_VERITY (disk flag instead)
- Keep EOF cleanup tag on inode if fsverity build failed
- Invalidate past EOF page cache in scrub on corrupted inodes
- Remove past EOF extents in scrub on corrupted inodes
Patches without review:
[PATCH v19 05/15] xfs: handle fsverity I/O in write/read path [PATCH v19 09/15] xfs: add fs-verity support
[PATCH v19 13/15] xfs: check and repair the verity inode flag state
The RO_COMPAT with CONFIG_FS_VERITY=n should be fine as fsverity inode won't open (this is same for all fs).
This series based on v7.4-rc3 and my series adding I_VERITY_BUILDING [1]
1: https://lore.kernel.org/linux-xfs/[email protected]
kernel:
https://git.kernel.org/pub/scm/linux/kernel/git/aalbersh/xfs-linux.git/log/?h=fsverity
xfsprogs:
https://git.kernel.org/pub/scm/linux/kernel/git/aalbersh/xfsprogs-dev.git/log/?h=fsverity
xfstests:
https://git.kernel.org/pub/scm/linux/kernel/git/aalbersh/xfstests-dev.git/log/?h=fsverity
v18:
https://lore.kernel.org/fsverity/[email protected]/T/#t
v17:
https://lore.kernel.org/fsverity/[email protected]/T/#u
v16:
https://lore.kernel.org/fsverity/[email protected]/T/#t
v15:
https://lore.kernel.org/fsverity/[email protected]/T/#t
To: [email protected]
To: [email protected]
To: Carlos Maiolino <[email protected]>
To: [email protected]
To: [email protected]
---
Changes in v19:
- Add guard to forbid use on Zoned devices
- Add a guard against using with LBS (compound pages no-go for fsverity)
- move IOMAP_F_FSVERITY to xfs_bmbt_to_iomap()
- Use I_VERITY_BUILDING instead of XFS inode flag
- Add guard against DAX during fsverity enable
- Change XFS_FSVERITY_LARGEST_FILE to macro for 32-bit kernel check
- Forbid opening too large fsverity files on 32-bit kernels
- xfs_free_eofblocks() doesn't depend on I_VERITY (disk flag instead)
- Keep EOF cleanup tag on inode if fsverity build failed
- Invalidate past EOF page cache in scrub on corrupted inodes
- Remove past EOF extents in scrub on corrupted inodes
Changes in v18:
- Rebase to latest origin/for-next and drop core fsverity patches
- Move truncate_inode_pages() before xfs_trans_alloc()
- Move xfs_fsverity_metadata_offset() to libxfs as used in xfs_bmap.c
Changes in v17:
- Add mempool for fsverity ioends cache
- Add xfs_fsverity_reset_inode() as a common clean up function
- Changed ILOCK_SHARED to ILOCK_EXCL for xfs_bmap_last_extent()
- Swap order of truncate_inode_pages() and ilock() due to ABBA
- Add xfs_fsverity_is_hashes_of_zeroed_blocks() helper
- Removed EINVAL and EFBIG from scrub as ambiguous
Changes in v16:
- Rebase to block/for-next
- Removed work_struct from ioend in favor of kmem_cache structs
- Minor adjustments from v15 review
- Skip written extents in lower level of __xfs_bunmapi()
Changes in v15:
- Pull BIO in task context patches
- Drop flag argument in xfs_free_eofblocks()
- Call xfs_free_eofblocks() on fsverity inodes
- Comments and commit messages updates
- Rebased to v7.2-rc7
- Dropped patch for fsverity_fill_zerohash() with highmem optimization
Changes in v14:
- Rebase to lazy-bounce@hch-misc
- Adjust read ioends to BIO in task context flow
- MMAPLOCK/sb_internal deadlock fix reported by sashiko
- Add missing delalloc clean up in verity_end_enable
- Use xfs_free_eofblocks() instead of writing own clean up routine
- Modify xfs_free_eofblocks() to be able to clean unwritten only
- Dropped fix patch for truncate/set_size check
- Various minor code and #include rearrangements for bisecting
Changes in v13:
- Hoisted statx reporting to common code
- Added read ioend sorted for worker self-deadlock fix
- Adjusted fsverity flags in zoned write path
Changes in v12:
- Refactored xfs_fsverity_cancel_unwritten()
- Switched to using inode_set_flags()
- Add a lock for COW fork reading
- Add pagecache truncation in cleanup path
- Added ERANGE and EBADMSG to fsverity scrub handling
- Add missing XFS_FSVERITY_CONSTRUCTION in various xfs_iomap
- Rebase to -rc3
Changes in v11:
- Drop wrong overlayfs patch
- Drop already merged iomap and fsverity patches
- Update to I_INO() use instead of ip->i_ino
- Sashiko.dev fixes. See list of issues below.
Changes in v10:
- Rebase to v7.1-rc3 with relevant adjustments
- Initialize ioend->io_vi to NULL to not get write work onto verity wq
- Range diff below
Changes in v9:
- Fix fsverity_fill_zerohash() parameter names
- A few fixes found by sashiko.dev:
- Replace ip->i_mount->m_attr_geo->blksize with m_sb.sb_blocksize
- Don't call xfs_trans_cancel() after xfs_trans_commit() in xfs_fsverity_end_enable()
- Call xfs_fsverity_delete_metadata() if verity enable failed
- Change start/end type from xfs_fileoff_t to loff_t
- Return xfs_trans_commit() error from
xfs_fsverity_cancel_unwritten()
Changes in v8:
- Return fsverity_ensure_verity_info() errors from
ovl_ensure_verity_loaded()
Changes in v7:
- Move kerneldoc to fsverity_ensure_verity_info() definition
- Drop patch adding XFS traces
- Fix overly long line in the comment
- Make order of fserror and fsverity_error consistent
- Add overlay patch converting to fsverity_ensure_verity_info()
Changes in v6:
- Removed stub for fsverity_ensure_verity_info() as it's optimized out
- Rename fsverity_folio_zero_hash() to fsverify_fill_zerohash()
- Merge patches 8 to 10 into one
- Merge patch gerating zero_hash and fsverity_fill_zerohash() into one
- Add kerneldoc to fsverity_ensure_verity_info()
- Add comments to iomap_block_needs_zeroing()
Changes in v5:
- Add fserror_report_data_lost() for data blocks in page spanning EOF
- Issue fsverity metadata readahead in data readahead
- iomap_fsverity_write() return type fix
- Use of S_ISREG(mode)
- Make 65536 #define instead of open-coded
- Use transaction per unwritten extent removal
- Fetch fsverity_info for all fsverity metadata
- Revert fsverity_folio_zero_hash() stub as used in iomap
- Extend cancel_unwritten to whole file range to remove cow leftovers
- Drop delayed allocation on the COW fork on fsverity completion
Changes in v4:
- Use fserror interface in fsverity instead of fs callback
- Hoist pagecache_read from f2fs/ext4 to fsverity
- Refactor iomap code
- Fetch fsverity_info only for file data and merkle tree holes
- Do not disable preallocation, remove unwritten extents instead
- Offload fsverity hash I/O to fsverity workqueue in read path
- Store merkle tree at round_up(i_size, 64k)
- Add a spacing between merkle tree and fsverity descriptor as next 64k
aligned block
- Squash helpers into first user commits
- Squash on-disk format changes into single commit
- Drop different offset for pagecache/on-disk
- Don't zero out pages in higher order folios in write path
- Link to v3: https://lore.kernel.org/fsverity/[email protected]/T/#t
Changes in v3:
- Different on-disk and pagecache offset
- Use read path ioends
- Switch to hashtable fsverity info
- Synthesize merkle tree blocks full of zeroes
- Other minor refactors
- Link to v2: https://lore.kernel.org/fsverity/20260114164210.GO15583@frogsfrogsfrogs/T/#t
Changes in v2:
- Move to VFS interface for merkle tree block reading
- Drop patchset for per filesystem workqueues
- Change how offsets of the descriptor and tree metadata is calculated
- Store fs-verity descriptor in data fork side by side with merkle tree
- Simplify iomap changes, remove interface for post eof read/write
- Get rid of extended attribute implementation
- Link to v1: https://lore.kernel.org/r/[email protected]
Andrey Albershteyn (13):
xfs: introduce fsverity on-disk changes
xfs: don't allow to enable DAX on fs-verity sealed inode
xfs: disable direct read path for fs-verity files
xfs: don't report dio_mem_align and dio_offset_align for fsverity
files
xfs: handle fsverity I/O in write/read path
xfs: use read ioend for fsverity data verification
xfs: add XFS_BMAPI_UNWRITTEN to unmap unwritten extents in
__xfs_bunmapi()
xfs: don't remove written extents past EOF on fsverity inodes
xfs: add fs-verity support
xfs: initialize fs-verity on file open
xfs: add fs-verity ioctls
xfs: introduce health state for corrupted fsverity metadata
xfs: enable ro-compat fs-verity flag
Darrick J. Wong (2):
xfs: advertise fs-verity being available on filesystem
xfs: check and repair the verity inode flag state
fs/xfs/Makefile | 2 + fs/xfs/libxfs/xfs_bmap.c | 26 +- fs/xfs/libxfs/xfs_bmap.h | 6 +- fs/xfs/libxfs/xfs_format.h | 31 +- fs/xfs/libxfs/xfs_fs.h | 2 + fs/xfs/libxfs/xfs_health.h | 4 +- fs/xfs/libxfs/xfs_inode_buf.c | 19 ++ fs/xfs/libxfs/xfs_inode_util.c | 5 +- fs/xfs/libxfs/xfs_sb.c | 4 + fs/xfs/libxfs/xfs_verity.c | 20 ++ fs/xfs/libxfs/xfs_verity.h | 13 + fs/xfs/scrub/common.c | 53 ++++ fs/xfs/scrub/common.h | 2 + fs/xfs/scrub/inode.c | 22 ++ fs/xfs/scrub/inode_repair.c | 49 ++++ fs/xfs/xfs_aops.c | 19 +- fs/xfs/xfs_bmap_util.c | 32 ++- fs/xfs/xfs_file.c | 71 +++-- fs/xfs/xfs_fsverity.c | 509 +++++++++++++++++++++++++++++++++ fs/xfs/xfs_fsverity.h | 42 +++ fs/xfs/xfs_health.c | 1 + fs/xfs/xfs_icache.c | 11 +- fs/xfs/xfs_ioctl.c | 33 +++ fs/xfs/xfs_ioend.c | 53 +++- fs/xfs/xfs_ioend.h | 4 +- fs/xfs/xfs_iomap.c | 61 ++-- fs/xfs/xfs_iomap.h | 5 +- fs/xfs/xfs_iops.c | 20 +- fs/xfs/xfs_message.c | 4 + fs/xfs/xfs_message.h | 1 + fs/xfs/xfs_mount.h | 4 + fs/xfs/xfs_pnfs.c | 2 +- fs/xfs/xfs_super.c | 32 ++- 33 files changed, 1093 insertions(+), 69 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_verity.c create mode 100644 fs/xfs/libxfs/xfs_verity.h create mode 100644 fs/xfs/xfs_fsverity.c create mode 100644 fs/xfs/xfs_fsverity.h
Range-diff against v18:
1: 78f9766b0f03 ! 1: ca9aa48fa04b xfs: introduce fsverity on-disk changes
@@ fs/xfs/libxfs/xfs_format.h: struct xfs_acl {
#define SGI_ACL_DEFAULT_SIZE (sizeof(SGI_ACL_DEFAULT)-1)
+/*
-+ * At maximum of 8 levels with 128 hashes per block (32 bytes SHA-256) maximum
-+ * tree size is ((128^8 − 1)/(128 − 1)) = 567*10^12 blocks. This should fit in
-+ * 53 bits address space.
-+ *
-+ * At this Merkle tree size we can cover 295EB large file. This is much larger
-+ * than the currently supported file size.
-+ *
-+ * For sha512 the largest file we can cover ends at 1 << 50 offset, this is also
-+ * good.
++ * fs-verity stores the Merkle tree in the data fork past EOF, so the file data
++ * blocks and the tree blocks share the inode's xfs_fileoff_t address space.
++ * Cap a verity file at half of the addressable file-offset range (in filesystem
++ * blocks) so the Merkle tree always fits in the other half.
+ */
-+#define XFS_FSVERITY_LARGEST_FILE ((loff_t)1ULL << 53)
++#define XFS_FSVERITY_LARGEST_FILE_FSB(mp) \
++ (XFS_B_TO_FSBT((mp), MAX_LFS_FILESIZE) >> 1)
+
+/*
+ * Alignment of the fsverity metadata placement. This is largest supported PAGE
2: 8617a78e7332 = 2: a019dc4ec4b8 xfs: don't allow to enable DAX on fs-verity sealed inode
3: a4cb44a90ad7 ! 3: b8f1466cf632 xfs: disable direct read path for fs-verity files
@@ fs/xfs/xfs_file.c: xfs_file_dio_read(
+ return xfs_file_buffered_read(iocb, to);
+ }
if (mapping_stable_writes(iocb->ki_filp->f_mapping)) {
- ret = iomap_dio_rw(iocb, to, &xfs_read_iomap_ops,
+ ret = iomap_dio_rw(iocb, to, xfs_read_iomap_next,
&xfs_dio_read_bounce_ops, 0, NULL, 0);
@@ fs/xfs/xfs_file.c: xfs_file_dax_read(
struct kiocb *iocb,
4: 91dc30941faf ! 4: d7810bcef90a xfs: don't report dio_mem_align and dio_offset_align for fsverity files
@@ Commit message
Signed-off-by: Andrey Albershteyn <[email protected]>
Acked-by: Eric Biggers <[email protected]>
Reviewed-by: "Darrick J. Wong" <[email protected]>
+ Reviewed-by: Christoph Hellwig <[email protected]>
## fs/xfs/xfs_iops.c ##
@@
@@ fs/xfs/xfs_iops.c: xfs_report_dioalign(
stat->result_mask |= STATX_DIOALIGN | STATX_DIO_READ_ALIGN;
+
++ /*
++ * The STATX_DIOALIGN | STATX_DIO_READ_ALIGN flags are used to
++ * explicitly report if DIO is supported or not. They can not indicate
++ * that fallback to the buffered IO is used for fsverity.
++ *
++ * Return zero alignment values which also mean that DIO is not
++ * supported on this file, see statx(2).
++ */
+ if (fsverity_active(VFS_I(ip)))
+ return;
+ 5: b1afe722c692 ! 5: 30fa010febff xfs: handle fsverity I/O in write/read path
@@ Commit message
treat holes in the tree as request to synthesize tree blocks and hole after descriptor as end of the fsverity region.
- Introduce a new inode flag meaning that merkle tree is being build on
- the inode.
-
- Reviewed-by: "Darrick J. Wong" <[email protected]>
- Reviewed-by: Christoph Hellwig <[email protected]>
## fs/xfs/Makefile ##
@@ fs/xfs/Makefile: xfs-y += $(addprefix libxfs/, \
@@ fs/xfs/Makefile: xfs-y += $(addprefix libxfs/, \
xfs-$(CONFIG_XFS_RT) += $(addprefix libxfs/, \
## fs/xfs/libxfs/xfs_bmap.c ##
-@@
- #include "xfs_inode_util.h"
- #include "xfs_rtgroup.h"
- #include "xfs_zone_alloc.h"
-+#include "xfs_verity.h"
-
- struct kmem_cache *xfs_bmap_intent_cache;
-
@@ fs/xfs/libxfs/xfs_bmap.c: xfs_bmapi_convert_one_delalloc(
* the extent. Just return the real extent at this offset. */
if (!isnullstartblock(bma.got.br_startblock)) {
-+ if (xfs_iflags_test(ip, XFS_VERITY_CONSTRUCTION) &&
-+ offset >= xfs_fsverity_metadata_offset(ip))
-+ flags |= IOMAP_F_FSVERITY;
- xfs_bmbt_to_iomap(ip, iomap, &bma.got, 0, flags,
+- xfs_bmbt_to_iomap(ip, iomap, &bma.got, 0, flags,
++ xfs_bmbt_to_iomap(ip, iomap, &bma.got, offset, 0, flags,
xfs_iomap_inode_sequence(ip, flags));
if (seq)
+ *seq = READ_ONCE(ifp->if_seq);
@@ fs/xfs/libxfs/xfs_bmap.c: xfs_bmapi_convert_one_delalloc(
- XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, bma.length));
XFS_STATS_INC(mp, xs_xstrat_quick);
-+ if (xfs_iflags_test(ip, XFS_VERITY_CONSTRUCTION) &&
-+ offset >= xfs_fsverity_metadata_offset(ip))
-+ flags |= IOMAP_F_FSVERITY;
-+
ASSERT(!isnullstartblock(bma.got.br_startblock));
- xfs_bmbt_to_iomap(ip, iomap, &bma.got, 0, flags,
+- xfs_bmbt_to_iomap(ip, iomap, &bma.got, 0, flags,
++ xfs_bmbt_to_iomap(ip, iomap, &bma.got, offset, 0, flags,
xfs_iomap_inode_sequence(ip, flags));
+ if (seq)
+ *seq = READ_ONCE(ifp->if_seq);
## fs/xfs/libxfs/xfs_verity.c (new) ##
@@
@@ fs/xfs/libxfs/xfs_verity.h (new)
+#define __XFS_VERITY_H__
+
+#include "xfs_platform.h"
++#include <linux/fsverity.h>
+
+loff_t xfs_fsverity_metadata_offset(const struct xfs_inode *ip); +
@@ fs/xfs/xfs_aops.c
#include "xfs_ioend.h"
#include "xfs_zone_alloc.h"
#include "xfs_rtgroup.h"
-+#include "xfs_fsverity.h"
++#include "xfs_verity.h"
struct xfs_writepage_ctx {
struct iomap_writepage_ctx ctx;
-@@ fs/xfs/xfs_aops.c: xfs_map_blocks(
- int retries = 0;
- int error = 0;
- unsigned int *seq;
-+ unsigned int iomap_flags = 0;
-
- if (xfs_is_shutdown(mp))
- return -EIO;
-
- XFS_ERRORTAG_DELAY(mp, XFS_ERRTAG_WB_DELAY_MS);
-
-+ if (xfs_iflags_test(ip, XFS_VERITY_CONSTRUCTION))
-+ iomap_flags |= IOMAP_F_FSVERITY;
-+
- /*
- * COW fork blocks can overlap data fork blocks even if the blocks
- * aren't shared. COW I/O always takes precedent, so we must always
@@ fs/xfs/xfs_aops.c: xfs_map_blocks(
isnullstartblock(imap.br_startblock))
goto allocate_blocks;
- xfs_bmbt_to_iomap(ip, &wpc->iomap, &imap, 0, 0, XFS_WPC(wpc)->data_seq);
-+ xfs_bmbt_to_iomap(ip, &wpc->iomap, &imap, 0, iomap_flags,
++ xfs_bmbt_to_iomap(ip, &wpc->iomap, &imap, offset, 0, 0,
+ XFS_WPC(wpc)->data_seq);
trace_xfs_map_blocks_found(ip, offset, count, whichfork, &imap);
return 0;
allocate_blocks:
-@@ fs/xfs/xfs_aops.c: xfs_zoned_map_blocks(
- xfs_filblks_t count_fsb;
- struct xfs_bmbt_irec imap, del;
- struct xfs_iext_cursor icur;
-+ u16 iomap_flags = 0;
-
- if (xfs_is_shutdown(mp))
- return -EIO;
-
- XFS_ERRORTAG_DELAY(mp, XFS_ERRTAG_WB_DELAY_MS);
-
-+ if (xfs_iflags_test(ip, XFS_VERITY_CONSTRUCTION))
-+ iomap_flags |= IOMAP_F_FSVERITY;
-+
- /*
- * All dirty data must be covered by delalloc extents. But truncate can
- * remove delalloc extents underneath us or reduce their size.
@@ fs/xfs/xfs_aops.c: xfs_zoned_map_blocks(
imap.br_startblock = HOLESTARTBLOCK;
imap.br_state = XFS_EXT_NORM;
xfs_iunlock(ip, XFS_ILOCK_EXCL);
- xfs_bmbt_to_iomap(ip, &wpc->iomap, &imap, 0, 0, 0);
-+ xfs_bmbt_to_iomap(ip, &wpc->iomap, &imap, 0, iomap_flags, 0);
++ xfs_bmbt_to_iomap(ip, &wpc->iomap, &imap, offset, 0, 0, 0);
return 0;
}
end_fsb = min(end_fsb, imap.br_startoff + imap.br_blockcount);
-@@ fs/xfs/xfs_aops.c: xfs_zoned_map_blocks(
- xfs_iunlock(ip, XFS_ILOCK_EXCL);
-
- xfs_iomap_set_anon_write(ip, &wpc->iomap, offset,
-- XFS_FSB_TO_B(mp, count_fsb));
-+ XFS_FSB_TO_B(mp, count_fsb), iomap_flags);
- trace_xfs_zoned_map_blocks(ip, offset, wpc->iomap.length);
- return 0;
- }
-@@ fs/xfs/xfs_aops.c: static const struct iomap_writeback_ops xfs_zoned_writeback_ops = {
- .writeback_submit = xfs_zoned_writeback_submit,
- };
-
-+static int
-+xfs_iomap_writepages(
-+ struct xfs_inode *ip,
-+ struct iomap_writepage_ctx *ctx)
-+{
-+ /*
-+ * Writeback does not work for folios past EOF, let it know that
-+ * I/O happens for fsverity metadata and this restriction need
-+ * to be skipped
-+ */
-+ if (xfs_iflags_test(ip, XFS_VERITY_CONSTRUCTION))
-+ ctx->iomap.flags |= IOMAP_F_FSVERITY;
-+
-+ return iomap_writepages(ctx);
-+}
-+
- STATIC int
- xfs_vm_writepages(
- struct address_space *mapping,
-@@ fs/xfs/xfs_aops.c: xfs_vm_writepages(
- };
- int error;
-
-- error = iomap_writepages(&xc.ctx);
-+ error = xfs_iomap_writepages(ip, &xc.ctx);
- if (xc.open_zone)
- xfs_open_zone_put(xc.open_zone);
- return error;
-@@ fs/xfs/xfs_aops.c: xfs_vm_writepages(
- },
- };
-
-- return iomap_writepages(&wpc.ctx);
-+ return xfs_iomap_writepages(ip, &wpc.ctx);
- }
- }
-
-
- ## fs/xfs/xfs_inode.h ##
-@@ fs/xfs/xfs_inode.h: static inline bool xfs_inode_can_sw_atomic_write(const struct xfs_inode *ip)
- */
- #define XFS_IREMAPPING (1U << 15)
-
-+/*
-+ * fs-verity's Merkle tree is under construction. The file is read-only, the
-+ * only writes happening are for the fsverity metadata.
-+ */
-+#define XFS_VERITY_CONSTRUCTION (1U << 16)
-+
- /* All inode state flags related to inode reclaim. */
- #define XFS_ALL_IRECLAIM_FLAGS (XFS_IRECLAIMABLE | \
- XFS_IRECLAIM | \
## fs/xfs/xfs_iomap.c ##
@@
@@ fs/xfs/xfs_iomap.c
#define XFS_ALLOC_ALIGN(mp, off) \
(((off) >> mp->m_allocsize_log) << mp->m_allocsize_log)
-@@ fs/xfs/xfs_iomap.c: xfs_direct_write_iomap_begin(
- if (flags & IOMAP_ATOMIC)
- iomap_flags |= IOMAP_F_ATOMIC_BIO;
+@@ fs/xfs/xfs_iomap.c: xfs_alert_fsblock_zero(
+ return -EFSCORRUPTED;
+ }
-+ if (xfs_iflags_test(ip, XFS_VERITY_CONSTRUCTION))
-+ iomap_flags |= IOMAP_F_FSVERITY;
++static bool
++xfs_iomap_is_fsverity_metadata(
++ struct xfs_inode *ip,
++ loff_t offset)
++{
++ return offset >= xfs_fsverity_metadata_offset(ip) &&
++ (fsverity_is_building(VFS_I(ip)) || fsverity_active(VFS_I(ip)));
++}
++
+ u64
+ xfs_iomap_inode_sequence(
+ struct xfs_inode *ip,
+@@ fs/xfs/xfs_iomap.c: xfs_bmbt_to_iomap(
+ struct xfs_inode *ip,
+ struct iomap *iomap,
+ struct xfs_bmbt_irec *imap,
++ loff_t offset,
+ unsigned int mapping_flags,
+ u16 iomap_flags,
+ u64 sequence_cookie)
+@@ fs/xfs/xfs_iomap.c: xfs_bmbt_to_iomap(
+ iomap->flags |= IOMAP_F_INTEGRITY;
+ }
+
++ /*
++ * Tell iomap when this I/O covers fs-verity metadata so it handles size
++ * updates and post-EOF folios correctly. The attr fork uses a separate
++ * offset space, so exclude it.
++ */
++ if (!(iomap_flags & IOMAP_F_XATTR) &&
++ xfs_iomap_is_fsverity_metadata(ip, offset))
++ iomap->flags |= IOMAP_F_FSVERITY;
+
/*
- * COW writes may allocate delalloc space or convert unwritten COW
- * extents, so we need to make sure to take the lock exclusively here.
+ * If the inode is dirty for datasync purposes, let iomap know so it
+ * doesn't elide the IO completion journal flushes on O_DSYNC IO.
+@@ fs/xfs/xfs_iomap.c: xfs_direct_write_iomap_begin(
+ seq = xfs_iomap_inode_sequence(ip, iomap_flags);
+ xfs_iunlock(ip, lockmode);
+ trace_xfs_iomap_found(ip, offset, length, XFS_DATA_FORK, &imap);
+- return xfs_bmbt_to_iomap(ip, iomap, &imap, flags, iomap_flags, seq);
++ return xfs_bmbt_to_iomap(ip, iomap, &imap, offset, flags, iomap_flags,
++ seq);
+
+ allocate_blocks:
+ error = -EAGAIN;
+@@ fs/xfs/xfs_iomap.c: xfs_direct_write_iomap_begin(
+ return error;
+
+ trace_xfs_iomap_alloc(ip, offset, length, XFS_DATA_FORK, &imap);
+- return xfs_bmbt_to_iomap(ip, iomap, &imap, flags,
++ return xfs_bmbt_to_iomap(ip, iomap, &imap, offset, flags,
+ iomap_flags | IOMAP_F_NEW, seq);
+
+ out_found_cow:
@@ fs/xfs/xfs_iomap.c: xfs_direct_write_iomap_begin(
trace_xfs_iomap_found(ip, offset, length - offset, XFS_COW_FORK, &cmap); if (imap.br_startblock != HOLESTARTBLOCK) {
seq = xfs_iomap_inode_sequence(ip, 0);
- error = xfs_bmbt_to_iomap(ip, srcmap, &imap, flags, 0, seq);
-+ error = xfs_bmbt_to_iomap(ip, srcmap, &imap, flags,
-+ iomap_flags & IOMAP_F_FSVERITY, seq);
++ error = xfs_bmbt_to_iomap(ip, srcmap, &imap, offset, flags,
++ 0, seq);
if (error)
goto out_unlock;
}
-@@ fs/xfs/xfs_iomap.c: xfs_zoned_direct_write_iomap_begin(
- return error;
- }
+ seq = xfs_iomap_inode_sequence(ip, IOMAP_F_SHARED);
+ xfs_iunlock(ip, lockmode);
+- return xfs_bmbt_to_iomap(ip, iomap, &cmap, flags, IOMAP_F_SHARED, seq);
++ return xfs_bmbt_to_iomap(ip, iomap, &cmap, offset, flags,
++ IOMAP_F_SHARED, seq);
-- xfs_iomap_set_anon_write(ip, iomap, offset, length);
-+ xfs_iomap_set_anon_write(ip, iomap, offset, length, 0);
- return 0;
- }
+ out_unlock:
+ if (lockmode)
+@@ fs/xfs/xfs_iomap.c: xfs_atomic_write_cow_iomap_begin(
+ trace_xfs_iomap_found(ip, offset, length, XFS_COW_FORK, &cmap);
+ seq = xfs_iomap_inode_sequence(ip, IOMAP_F_SHARED);
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
+- return xfs_bmbt_to_iomap(ip, iomap, &cmap, flags, IOMAP_F_SHARED, seq);
++ return xfs_bmbt_to_iomap(ip, iomap, &cmap, offset, flags,
++ IOMAP_F_SHARED, seq);
-@@ fs/xfs/xfs_iomap.c: xfs_zoned_fill_srcmap(
- xfs_fileoff_t offset_fsb,
- xfs_fileoff_t *end_fsb,
- unsigned flags,
-- struct iomap *srcmap)
-+ struct iomap *srcmap,
-+ u16 iomap_flags)
- {
- struct xfs_bmbt_irec smap;
- struct xfs_iext_cursor scur;
+ convert_delay:
+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
@@ fs/xfs/xfs_iomap.c: xfs_zoned_fill_srcmap(
*/
xfs_trim_extent(&smap, offset_fsb, *end_fsb - offset_fsb); *end_fsb = min(*end_fsb, smap.br_startoff + smap.br_blockcount);
- return xfs_bmbt_to_iomap(ip, srcmap, &smap, flags, 0,
-+ return xfs_bmbt_to_iomap(ip, srcmap, &smap, flags, iomap_flags,
- xfs_iomap_inode_sequence(ip, 0));
+- xfs_iomap_inode_sequence(ip, 0));
++ return xfs_bmbt_to_iomap(ip, srcmap, &smap,
++ XFS_FSB_TO_B(ip->i_mount, offset_fsb), flags,
++ 0, xfs_iomap_inode_sequence(ip, 0));
}
-@@ fs/xfs/xfs_iomap.c: xfs_zoned_buffered_write_iomap_begin(
- loff_t count,
- unsigned flags,
- struct iomap *iomap,
-- struct iomap *srcmap)
-+ struct iomap *srcmap,
-+ u16 iomap_flags)
- {
- struct iomap_iter *iter =
- container_of(iomap, struct iomap_iter, iomap);
-@@ fs/xfs/xfs_iomap.c: xfs_zoned_buffered_write_iomap_begin(
- struct xfs_mount *mp = ip->i_mount;
- xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
- xfs_fileoff_t end_fsb = xfs_iomap_end_fsb(mp, offset, count);
-- u16 iomap_flags = IOMAP_F_SHARED;
- unsigned int lockmode = XFS_ILOCK_EXCL;
- xfs_filblks_t count_fsb;
- xfs_extlen_t indlen;
-@@ fs/xfs/xfs_iomap.c: xfs_zoned_buffered_write_iomap_begin(
- !IS_ALIGNED(offset + count, mp->m_sb.sb_blocksize) ||
- (flags & IOMAP_ZERO)) {
- error = xfs_zoned_fill_srcmap(ip, offset_fsb, &end_fsb, flags,
-- srcmap);
-+ srcmap, iomap_flags);
- if (error)
- goto out_unlock;
- }
-@@ fs/xfs/xfs_iomap.c: xfs_zoned_buffered_write_iomap_begin(
- if (!ip->i_cowfp)
- xfs_ifork_init_cow(ip);
-
-+ iomap_flags |= IOMAP_F_SHARED;
-+
- if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &got))
- got.br_startoff = end_fsb;
- if (got.br_startoff <= offset_fsb) {
+ static int
+@@ fs/xfs/xfs_iomap.c: xfs_zoned_buffered_write_iomap_begin(
+ trace_xfs_iomap_alloc(ip, offset, XFS_FSB_TO_B(mp, count_fsb),
+ XFS_COW_FORK, &got);
+ done:
+- error = xfs_bmbt_to_iomap(ip, iomap, &got, flags, iomap_flags,
++ error = xfs_bmbt_to_iomap(ip, iomap, &got, offset, flags, iomap_flags,
+ xfs_iomap_inode_sequence(ip, IOMAP_F_SHARED));
+ out_unlock:
+ xfs_iunlock(ip, lockmode);
@@ fs/xfs/xfs_iomap.c: xfs_buffered_write_iomap_begin(
- if (xfs_is_shutdown(mp))
- return -EIO;
+ found_imap:
+ seq = xfs_iomap_inode_sequence(ip, iomap_flags);
+ xfs_iunlock(ip, lockmode);
+- return xfs_bmbt_to_iomap(ip, iomap, &imap, flags, iomap_flags, seq);
++ return xfs_bmbt_to_iomap(ip, iomap, &imap, offset, flags, iomap_flags,
++ seq);
-+ if (xfs_iflags_test(ip, XFS_VERITY_CONSTRUCTION))
-+ iomap_flags |= IOMAP_F_FSVERITY;
-+
- if (xfs_is_zoned_inode(ip))
- return xfs_zoned_buffered_write_iomap_begin(inode, offset,
-- count, flags, iomap, srcmap);
-+ count, flags, iomap, srcmap, iomap_flags);
-
- /* we can't use delayed allocations when using extent size hints */
- if (xfs_get_extsz_hint(ip))
+ convert_delay:
+ xfs_iunlock(ip, lockmode);
@@ fs/xfs/xfs_iomap.c: xfs_buffered_write_iomap_begin(
found_cow:
if (imap.br_startoff <= offset_fsb) {
- error = xfs_bmbt_to_iomap(ip, srcmap, &imap, flags, 0,
-+ error = xfs_bmbt_to_iomap(ip, srcmap, &imap, flags,
-+ iomap_flags & IOMAP_F_FSVERITY,
- xfs_iomap_inode_sequence(ip, 0));
+- xfs_iomap_inode_sequence(ip, 0));
++ error = xfs_bmbt_to_iomap(ip, srcmap, &imap, offset, flags,
++ 0, xfs_iomap_inode_sequence(ip, 0));
if (error)
goto out_unlock;
-@@ fs/xfs/xfs_iomap.c: xfs_read_iomap_begin(
- bool shared = false;
- unsigned int lockmode = XFS_ILOCK_SHARED;
- u64 seq;
-+ unsigned int iomap_flags = 0;
+ } else {
+@@ fs/xfs/xfs_iomap.c: xfs_buffered_write_iomap_begin(
+ iomap_flags |= IOMAP_F_SHARED;
+ seq = xfs_iomap_inode_sequence(ip, iomap_flags);
+ xfs_iunlock(ip, lockmode);
+- return xfs_bmbt_to_iomap(ip, iomap, &cmap, flags, iomap_flags, seq);
++ return xfs_bmbt_to_iomap(ip, iomap, &cmap, offset, flags, iomap_flags,
++ seq);
- ASSERT(!(flags & (IOMAP_WRITE | IOMAP_ZERO)));
-
- if (xfs_is_shutdown(mp))
- return -EIO;
-
-+ if (fsverity_active(inode) &&
-+ (offset >= xfs_fsverity_metadata_offset(ip)))
-+ iomap_flags |= IOMAP_F_FSVERITY;
-+
- error = xfs_ilock_for_iomap(ip, flags, &lockmode);
- if (error)
- return error;
+ out_unlock:
+ xfs_iunlock(ip, lockmode);
@@ fs/xfs/xfs_iomap.c: xfs_read_iomap_begin(
if (error)
return error;
trace_xfs_iomap_found(ip, offset, length, XFS_DATA_FORK, &imap);
- return xfs_bmbt_to_iomap(ip, iomap, &imap, flags,
-- shared ? IOMAP_F_SHARED : 0, seq);
-+ iomap_flags |= shared ? IOMAP_F_SHARED : 0;
-+
-+ return xfs_bmbt_to_iomap(ip, iomap, &imap, flags, iomap_flags, seq);
++ return xfs_bmbt_to_iomap(ip, iomap, &imap, offset, flags,
+ shared ? IOMAP_F_SHARED : 0, seq);
}
- static DEFINE_IOMAP_ITER_NEXT(xfs_read_iomap_next, xfs_read_iomap_begin); +@@ fs/xfs/xfs_iomap.c: xfs_seek_iomap_begin(
+ end_fsb = min(end_fsb, data_fsb);
+ xfs_trim_extent(&cmap, offset_fsb, end_fsb - offset_fsb);
+ seq = xfs_iomap_inode_sequence(ip, IOMAP_F_SHARED);
+- error = xfs_bmbt_to_iomap(ip, iomap, &cmap, flags,
++ error = xfs_bmbt_to_iomap(ip, iomap, &cmap, offset, flags,
+ IOMAP_F_SHARED, seq);
+ /*
+ * This is a COW extent, so we must probe the page cache
+@@ fs/xfs/xfs_iomap.c: xfs_seek_iomap_begin(
+ done:
+ seq = xfs_iomap_inode_sequence(ip, 0);
+ xfs_trim_extent(&imap, offset_fsb, end_fsb - offset_fsb);
+- error = xfs_bmbt_to_iomap(ip, iomap, &imap, flags, 0, seq);
++ error = xfs_bmbt_to_iomap(ip, iomap, &imap, offset, flags, 0, seq);
+ out_unlock:
+ xfs_iunlock(ip, lockmode);
+ return error;
+@@ fs/xfs/xfs_iomap.c: xfs_xattr_iomap_begin(
+ if (error)
+ return error;
+ ASSERT(nimaps);
+- return xfs_bmbt_to_iomap(ip, iomap, &imap, flags, IOMAP_F_XATTR, seq);
++ return xfs_bmbt_to_iomap(ip, iomap, &imap, offset, flags,
++ IOMAP_F_XATTR, seq);
+ }
+
+ DEFINE_IOMAP_ITER_NEXT(xfs_xattr_iomap_next, xfs_xattr_iomap_begin);
## fs/xfs/xfs_iomap.h ##
-@@ fs/xfs/xfs_iomap.h: xfs_iomap_set_anon_write(
- struct xfs_inode *ip,
- struct iomap *iomap,
- loff_t offset,
-- loff_t length)
-+ loff_t length,
-+ u16 iomap_flags)
- {
- iomap->type = IOMAP_MAPPED;
- iomap->bdev = ip->i_mount->m_rtdev_targp->bt_bdev;
- iomap->offset = offset;
- iomap->length = length;
-- iomap->flags = IOMAP_F_ANON_WRITE | IOMAP_F_DIRTY;
-+ iomap->flags = iomap_flags | IOMAP_F_ANON_WRITE | IOMAP_F_DIRTY;
- if (bdev_has_integrity_csum(iomap->bdev))
- iomap->flags |= IOMAP_F_INTEGRITY;
- }
+@@ fs/xfs/xfs_iomap.h: xfs_fileoff_t xfs_iomap_eof_align_last_fsb(struct xfs_inode *ip, +
+ u64 xfs_iomap_inode_sequence(struct xfs_inode *ip, u16 iomap_flags);
+ int xfs_bmbt_to_iomap(struct xfs_inode *ip, struct iomap *iomap,
+- struct xfs_bmbt_irec *imap, unsigned int mapping_flags,
+- u16 iomap_flags, u64 sequence_cookie);
++ struct xfs_bmbt_irec *imap, loff_t offset,
++ unsigned int mapping_flags, u16 iomap_flags,
++ u64 sequence_cookie);
+
+ int xfs_zero_range(struct xfs_inode *ip, loff_t pos, loff_t len,
+ struct xfs_zone_alloc_ctx *ac, bool *did_zero);
+
+ ## fs/xfs/xfs_pnfs.c ##
+@@ fs/xfs/xfs_pnfs.c: xfs_fs_map_blocks(
+ }
+ xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL);
+
+- error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0, 0, seq);
++ error = xfs_bmbt_to_iomap(ip, iomap, &imap, offset, 0, 0, seq);
+ *device_generation = mp->m_generation;
+ return error;
+ out_unlock:
6: b3a0bdad384a ! 6: fe7a17bb65c6 xfs: use read ioend for fsverity data verification
@@ Commit message
data that needs verification.
Signed-off-by: Andrey Albershteyn <[email protected]>
+ Reviewed-by: Christoph Hellwig <[email protected]>
## fs/xfs/Makefile ##
@@ fs/xfs/Makefile: xfs-$(CONFIG_XFS_POSIX_ACL) += xfs_acl.o
@@ fs/xfs/Makefile: xfs-$(CONFIG_XFS_POSIX_ACL) += xfs_acl.o
ifeq ($(CONFIG_MEMORY_FAILURE),y)
## fs/xfs/xfs_aops.c ##
+@@
+ #include "xfs_zone_alloc.h"
+ #include "xfs_rtgroup.h"
+ #include "xfs_verity.h"
++#include "xfs_fsverity.h"
+
+ struct xfs_writepage_ctx {
+ struct iomap_writepage_ctx ctx;
@@ fs/xfs/xfs_aops.c: xfs_bio_submit_read(
{
xfs_ioend_submit_read(iter->inode, ctx->read_ctx,
@@ fs/xfs/xfs_aops.c: xfs_vm_read_folio(
- ctx.ops = xfs_get_iomap_read_ops(folio->mapping);
+ ctx.ops = xfs_get_iomap_read_ops(folio->mapping, folio_pos(folio));
- iomap_read_folio(&xfs_read_iomap_ops, &ctx, NULL);
+ iomap_read_folio(xfs_read_iomap_next, &ctx, NULL);
return 0;
}
@@ fs/xfs/xfs_aops.c: xfs_vm_readahead(
@@ fs/xfs/xfs_aops.c: xfs_vm_readahead(
- ctx.ops = xfs_get_iomap_read_ops(rac->mapping),
+ ctx.ops = xfs_get_iomap_read_ops(rac->mapping, readahead_pos(rac));
- iomap_readahead(&xfs_read_iomap_ops, &ctx, NULL);
+ iomap_readahead(xfs_read_iomap_next, &ctx, NULL);
}
@@ fs/xfs/xfs_ioend.h: static inline bool xfs_ioend_is_append(struct iomap_ioend *i
#endif /* __XFS_IOEND_H */
## fs/xfs/xfs_super.c ##
+@@
+ #include "xfs_rtalloc.h"
+ #include "xfs_zone_alloc.h"
+ #include "xfs_healthmon.h"
++#include "xfs_fsverity.h"
+ #include "scrub/stats.h"
+ #include "scrub/rcbag_btree.h"
+
@@ fs/xfs/xfs_super.c: xfs_init_caches(void)
if (!xfs_parent_args_cache)
goto out_destroy_xmi_cache;
7: e41f43b1f4dd ! 7: c428bb5ceba4 xfs: add XFS_BMAPI_UNWRITTEN to unmap unwritten extents in __xfs_bunmapi()
@@ Commit message
Reviewed-by: "Darrick J. Wong" <[email protected]>
## fs/xfs/libxfs/xfs_bmap.c ##
+@@ fs/xfs/libxfs/xfs_bmap.c: __xfs_bunmapi(
+ ASSERT(len > 0);
+ ASSERT(nexts >= 0);
+
++ /*
++ * XFS_BMAPI_UNWRITTEN is only used by fs-verity to drop unwritten
++ * blocks past EOF while keeping written ones (fsverity metadata).
++ *
++ * The XFS_BMAPI_UNWRITTEN could not be used with realtime inodes with
++ * realtime extent larger than 1 filesystem block. This is because the
++ * realtime inode with larger extents could have EOF in the middle of
++ * the extent. Removing these unwritten extent beyond EOF could lead to
++ * removal of data before EOF.
++ *
++ * fs-verity is not allowed to be enabled on realtime files whose
++ * extent size is larger than 1.
++ */
++ ASSERT(!((flags & XFS_BMAPI_UNWRITTEN) &&
++ xfs_inode_has_bigrtalloc(ip)));
++
+ error = xfs_iread_extents(tp, ip, whichfork);
+ if (error)
+ return error;
@@ fs/xfs/libxfs/xfs_bmap.c: __xfs_bunmapi(
if (del.br_startoff + del.br_blockcount > end + 1)
del.br_blockcount = end + 1 - del.br_startoff;
@@ fs/xfs/libxfs/xfs_bmap.c: __xfs_bunmapi(
## fs/xfs/libxfs/xfs_bmap.h ##
@@ fs/xfs/libxfs/xfs_bmap.h: struct xfs_bmalloca {
- /* Try to align allocations to the extent size hint */
- #define XFS_BMAPI_EXTSZALIGN (1u << 11)
+ */
+ #define XFS_BMAPI_CONVERT_ONLY (1u << 12)
+/* Process unwritten extents only. Used for unmapping */
-+#define XFS_BMAPI_UNWRITTEN (1u << 12)
++#define XFS_BMAPI_UNWRITTEN (1u << 13)
+
#define XFS_BMAPI_FLAGS \
{ XFS_BMAPI_ENTIRE, "ENTIRE" }, \
{ XFS_BMAPI_METADATA, "METADATA" }, \
@@ fs/xfs/libxfs/xfs_bmap.h: struct xfs_bmalloca {
- { XFS_BMAPI_COWFORK, "COWFORK" }, \
{ XFS_BMAPI_NODISCARD, "NODISCARD" }, \
{ XFS_BMAPI_NORMAP, "NORMAP" },\
-- { XFS_BMAPI_EXTSZALIGN, "EXTSZALIGN" }
-+ { XFS_BMAPI_EXTSZALIGN, "EXTSZALIGN" }, \
+ { XFS_BMAPI_EXTSZALIGN, "EXTSZALIGN" }, \
+- { XFS_BMAPI_CONVERT_ONLY, "CONVERT_ONLY" }
++ { XFS_BMAPI_CONVERT_ONLY, "CONVERT_ONLY" }, \
+ { XFS_BMAPI_UNWRITTEN, "UNWRITTEN" } 8: 8a033752cc2e ! 8: f62ffd5f8991 xfs: don't remove written extents past EOF on fsverity inodes
@@ fs/xfs/xfs_bmap_util.c: xfs_can_free_eofblocks(
+ /*
+ * Don't clean fsverity inodes as they already have been cleaned up and
+ * are read-only. Skip inodes which have merkle tree being built, the
-+ * merkle tree is written beyond EOF
++ * merkle tree is written beyond EOF. Skip inodes which have
++ * XFS_DIFLAG2_VERITY in case this kernel has fsverity disabled.
+ */
+ if (fsverity_active(VFS_IC(ip)) ||
-+ xfs_iflags_test(ip, XFS_VERITY_CONSTRUCTION))
++ fsverity_is_building(VFS_I(ip)) ||
++ ip->i_diflags2 & XFS_DIFLAG2_VERITY)
+ return false;
+
/*
@@ fs/xfs/xfs_bmap_util.c: xfs_free_eofblocks(
struct xfs_mount *mp = ip->i_mount;
int error;
+ int bmapi_flags = XFS_BMAPI_NODISCARD;
-+ bool has_verity =
-+ ip->i_diflags2 & XFS_DIFLAG2_VERITY;
++ bool verity = fsverity_is_building(VFS_I(ip));
/* Attach the dquots to the inode up front. */
error = xfs_qm_dqattach(ip);
@@ fs/xfs/xfs_bmap_util.c: xfs_free_eofblocks(
*/
- if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) {
+ if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND) ||
-+ has_verity) {
++ verity) {
if (ip->i_delayed_blks) {
xfs_bmap_punch_delalloc_range(ip, XFS_DATA_FORK,
round_up(XFS_ISIZE(ip), mp->m_sb.sb_blocksize),
@@ fs/xfs/xfs_bmap_util.c: xfs_free_eofblocks(
}
xfs_inode_clear_eofblocks_tag(ip);
- return 0;
-+ if (!has_verity)
++ if (!verity)
+ return 0;
}
@@ fs/xfs/xfs_bmap_util.c: xfs_free_eofblocks(
+ * While fs-verity writes metadata after EOF, it can leave unwritten
+ * preallocations. Clear all that out.
+ */
-+ if (has_verity)
++ if (verity)
+ bmapi_flags |= XFS_BMAPI_UNWRITTEN;
+
/*
@@ fs/xfs/xfs_bmap_util.c: xfs_free_eofblocks(
if (error)
goto err_cancel;
+
+ ## fs/xfs/xfs_icache.c ##
+@@
+ #include "xfs_da_format.h"
+ #include "xfs_dir2.h"
+ #include "xfs_metafile.h"
+-
++#include <linux/fsverity.h>
+ #include <linux/iversion.h>
+
+ /* Radix tree tags for incore inode tree. */
+@@ fs/xfs/xfs_icache.c: xfs_inode_free_eofblocks(
+ if (xfs_can_free_eofblocks(ip))
+ return xfs_free_eofblocks(ip);
+
++ /*
++ * The above xfs_free_eofblocks() is skipped for inodes with fsverity
++ * tree is being built. However, we don't want to clear EOF tag in this
++ * case. If building the tree fails, inode will have EOF blocks which
++ * needs removal.
++ */
++ if (fsverity_is_building(VFS_IC(ip)))
++ return 0;
++
+ /* inode could be preallocated */
+ trace_xfs_inode_free_eofblocks_invalid(ip);
+ xfs_inode_clear_eofblocks_tag(ip);
9: f528fd0329d9 ! 9: 5f6f04fde6e4 xfs: add fs-verity support
@@ Commit message
locate descriptor.
Signed-off-by: Andrey Albershteyn <[email protected]>
- Reviewed-by: Christoph Hellwig <[email protected]>
+
+ ## fs/xfs/libxfs/xfs_inode_buf.c ##
+@@ fs/xfs/libxfs/xfs_inode_buf.c: xfs_dinode_verify(
+ return __this_address;
+ if (!S_ISREG(mode))
+ return __this_address;
++ /*
++ * fs-verity stores the Merkle tree past EOF, so it cannot
++ * coexist with a realtime allocation unit larger than a single
++ * filesystem block. This is because we remove any unwritten
++ * extents beyond EOF for fs-verity inodes. The realtime inode
++ * with larger extents could have EOF in the middle of the
++ * extent. Enabling fsverity on such inode could lead to removal
++ * of data before EOF.
++ */
++ if ((flags & XFS_DIFLAG_REALTIME) && mp->m_sb.sb_rextsize > 1)
++ return __this_address;
+ }
+
+ if (xfs_has_zoned(mp) &&
## fs/xfs/xfs_fsverity.c ##
@@
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ uint32_t blocksize = i_blocksize(VFS_I(ip));
+ xfs_fileoff_t last_block_offset;
+
++ /*
++ * fs-verity cannot be used when the filesystem block size exceeds the
++ * page size, as the Merkle tree folios are compound and PG_checked is
++ * not supported on compound folios. Reject such inodes so that they
++ * cannot be opened and read as verity files.
++ */
++ if (mp->m_sb.sb_blocksize > PAGE_SIZE)
++ return -EOPNOTSUPP;
++
+ xfs_ilock(ip, XFS_ILOCK_EXCL);
+ /*
+ * Serialize reading of inode->i_flags with xfs_scrub clearing of this
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ if (is_empty)
+ return -ENODATA;
+
++ /*
++ * Make sure we can open large file on a 32-bit kernel
++ */
++ if (rec.br_startoff + rec.br_blockcount >
++ XFS_B_TO_FSB(mp, inode->i_sb->s_maxbytes))
++ return -EFBIG;
++
+ last_block_offset =
+ XFS_FSB_TO_B(mp, rec.br_startoff + rec.br_blockcount);
+ if (last_block_offset <= xfs_fsverity_metadata_offset(ip))
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ round_up(desc_end + sizeof(desc_size_disk), blksize) -
+ sizeof(desc_size_disk);
+
++ if (desc_size_pos + sizeof(desc_size_disk) > inode->i_sb->s_maxbytes)
++ return -EFBIG;
++
+ error = iomap_fsverity_write(file, desc_size_pos, sizeof(__be32),
+ (const void *)&desc_size_disk,
-+ &xfs_buffered_write_iomap_ops,
++ xfs_buffered_write_iomap_next,
+ &xfs_iomap_write_ops);
+ if (error)
+ return error;
+
+ return iomap_fsverity_write(file, desc_pos, desc_size, desc,
-+ &xfs_buffered_write_iomap_ops,
++ xfs_buffered_write_iomap_next,
+ &xfs_iomap_write_ops);
+}
+
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ return -EINVAL;
+
+ /*
++ * fs-verity tracks verified Merkle tree pages using PG_checked, which
++ * is only valid on single-page (non-compound) folios. When the
++ * filesystem block size is larger than the page size, the page cache
++ * enforces a minimum folio order > 0, so all Merkle tree folios are
++ * compound. fs-verity cannot be used on such filesystems.
++ */
++ if (ip->i_mount->m_sb.sb_blocksize > PAGE_SIZE)
++ return -EOPNOTSUPP;
++
++ /*
++ * fs-verity doesn't work on zoned
++ */
++ if (xfs_is_zoned_inode(ip))
++ return -EOPNOTSUPP;
++
++ /*
+ * fs-verity stores the Merkle tree past EOF in units of the filesystem
+ * block size, so it cannot support realtime files whose allocation unit
+ * (extent size) is larger than the block size.
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ if (xfs_inode_has_bigrtalloc(ip))
+ return -EINVAL;
+
-+ if (inode->i_size > XFS_FSVERITY_LARGEST_FILE)
++ if (XFS_B_TO_FSB(ip->i_mount, inode->i_size) >
++ XFS_FSVERITY_LARGEST_FILE_FSB(ip->i_mount))
+ return -EFBIG;
+
+ /*
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ if (error)
+ return error;
+
-+ if (xfs_iflags_test_and_set(ip, XFS_VERITY_CONSTRUCTION))
-+ return -EBUSY;
-+
+ error = xfs_qm_dqattach(ip);
+ if (error)
-+ goto out_clear;
++ return error;
+
-+ error = xfs_fsverity_delete_metadata(ip);
-+ if (error)
-+ goto out_clear;
-+ return error;
-+out_clear:
-+ xfs_iflags_clear(ip, XFS_VERITY_CONSTRUCTION);
-+ return error;
++ return xfs_fsverity_delete_metadata(ip);
+}
+
+/*
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ struct xfs_mount *mp = ip->i_mount;
+ struct xfs_trans *tp;
+ int error = 0;
++ int error2;
+ loff_t range_start = xfs_fsverity_metadata_offset(ip);
+
+ xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL);
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+
+ /*
+ * Wait for Merkle tree get written to disk before setting on-disk inode
-+ * flag and clearing XFS_VERITY_CONSTRUCTION
++ * flag and clearing I_VERITY_BUILDING
+ */
+ error = filemap_write_and_wait_range(inode->i_mapping, range_start,
+ LLONG_MAX);
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ goto out;
+
+ /*
-+ * Set fsverity inode flag
-+ */
-+ error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_ichange,
-+ 0, 0, false, &tp);
-+ if (error)
-+ goto out;
-+
-+ /*
-+ * Ensure that we've persisted the verity information before we enable
-+ * it on the inode and tell the caller we have sealed the inode.
-+ */
-+ ip->i_diflags2 |= XFS_DIFLAG2_VERITY;
-+
-+ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-+ xfs_trans_set_sync(tp);
-+
-+ error = xfs_trans_commit(tp);
-+ xfs_iunlock(ip, XFS_ILOCK_EXCL);
-+ if (error)
-+ goto out;
-+
-+ inode_set_flags(inode, S_VERITY, S_VERITY);
-+
-+ /*
+ * Proactively remove unwritten extents left by COW preallocations and
+ * write preallocation in the merkle tree holes and past descriptor,
+ * and any delayed preallocations
+ */
+ error = xfs_free_eofblocks(ip);
++ if (error)
++ goto out;
++
++ /*
++ * Set fsverity inode flag
++ */
++ error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_ichange,
++ 0, 0, false, &tp);
++ if (error)
++ goto out;
++
++ /*
++ * Ensure that we've persisted the verity information before we enable
++ * it on the inode and tell the caller we have sealed the inode.
++ */
++ ip->i_diflags2 |= XFS_DIFLAG2_VERITY;
++
++ xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
++ xfs_trans_set_sync(tp);
++
++ error = xfs_trans_commit(tp);
++ xfs_iunlock(ip, XFS_ILOCK_EXCL);
++ if (error)
++ goto out;
++
++ inode_set_flags(inode, S_VERITY, S_VERITY);
++ return error;
++
+out:
-+ if (error) {
-+ int error2;
-+
-+ error2 = xfs_fsverity_reset_inode(ip);
-+ if (error2)
-+ xfs_alert(ip->i_mount,
++ error2 = xfs_fsverity_reset_inode(ip);
++ if (error2)
++ xfs_alert(ip->i_mount,
+"ino 0x%llx failed to clean up new fsverity metadata, err %d",
-+ I_INO(ip), error2);
-+ }
++ I_INO(ip), error2);
+
-+ xfs_iflags_clear(ip, XFS_VERITY_CONSTRUCTION);
+ return error;
+}
+
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_is_file_data(
+ return 0;
+
+ return iomap_fsverity_write(file, position, size, buf,
-+ &xfs_buffered_write_iomap_ops,
++ xfs_buffered_write_iomap_next,
+ &xfs_iomap_write_ops);
+}
+
@@ fs/xfs/xfs_fsverity.h
void xfs_fsverity_exit(void);
bool xfs_fsverity_is_file_data(const struct xfs_inode *ip, loff_t offset);
+ ## fs/xfs/xfs_ioctl.c ##
+@@ fs/xfs/xfs_ioctl.c: xfs_ioctl_setattr_xflags(
+ if (xfs_inode_has_filedata(ip))
+ return -EINVAL;
+
++ /*
++ * fs-verity is incompatible with a realtime allocation unit
++ * larger than a single filesystem block, so don't let a file be
++ * converted to realtime while verity is being enabled.
++ */
++ if (fsverity_is_building(VFS_IC(ip)))
++ return -EINVAL;
++
+ /*
+ * If S_DAX is enabled on this file, we can only switch the
+ * device if both support fsdax. We can't update S_DAX because
+@@ fs/xfs/xfs_ioctl.c: xfs_ioctl_setattr_xflags(
+ return -EINVAL;
+ }
+
++ /*
++ * fs-verity is incompatible with DAX, and xfs_fsverity_begin_enable()
++ * verified the inode was not DAX under the inode lock. That lock is
++ * dropped while the Merkle tree is built, so reject enabling DAX while
++ * verity is being enabled.
++ */
++ if ((fa->fsx_xflags & FS_XFLAG_DAX) &&
++ !(ip->i_diflags2 & XFS_DIFLAG2_DAX) &&
++ fsverity_is_building(VFS_IC(ip)))
++ return -EINVAL;
++
+ if (rtflag) {
+ /* If realtime flag is set then must have realtime device */
+ if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
+
## fs/xfs/xfs_message.c ##
@@ fs/xfs/xfs_message.c: xfs_warn_experimental(
.opstate = XFS_OPSTATE_WARNED_LARP,
10: 827908e045f1 = 10: 9206c4a644f1 xfs: initialize fs-verity on file open
11: d13b62d8ce52 = 11: 856483dbd534 xfs: add fs-verity ioctls
12: 69d2733475a1 = 12: 31f7e8a2669e xfs: advertise fs-verity being available on filesystem
13: 3b40328cc8e2 ! 13: dfabd8df8c89 xfs: check and repair the verity inode flag state
@@ Commit message
If an inode has the incore verity iflag set, make sure that we can
actually activate fsverity on that inode. If activation fails due to
- a fsverity metadata validation error, clear the flag. The usage model
- for fsverity requires that any program that cares about verity state is
- required to call statx/getflags to check that the flag is set after
- opening the file, so clearing the flag will not compromise that model.
+ a fsverity metadata validation error, clear the flag and delete
+ fs-verity metadata. The usage model for fsverity requires that any
+ program that cares about verity state is required to call statx/getflags
+ to check that the flag is set after opening the file, so clearing the
+ flag will not compromise that model.
Signed-off-by: Darrick J. Wong <[email protected]>
Signed-off-by: Andrey Albershteyn <[email protected]>
- Reviewed-by: Christoph Hellwig <[email protected]>
## fs/xfs/scrub/common.c ##
@@
@@ fs/xfs/scrub/common.h: int xchk_inode_is_allocated(struct xfs_scrub *sc, xfs_agi
## fs/xfs/scrub/inode.c ##
@@ fs/xfs/scrub/inode.c: xchk_prepare_iscrub(
+ struct xfs_scrub *sc)
+ {
+ int error;
++ struct xfs_inode *ip = sc->ip;
xchk_ilock(sc, XFS_IOLOCK_EXCL);
+ error = xchk_inode_setup_verity(sc);
+ if (error)
+ return error;
++
++ /*
++ * If we're going to repair a file whose fsverity descriptor cannot be
++ * activated, drop the stale Merkle tree folios. Once the
++ * post-EOF Merkle extents are freed during repair, those uptodate
++ * folios would otherwise sit over a hole and could be exposed as file
++ * data by a later extending write or truncate.
++ *
++ * The lock would be unlocked by global scrub machinery.
++ */
++ if (xchk_could_repair(sc) && xchk_inode_verity_broken(ip)) {
++ xchk_ilock(sc, XFS_MMAPLOCK_EXCL);
++ truncate_inode_pages(VFS_I(ip)->i_mapping, XFS_ISIZE(ip));
++ }
+
error = xchk_trans_alloc(sc, 0);
if (error)
@@ fs/xfs/scrub/inode_repair.c: xrep_inode_reset_dquots(
+/*
+ * If this file is a fsverity file, xchk_prepare_iscrub or xrep_dinode_core
+ * should have activated it. If it's still not active, then there's something
-+ * wrong with the verity descriptor and we should turn it off.
++ * wrong with the verity descriptor, so turn verity off and free the orphaned
++ * Merkle tree that XFS keeps in extents beyond EOF.
+ */
+STATIC int
+xrep_inode_verity(
+ struct xfs_scrub *sc)
+{
+ struct inode *inode = VFS_I(sc->ip);
++ struct xfs_mount *mp = sc->mp;
++ int error;
+
-+ if (xchk_inode_verity_broken(sc->ip)) {
-+ sc->ip->i_diflags2 &= ~XFS_DIFLAG2_VERITY;
-+ inode_set_flags(inode, 0, S_VERITY);
++ if (!xchk_inode_verity_broken(sc->ip))
++ return 0;
+
-+ xfs_trans_log_inode(sc->tp, sc->ip, XFS_ILOG_CORE);
-+ }
++ /*
++ * The fsverity descriptor cannot be activated, so disable verity and
++ * free the Merkle tree, which XFS stores in beyond EOF. The stale
++ * Merkle tree page cache was already dropped during scrub setup.
++ */
++ error = xfs_bunmapi_range(&sc->tp, sc->ip, 0,
++ XFS_B_TO_FSB(mp, XFS_ISIZE(sc->ip)), XFS_MAX_FILEOFF);
++ if (error)
++ return error;
+
++ sc->ip->i_diflags2 &= ~XFS_DIFLAG2_VERITY;
++ inode_set_flags(inode, 0, S_VERITY);
++
++ xfs_trans_log_inode(sc->tp, sc->ip, XFS_ILOG_CORE);
+ return 0;
+}
+
14: 7ae522f75fbd ! 14: 6e4fdcf643b6 xfs: introduce health state for corrupted fsverity metadata
@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_get_descriptor(
return -ENODATA;
+ }
+ /*
+ * Make sure we can open large file on a 32-bit kernel
+@@ fs/xfs/xfs_fsverity.c: xfs_fsverity_get_descriptor(
+
last_block_offset =
XFS_FSB_TO_B(mp, rec.br_startoff + rec.br_blockcount);
- if (last_block_offset <= xfs_fsverity_metadata_offset(ip))15: e2034d8bdff1 = 15: 28c74513a1bf xfs: enable ro-compat fs-verity flag
Signature · 1 line
2.54.0
PATCH v19 1/15 xfs: introduce fsverity on-disk changes
Introduce XFS_DIFLAG2_VERITY for inodes with fsverity. This flag indicates that inode has fs-verity enabled (i.e. descriptor exist, tree is built and file is read-only).
Introduce XFS_SB_FEAT_RO_COMPAT_VERITY for filesystems having fsverity inodes. As on-disk changes applies to fsverity inodes only, let older kernels read-only access. This will be enabled in the further patch after full fsverity support.
--- fs/xfs/libxfs/xfs_format.h | 26 +++++++++++++++++++++++++- fs/xfs/libxfs/xfs_inode_buf.c | 8 ++++++++ fs/xfs/libxfs/xfs_inode_util.c | 5 ++++- fs/xfs/libxfs/xfs_sb.c | 2 ++ fs/xfs/xfs_iops.c | 5 ++++- fs/xfs/xfs_mount.h | 2 ++ 6 files changed, 45 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_format.h +25 -1
@@ -374,6 +374,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 | \
@@ -1234,16 +1235,21 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)*/ #define XFS_DIFLAG2_METADATA_BIT 5 +/* inodes sealed with fs-verity */ +#define XFS_DIFLAG2_VERITY_BIT 6 +#define XFS_DIFLAG2_DAX (1ULL << XFS_DIFLAG2_DAX_BIT)#define XFS_DIFLAG2_REFLINK (1ULL << XFS_DIFLAG2_REFLINK_BIT)#define XFS_DIFLAG2_COWEXTSIZE (1ULL << XFS_DIFLAG2_COWEXTSIZE_BIT)#define XFS_DIFLAG2_BIGTIME (1ULL << XFS_DIFLAG2_BIGTIME_BIT)#define XFS_DIFLAG2_NREXT64 (1ULL << XFS_DIFLAG2_NREXT64_BIT)#define XFS_DIFLAG2_METADATA (1ULL << XFS_DIFLAG2_METADATA_BIT) +#define XFS_DIFLAG2_VERITY (1ULL << 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_METADATA) + XFS_DIFLAG2_BIGTIME | XFS_DIFLAG2_NREXT64 | XFS_DIFLAG2_METADATA | \ + XFS_DIFLAG2_VERITY)static inline bool xfs_dinode_has_bigtime (const struct xfs_dinode *dip) {
@@ -2031,4 +2037,22 @@ struct xfs_acl {#define SGI_ACL_FILE_SIZE (sizeof(SGI_ACL_FILE)-1)#define SGI_ACL_DEFAULT_SIZE (sizeof(SGI_ACL_DEFAULT)-1) +/* +* fs-verity stores the Merkle tree in the data fork past EOF, so the file data +* blocks and the tree blocks share the inode's xfs_fileoff_t address space. +* Cap a verity file at half of the addressable file-offset range (in filesystem +* blocks) so the Merkle tree always fits in the other half. +*/ +#define XFS_FSVERITY_LARGEST_FILE_FSB (mp) \ + (XFS_B_TO_FSBT((mp), MAX_LFS_FILESIZE) >> 1) + +/* +* Alignment of the fsverity metadata placement. This is largest supported PAGE +* SIZE for fsverity. This is used to space out data and metadata in page cache. +* The spacing is necessary for non-exposure of metadata to userspace and +* correct merkle tree synthesis in the iomap. +*/ +#define XFS_FSVERITY_START_ALIGN (65536) + +#endif /* __XFS_FORMAT_H__ */
fs/xfs/libxfs/xfs_inode_buf.c +8 -0
@@ -758,6 +758,14 @@ xfs_dinode_verify( !xfs_has_rtreflink(mp))return __this_address; +/* only regular files can have fsverity */ +if (flags2 &XFS_DIFLAG2_VERITY ) { +if (!xfs_has_verity (mp)) +return __this_address; +if (!S_ISREG (mode)) +return __this_address; + } +if (xfs_has_zoned (mp) && dip->di_metatype ==cpu_to_be16 (XFS_METAFILE_RTRMAP )) {if (be32_to_cpu (dip->di_used_blocks) > mp->m_sb.sb_rgextents)
fs/xfs/libxfs/xfs_inode_util.c +4 -1
@@ -73,7 +73,8 @@ xfs_flags2diflags2(uint64_t di_flags2 = (ip->i_diflags2 & (XFS_DIFLAG2_REFLINK |XFS_DIFLAG2_BIGTIME | -XFS_DIFLAG2_NREXT64 )); +XFS_DIFLAG2_NREXT64 | +XFS_DIFLAG2_VERITY ));if (xflags &FS_XFLAG_DAX ) di_flags2 |=XFS_DIFLAG2_DAX ;
@@ -125,6 +126,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/libxfs/xfs_sb.c +2 -0
@@ -164,6 +164,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_iops.c +4 -1
@@ -1415,12 +1415,15 @@ 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 * the VFS, so we cannot mask off S_DAX in i_flags. */ - inode->i_flags &= ~(S_IMMUTABLE |S_APPEND |S_SYNC |S_NOATIME ); + inode->i_flags &= + ~(S_IMMUTABLE |S_APPEND |S_SYNC |S_NOATIME |S_VERITY ); inode->i_flags |= flags; }
fs/xfs/xfs_mount.h +2 -0
@@ -403,6 +403,7 @@ typedef struct xfs_mount {#define XFS_FEAT_EXCHANGE_RANGE (1ULL << 27)/* exchange range */ #define XFS_FEAT_METADIR (1ULL << 28)/* metadata directory tree */ #define XFS_FEAT_ZONED (1ULL << 29)/* zoned RT device */ +#define XFS_FEAT_VERITY (1ULL << 30)/* fs-verity */ /* Mount features */ #define XFS_FEAT_NOLIFETIME (1ULL << 47)/* disable lifetime hints */
@@ -460,6 +461,7 @@ __XFS_HAS_FEAT(exchange_range, EXCHANGE_RANGE) __XFS_HAS_FEAT(metadir, METADIR) __XFS_HAS_FEAT(zoned, ZONED) __XFS_HAS_FEAT(nolifetime, NOLIFETIME) +__XFS_HAS_FEAT(verity, VERITY)static inline bool xfs_has_rtgroups (const struct xfs_mount *mp) {
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v19 01/15] xfs: introduce fsverity on-disk changes
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider: - [Medium] xfs: missing FS_VERITY_FL in xfs_fileattr_set() breaks FS_IOC_SETFLAGS --
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider:
- [Medium] xfs: missing FS_VERITY_FL in xfs_fileattr_set() breaks FS_IOC_SETFLAGS
--
commit 6ecc983ef533264f23250c3f4f069d8b6005a644
Author: Andrey Albershteyn <[email protected]>
xfs: introduce fsverity on-disk changes
This commit introduces on-disk format definitions for fs-verity in XFS, including XFS_SB_FEAT_RO_COMPAT_VERITY and XFS_DIFLAG2_VERITY, along with inode verifier checks and flag conversions.
Quoted 15 lines
fs/xfs/libxfs/xfs_inode_util.c +2
-1@@ -73,7 +73,8 @@ xfs_flags2diflags2(uint64_t di_flags2 = (ip->i_diflags2 & (XFS_DIFLAG2_REFLINK |XFS_DIFLAG2_BIGTIME | -XFS_DIFLAG2_NREXT64 )); +XFS_DIFLAG2_NREXT64 | +XFS_DIFLAG2_VERITY ));if (xflags &FS_XFLAG_DAX ) di_flags2 |=XFS_DIFLAG2_DAX ;
fs/xfs/libxfs/xfs_inode_util.c xfs_ip2xflags( · line 131
Quoted 6 lines
fs/xfs/libxfs/xfs_inode_util.c +2
-0@@ -125,6 +126,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 ; }
[Severity: Medium]
Does exposing FS_XFLAG_VERITY in xfs_ip2xflags() without allowing FS_VERITY_FL in xfs_fileattr_set() break FS_IOC_SETFLAGS on verity inodes?
When FS_IOC_GETFLAGS runs on a verity inode, xfs_fileattr_get() -> xfs_fill_fsxattr() -> fileattr_fill_xflags() translates FS_XFLAG_VERITY into FS_VERITY_FL in fa->flags. When userspace such as chattr(1) modifies an unrelated flag (like FS_NOATIME_FL or FS_IMMUTABLE_FL) and writes the flags back via FS_IOC_SETFLAGS, xfs_fileattr_set() checks fa->flags against an allowlist that does not include FS_VERITY_FL:
fs/xfs/xfs_ioctl.c:xfs_fileattr_set() {
...
if (!fa->fsx_valid) {
unsigned int allowed = FS_IMMUTABLE_FL | FS_APPEND_FL |
FS_NOATIME_FL | FS_NODUMP_FL |
FS_SYNC_FL | FS_DAX_FL |
FS_PROJINHERIT_FL;
if (xfs_has_asciici(mp))
allowed |= FS_CASEFOLD_FL;
if (fa->flags & ~allowed)
return -EOPNOTSUPP;
}
...
}Because FS_VERITY_FL is still present in fa->flags from the GETFLAGS read, FS_IOC_SETFLAGS fails with -EOPNOTSUPP.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Re: [PATCH v19 01/15] xfs: introduce fsverity on-disk changes
Quoted 10 lines · On Fri, Nov 20, 2026 at 04:26:31PM +0000, [email protected] wrote:
[Severity: Medium]
Does exposingFS_XFLAG_VERITYinxfs_ip2xflags()without allowingFS_VERITY_FLinxfs_fileattr_set()breakFS_IOC_SETFLAGSon verity inodes?When
FS_IOC_GETFLAGSruns on a verity inode,xfs_fileattr_get()->xfs_fill_fsxattr()->fileattr_fill_xflags()translatesFS_XFLAG_VERITYintoFS_VERITY_FLinfa->flags. When userspace such as chattr(1) modifies an unrelated flag (likeFS_NOATIME_FLorFS_IMMUTABLE_FL) and writes the flags back viaFS_IOC_SETFLAGS,xfs_fileattr_set()checksfa->flagsagainst an allowlist that does not includeFS_VERITY_FL:
Yeah. ext4 just ignores flags like verity in fileattr_set. Should we do the same here?
Re: [PATCH v19 01/15] xfs: introduce fsverity on-disk changes
Quoted 12 lines · Christoph Hellwig
Quoted 10 lines · On Fri, Nov 20, 2026 at 04:26:31PM +0000, [email protected] wrote:
[Severity: Medium]
Does exposingFS_XFLAG_VERITYinxfs_ip2xflags()without allowingFS_VERITY_FLinxfs_fileattr_set()breakFS_IOC_SETFLAGSon verity inodes?When
FS_IOC_GETFLAGSruns on a verity inode,xfs_fileattr_get()->xfs_fill_fsxattr()->fileattr_fill_xflags()translatesFS_XFLAG_VERITYintoFS_VERITY_FLinfa->flags. When userspace such as chattr(1) modifies an unrelated flag (likeFS_NOATIME_FLorFS_IMMUTABLE_FL) and writes the flags back viaFS_IOC_SETFLAGS,xfs_fileattr_set()checksfa->flagsagainst an allowlist that does not includeFS_VERITY_FL:
Quoted 2 lines
Yeah. ext4 just ignores flags like verity in
fileattr_set. Should we do the same here?
yes, fixed in the other patchset [1]
1: https://lore.kernel.org/fsverity/[email protected]/T/#m96800af1279dd56736b8199528c1c6238984e2f9
Signature · 1 line
- Andrey
PATCH v19 2/15 xfs: don't allow to enable DAX on fs-verity sealed inode
In reply to Andrey Albershteynfs-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
@@ -1387,6 +1387,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 )
Signature · 1 line
2.54.0
PATCH v19 3/15 xfs: disable direct read path for fs-verity files
In reply to Andrey AlbershteynThe 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.
Add a fall back to buffered I/O at two place, in a common fast path and latter when lock is acquired. The second check prevents TOCTOU issue with reading fsverity_active() status and resetting IOCB_DIRECT flag.
If one thread saw fsverity_active() to be false, and then second thread acquired XFS_IOLOCK_EXCL and enabled fsverity. The first thread will go through the DIO path.
--- fs/xfs/xfs_file.c | 61 +++++++++++++++++++++++++++++++---------------- 1 file changed, 41 insertions(+), 20 deletions(-)
fs/xfs/xfs_file.c +41 -20
@@ -38,6 +38,7 @@#include <linux/mount.h> #include <linux/filelock.h> #include <linux/bio-integrity.h> +#include <linux/fsverity.h> static const struct vm_operations_struct xfs_file_vm_ops;
@@ -189,6 +190,25 @@ static const struct iomap_dio_ops xfs_dio_read_bounce_ops = { .bio_set = &iomap_ioend_bioset, }; +STATIC ssize_t +xfs_file_buffered_read ( +struct kiocb *iocb, +struct iov_iter *to) +{ +struct xfs_inode *ip =XFS_I (file_inode (iocb->ki_filp)); +ssize_t ret; + +trace_xfs_file_buffered_read (iocb, to); + + ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED ); +if (ret) +return ret; + ret =generic_file_read_iter (iocb, to); +xfs_iunlock (ip,XFS_IOLOCK_SHARED ); + +return ret; +} + STATIC ssize_t xfs_file_dio_read( struct kiocb *iocb,
@@ -207,6 +227,17 @@ xfs_file_dio_read( ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED );if (ret)return ret; + +/* +* Re-check verity status after acquiring lock. This prevents TOCTOU in +* xfs_file_read_iter() while falling back from DIO to buffered I/O as +* now we are holding a lock +*/ +if (fsverity_active (VFS_I (ip))) { +xfs_iunlock (ip,XFS_IOLOCK_SHARED ); + iocb->ki_flags &= ~IOCB_DIRECT ; +return xfs_file_buffered_read (iocb, to); + }if (mapping_stable_writes (iocb->ki_filp->f_mapping)) { ret =iomap_dio_rw (iocb, to, xfs_read_iomap_next, &xfs_dio_read_bounce_ops,0 ,NULL ,0 );
@@ -226,7 +257,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);
@@ -244,25 +276,6 @@ xfs_file_dax_read(return ret; } -STATIC ssize_t -xfs_file_buffered_read ( -struct kiocb *iocb, -struct iov_iter *to) -{ -struct xfs_inode *ip =XFS_I (file_inode (iocb->ki_filp)); -ssize_t ret; - -trace_xfs_file_buffered_read (iocb, to); - - ret =xfs_ilock_iocb (iocb,XFS_IOLOCK_SHARED ); -if (ret) -return ret; - ret =generic_file_read_iter (iocb, to); -xfs_iunlock (ip,XFS_IOLOCK_SHARED ); - -return ret; -} - STATIC ssize_t xfs_file_read_iter( struct kiocb *iocb,
@@ -277,6 +290,14 @@ xfs_file_read_iter(if (xfs_is_shutdown (mp))return -EIO ; +/* +* 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()) +*/ +if (fsverity_active (inode)) + iocb->ki_flags &= ~IOCB_DIRECT ; +if (IS_DAX (inode)) ret =xfs_file_dax_read (iocb, to);else if (iocb->ki_flags &IOCB_DIRECT )
Signature · 1 line
2.54.0
PATCH v19 4/15 xfs: don't report dio_mem_align and dio_offset_align for fsverity files
In reply to Andrey AlbershteynSashiko.dev reported that while fsverity files falls back to the buffered IO for Direct I/O, they should not report non-zero values in dio_mem_align and dio_offset_align, meaning it's not supported.
The STATX_DIOALIGN | STATX_DIO_READ_ALIGN flags are used to explicitly report if DIO is supported or not. They can not indicate that fallback to the buffered IO is used in this case. The zero alignment values also mean that DIO is not supported on this file, see statx(2).
--- fs/xfs/xfs_iops.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
fs/xfs/xfs_iops.c +13 -0
@@ -35,6 +35,7 @@#include <linux/security.h> #include <linux/iversion.h> #include <linux/fiemap.h> +#include <linux/fsverity.h> /* * Directories have different lock order w.r.t. mmap_lock compared to regular
@@ -579,6 +580,18 @@ xfs_report_dioalign(struct block_device *bdev = target->bt_bdev; stat->result_mask |=STATX_DIOALIGN |STATX_DIO_READ_ALIGN ; + +/* +* The STATX_DIOALIGN | STATX_DIO_READ_ALIGN flags are used to +* explicitly report if DIO is supported or not. They can not indicate +* that fallback to the buffered IO is used for fsverity. +* +* Return zero alignment values which also mean that DIO is not +* supported on this file, see statx(2). +*/ +if (fsverity_active (VFS_I (ip))) +return ; + stat->dio_mem_align =bdev_dma_alignment (bdev) +1 ;/*
Signature · 1 line
2.54.0
PATCH v19 5/15 xfs: handle fsverity I/O in write/read path
In reply to Andrey AlbershteynFor write/writeback set IOMAP_F_FSVERITY flag telling iomap to not update inode size and to not skip folios beyond EOF.
Initiate fsverity writeback with IOMAP_F_FSVERITY set to tell iomap should not skip folio that is dirty beyond EOF.
In read path let iomap know that we are reading fsverity metadata. So, treat holes in the tree as request to synthesize tree blocks and hole after descriptor as end of the fsverity region.
--- fs/xfs/Makefile | 1 + fs/xfs/libxfs/xfs_bmap.c | 4 +-- fs/xfs/libxfs/xfs_verity.c | 20 +++++++++++++ fs/xfs/libxfs/xfs_verity.h | 13 ++++++++ fs/xfs/xfs_aops.c | 6 ++-- fs/xfs/xfs_iomap.c | 61 ++++++++++++++++++++++++++++---------- fs/xfs/xfs_iomap.h | 5 ++-- fs/xfs/xfs_pnfs.c | 2 +- 8 files changed, 89 insertions(+), 23 deletions(-) create mode 100644 fs/xfs/libxfs/xfs_verity.c create mode 100644 fs/xfs/libxfs/xfs_verity.h
fs/xfs/Makefile +1 -0
@@ -59,6 +59,7 @@ xfs-y += $(addprefix libxfs/, \ xfs_trans_resv.o \ xfs_trans_space.o \ xfs_types.o \ + xfs_verity.o \ ) # xfs_rtbitmap is shared with libxfs xfs-$(CONFIG_XFS_RT) += $(addprefix libxfs/, \
fs/xfs/libxfs/xfs_bmap.c +2 -2
@@ -4414,7 +4414,7 @@ xfs_bmapi_convert_one_delalloc(* the extent. Just return the real extent at this offset. */ if (!isnullstartblock (bma.got.br_startblock)) { -xfs_bmbt_to_iomap (ip, iomap, &bma.got,0 , flags, +xfs_bmbt_to_iomap (ip, iomap, &bma.got, offset,0 , flags,xfs_iomap_inode_sequence (ip, flags));if (seq) *seq =READ_ONCE (ifp->if_seq);
@@ -4462,7 +4462,7 @@ xfs_bmapi_convert_one_delalloc(XFS_STATS_INC (mp, xs_xstrat_quick);ASSERT (!isnullstartblock (bma.got.br_startblock)); -xfs_bmbt_to_iomap (ip, iomap, &bma.got,0 , flags, +xfs_bmbt_to_iomap (ip, iomap, &bma.got, offset,0 , flags,xfs_iomap_inode_sequence (ip, flags));if (seq) *seq =READ_ONCE (ifp->if_seq);
fs/xfs/libxfs/xfs_verity.c new file +20 -0
@@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2026 Red Hat, Inc. +*/ +#include "xfs_platform.h" +#include "xfs_fs.h" +#include "xfs_shared.h" +#include "xfs_format.h" +#include "xfs_log_format.h" +#include "xfs_trans_resv.h" +#include "xfs_mount.h" +#include "xfs_inode.h" +#include "xfs_verity.h" + +loff_t +xfs_fsverity_metadata_offset ( +const struct xfs_inode *ip) +{ +return round_up (i_size_read (VFS_IC (ip)),XFS_FSVERITY_START_ALIGN ); +}
fs/xfs/libxfs/xfs_verity.h new file +13 -0
@@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2026 Red Hat, Inc. +*/ +#ifndef __XFS_VERITY_H__ +#define __XFS_VERITY_H__ + +#include "xfs_platform.h" +#include <linux/fsverity.h> + +loff_t xfs_fsverity_metadata_offset (const struct xfs_inode *ip); + +#endif /* __XFS_VERITY_H__ */
fs/xfs/xfs_aops.c +4 -2
@@ -23,6 +23,7 @@#include "xfs_ioend.h" #include "xfs_zone_alloc.h" #include "xfs_rtgroup.h" +#include "xfs_verity.h" struct xfs_writepage_ctx {struct iomap_writepage_ctx ctx;
@@ -265,7 +266,8 @@ xfs_map_blocks( isnullstartblock(imap.br_startblock)) goto allocate_blocks; -xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap,0 ,0 ,XFS_WPC (wpc)->data_seq); +xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap, offset,0 ,0 , +XFS_WPC (wpc)->data_seq);trace_xfs_map_blocks_found (ip, offset, count, whichfork, &imap);return 0 ; allocate_blocks:
@@ -441,7 +443,7 @@ xfs_zoned_map_blocks( imap.br_startblock =HOLESTARTBLOCK ; imap.br_state =XFS_EXT_NORM ;xfs_iunlock (ip,XFS_ILOCK_EXCL ); -xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap,0 ,0 ,0 ); +xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap, offset,0 ,0 ,0 );return 0 ; } end_fsb =min (end_fsb, imap.br_startoff + imap.br_blockcount);
fs/xfs/xfs_iomap.c +45 -16
168 lines not on this page · raw message
fs/xfs/xfs_iomap.h +3 -2
@@ -22,8 +22,9 @@ xfs_fileoff_t xfs_iomap_eof_align_last_fsb(struct xfs_inode *ip,u64 xfs_iomap_inode_sequence (struct xfs_inode *ip,u16 iomap_flags);int xfs_bmbt_to_iomap (struct xfs_inode *ip,struct iomap *iomap, -struct xfs_bmbt_irec *imap,unsigned int mapping_flags, -u16 iomap_flags,u64 sequence_cookie); +struct xfs_bmbt_irec *imap,loff_t offset, +unsigned int mapping_flags,u16 iomap_flags, +u64 sequence_cookie);int xfs_zero_range (struct xfs_inode *ip,loff_t pos,loff_t len,struct xfs_zone_alloc_ctx *ac,bool *did_zero);
fs/xfs/xfs_pnfs.c +1 -1
@@ -256,7 +256,7 @@ xfs_fs_map_blocks( }xfs_iunlock (ip,XFS_IOLOCK_EXCL |XFS_MMAPLOCK_EXCL ); - error =xfs_bmbt_to_iomap (ip, iomap, &imap,0 ,0 , seq); + error =xfs_bmbt_to_iomap (ip, iomap, &imap, offset,0 ,0 , seq); *device_generation = mp->m_generation;return error; out_unlock:
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v19 05/15] xfs: handle fsverity I/O in write/read path
Thank you for your contribution! Sashiko AI review found 2 potential issues to consider: - [High] xfs: undeclared fsverity_is_building() breaks build in xfs_iomap.c - [High] xfs: post-EOF fsverity…
Thank you for your contribution! Sashiko AI review found 2 potential issues to consider:
- [High] xfs: undeclared fsverity_is_building() breaks build in xfs_iomap.c
- [High] xfs: post-EOF fsverity folios skipped in writeback due to missing flag
--
commit bdb3069c02095cd61adc7db45f468d33efe53e6b
Author: Andrey Albershteyn <[email protected]>
xfs: handle fsverity I/O in write/read path
This commit adds xfs_fsverity_metadata_offset() and passes the I/O offset to xfs_bmbt_to_iomap() so IOMAP_F_FSVERITY is set on mappings covering fs-verity metadata past EOF.
Quoted 23 lines
fs/xfs/xfs_aops.c +3
-1@@ -23,6 +23,7 @@#include "xfs_ioend.h" #include "xfs_zone_alloc.h" #include "xfs_rtgroup.h" +#include "xfs_verity.h" struct xfs_writepage_ctx {struct iomap_writepage_ctx ctx;@@ -265,7 +266,8 @@ xfs_map_blocks( isnullstartblock(imap.br_startblock)) goto allocate_blocks; -xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap,0 ,0 ,XFS_WPC (wpc)->data_seq); +xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap, offset,0 ,0 , +XFS_WPC (wpc)->data_seq);trace_xfs_map_blocks_found (ip, offset, count, whichfork, &imap);return 0 ; allocate_blocks:
fs/xfs/xfs_aops.c xfs_zoned_map_blocks( · line 449
Quoted 8 lines
fs/xfs/xfs_aops.c +1
-1@@ -441,7 +443,7 @@ xfs_zoned_map_blocks( imap.br_startblock =HOLESTARTBLOCK ; imap.br_state =XFS_EXT_NORM ;xfs_iunlock (ip,XFS_ILOCK_EXCL ); -xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap,0 ,0 ,0 ); +xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap, offset,0 ,0 ,0 );return 0 ; } end_fsb =min (end_fsb, imap.br_startoff + imap.br_blockcount);
[Severity: High]
Will iomap_writeback_folio() skip dirty fs-verity metadata folios before xfs_map_blocks() can set IOMAP_F_FSVERITY?
xfs_vm_writepages() zero-initializes wpc.ctx.iomap.flags (and xc.ctx.iomap.flags on zoned filesystems), and iomap_writeback_folio() calls iomap_writeback_handle_eof() before ->writeback_range() invokes xfs_map_blocks(). When a dirty fs-verity folio past i_size is reached, wpc->iomap.flags still lacks IOMAP_F_FSVERITY, so iomap_writeback_handle_eof() returns false and the folio is skipped with its dirty bit cleared and its delalloc extent unconverted.
Also, in xfs_zoned_map_blocks(), the non-hole path calls xfs_iomap_set_anon_write(), which overwrites wpc->iomap.flags with IOMAP_F_ANON_WRITE | IOMAP_F_DIRTY and drops IOMAP_F_FSVERITY.
Quoted 15 lines
fs/xfs/xfs_iomap.c +2
-0@@ -32,6 +32,8 @@#include "xfs_rtbitmap.h" #include "xfs_icache.h" #include "xfs_zone_alloc.h" +#include "xfs_verity.h" +#include <linux/fsverity.h> #define XFS_ALLOC_ALIGN (mp, off) \ (((off) >> mp->m_allocsize_log) << mp->m_allocsize_log)@@ -54,6 +56,15 @@ xfs_alert_fsblock_zero(return -EFSCORRUPTED ;
fs/xfs/xfs_iomap.c xfs_alert_fsblock_zero( · line 66
Quoted 10 lines
fs/xfs/xfs_iomap.c +8
-0} +static bool +xfs_iomap_is_fsverity_metadata ( +struct xfs_inode *ip, +loff_t offset) +{ +return offset >=xfs_fsverity_metadata_offset (ip) && + (fsverity_is_building (VFS_I (ip)) ||fsverity_active (VFS_I (ip))); +}
[Severity: High]
Does calling fsverity_is_building() here break the build? Neither linux/fsverity.h nor xfs_verity.h declares or defines fsverity_is_building(), so compiling fs/xfs/xfs_iomap.c fails with an implicit function declaration error.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
Re: [PATCH v19 05/15] xfs: handle fsverity I/O in write/read path
Quoted 12 lines · On Fri, Nov 20, 2026 at 04:27:02PM +0000, [email protected] wrote:
[Severity: High]
Williomap_writeback_folio()skip dirty fs-verity metadata folios beforexfs_map_blocks()can setIOMAP_F_FSVERITY?
xfs_vm_writepages()zero-initializes wpc.ctx.iomap.flags (and xc.ctx.iomap.flags on zoned filesystems), andiomap_writeback_folio()callsiomap_writeback_handle_eof()before ->writeback_range() invokesxfs_map_blocks(). When a dirty fs-verity folio pasti_sizeis reached,wpc->iomap.flagsstill lacksIOMAP_F_FSVERITY, soiomap_writeback_handle_eof()returns false and the folio is skipped with its dirty bit cleared and its delalloc extent unconverted.
Quoted 3 lines
Also, in
xfs_zoned_map_blocks(), the non-hole path callsxfs_iomap_set_anon_write(), which overwriteswpc->iomap.flagswithIOMAP_F_ANON_WRITE|IOMAP_F_DIRTYand dropsIOMAP_F_FSVERITY.
Yeah. This was kinda why I wondered if an inode flag would do better for this.
Quoted 5 lines
Quoted 5 lines
fs/xfs/xfs_iomap.c +5
-0+xfs_iomap_is_fsverity_metadata( + struct xfs_inode *ip, + loff_t offset) +{ + return offset >= xfs_fsverity_metadata_offset(ip) &&
Quoted 8 lines
fs/xfs/xfs_iomap.c xfs_alert_fsblock_zero( · line 66
Quoted 2 lines
fs/xfs/xfs_iomap.c +2
-0+ (fsverity_is_building (VFS_I (ip)) ||fsverity_active (VFS_I (ip))); +}[Severity: High]
Does callingfsverity_is_building()here break the build? Neitherlinux/fsverity.hnorxfs_verity.hdeclares or definesfsverity_is_building(), so compilingfs/xfs/xfs_iomap.cfails with an implicit function declaration error.
It might make sense to include the core fs/fsverity patches in the series so that human and less humane reviewers have the full context.
PATCH v19 6/15 xfs: use read ioend for fsverity data verification
In reply to Andrey AlbershteynUse read ioends for fsverity verification. Do not issue fsverity metadata I/O through the same workqueue due to risk of a deadlock by a filled workqueue.
Pass fsverity_info from iomap context down to the ioend as hashtable lookups are expensive.
Add a simple helper to check that this is not fsverity metadata but file data that needs verification.
--- fs/xfs/Makefile | 1 + fs/xfs/xfs_aops.c | 13 +++++++---- fs/xfs/xfs_file.c | 3 ++- fs/xfs/xfs_fsverity.c | 46 +++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_fsverity.h | 40 ++++++++++++++++++++++++++++++++ fs/xfs/xfs_ioend.c | 53 ++++++++++++++++++++++++++++++++++++++----- fs/xfs/xfs_ioend.h | 4 +++- fs/xfs/xfs_super.c | 25 +++++++++++++++++++- 8 files changed, 171 insertions(+), 14 deletions(-) create mode 100644 fs/xfs/xfs_fsverity.c create mode 100644 fs/xfs/xfs_fsverity.h
fs/xfs/Makefile +1 -0
@@ -151,6 +151,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_fsverity.o # notify failure ifeq ($(CONFIG_MEMORY_FAILURE),y)
fs/xfs/xfs_aops.c +8 -5
@@ -24,6 +24,7 @@#include "xfs_zone_alloc.h" #include "xfs_rtgroup.h" #include "xfs_verity.h" +#include "xfs_fsverity.h" struct xfs_writepage_ctx {struct iomap_writepage_ctx ctx;
@@ -587,7 +588,7 @@ xfs_bio_submit_read( {xfs_ioend_submit_read (iter->inode, ctx->read_ctx, ctx->read_ctx_file_offset, -iomap_ioend_flags (&iter->iomap)); +iomap_ioend_flags (&iter->iomap), ctx->vi); ctx->read_ctx =NULL ; }
@@ -599,11 +600,13 @@ static const struct iomap_read_ops xfs_iomap_read_ops = {static inline const struct iomap_read_ops *xfs_get_iomap_read_ops ( -const struct address_space *mapping) +const struct address_space *mapping, +loff_t pos) {struct xfs_inode *ip =XFS_I (mapping->host); -if (bdev_has_integrity_csum (xfs_inode_buftarg (ip)->bt_bdev)) +if (bdev_has_integrity_csum (xfs_inode_buftarg (ip)->bt_bdev) || +xfs_fsverity_is_file_data (ip, pos))return &xfs_iomap_read_ops;return &iomap_bio_read_ops; }
@@ -615,7 +618,7 @@ xfs_vm_read_folio( {struct iomap_read_folio_ctx ctx = { .cur_folio = folio }; - ctx.ops =xfs_get_iomap_read_ops (folio->mapping); + ctx.ops =xfs_get_iomap_read_ops (folio->mapping,folio_pos (folio));iomap_read_folio (xfs_read_iomap_next, &ctx,NULL );return 0 ; }
@@ -626,7 +629,7 @@ xfs_vm_readahead( {struct iomap_read_folio_ctx ctx = { .rac = rac }; - ctx.ops =xfs_get_iomap_read_ops (rac->mapping), + ctx.ops =xfs_get_iomap_read_ops (rac->mapping,readahead_pos (rac));iomap_readahead (xfs_read_iomap_next, &ctx,NULL ); }
fs/xfs/xfs_file.c +2 -1
@@ -182,7 +182,8 @@ xfs_dio_read_bounce_submit_io( loff_t file_offset) {xfs_ioend_submit_read (iter->inode, bio, file_offset, -iomap_ioend_flags (&iter->iomap) |IOMAP_IOEND_DIRECT ); +iomap_ioend_flags (&iter->iomap) |IOMAP_IOEND_DIRECT , +NULL ); }static const struct iomap_dio_ops xfs_dio_read_bounce_ops = {
fs/xfs/xfs_fsverity.c new file +46 -0
46 lines not on this page · raw message
fs/xfs/xfs_fsverity.h new file +40 -0
@@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (C) 2026 Red Hat, Inc. +*/ +#ifndef __XFS_FSVERITY_H__ +#define __XFS_FSVERITY_H__ + +#include "xfs_platform.h" +#include "xfs_verity.h" +#include <linux/iomap.h> +#include <linux/mempool.h> + +#ifdef CONFIG_FS_VERITY +int xfs_fsverity_init (void ); +void xfs_fsverity_exit (void ); +bool xfs_fsverity_is_file_data (const struct xfs_inode *ip,loff_t offset); +#else +static inline int xfs_fsverity_init (void ) +{ +return 0 ; +} +static inline void xfs_fsverity_exit (void ) +{ +} +static inline bool xfs_fsverity_is_file_data (const struct xfs_inode *ip, +loff_t offset) +{ +return false; +} +#endif /* CONFIG_FS_VERITY */ + +struct xfs_fsverity_ioend { +struct iomap_ioend *ioend; +struct work_struct work; +}; + +extern struct kmem_cache *xfs_fsverity_ioend_cache; +extern mempool_t xfs_fsverity_ioend_pool; + +#endif /* __XFS_FSVERITY_H__ */
fs/xfs/xfs_ioend.c +47 -6
85 lines not on this page · raw message
fs/xfs/xfs_ioend.h +3 -1
@@ -2,6 +2,8 @@#ifndef __XFS_IOEND_H#define __XFS_IOEND_H +#include <linux/fsverity.h> +/* * Fast and loose check if this write could update the on-disk inode size. */
@@ -13,6 +15,6 @@ static inline bool xfs_ioend_is_append(struct iomap_ioend *ioend)void xfs_end_bio (struct bio *bio);void xfs_ioend_submit_read (struct inode *inode,struct bio *bio, -loff_t file_offset,u16 ioend_flags); +loff_t file_offset,u16 ioend_flags,struct fsverity_info *vi);#endif /* __XFS_IOEND_H */
fs/xfs/xfs_super.c +24 -1
@@ -50,6 +50,7 @@#include "xfs_rtalloc.h" #include "xfs_zone_alloc.h" #include "xfs_healthmon.h" +#include "xfs_fsverity.h" #include "scrub/stats.h" #include "scrub/rcbag_btree.h"
@@ -2516,8 +2517,20 @@ xfs_init_caches(void)if (!xfs_parent_args_cache) goto out_destroy_xmi_cache; +#ifdef CONFIG_FS_VERITY + xfs_fsverity_ioend_cache =kmem_cache_create ("xfs_fsverity_ioend" , +sizeof (struct xfs_fsverity_ioend ), +0 ,0 ,NULL ); +if (!xfs_fsverity_ioend_cache) + goto out_destroy_parent_args_cache; +#endif +return 0 ; +#ifdef CONFIG_FS_VERITY + out_destroy_parent_args_cache: +kmem_cache_destroy (xfs_parent_args_cache); +#endif out_destroy_xmi_cache:kmem_cache_destroy (xfs_xmi_cache); out_destroy_xmd_cache:
@@ -2580,6 +2593,9 @@ xfs_destroy_caches(void)* destroy caches. */ rcu_barrier (); +#ifdef CONFIG_FS_VERITY +kmem_cache_destroy (xfs_fsverity_ioend_cache); +#endif kmem_cache_destroy (xfs_parent_args_cache);kmem_cache_destroy (xfs_xmd_cache);kmem_cache_destroy (xfs_xmi_cache);
@@ -2660,10 +2676,14 @@ init_xfs_fs(void)if (error) goto out; - error =xfs_init_workqueues (); + error =xfs_fsverity_init ();if (error) goto out_destroy_caches; + error =xfs_init_workqueues (); +if (error) + goto out_fsverity_exit; + error =xfs_mru_cache_init ();if (error) goto out_destroy_wq;
@@ -2740,6 +2760,8 @@ init_xfs_fs(void)xfs_mru_cache_uninit (); out_destroy_wq:xfs_destroy_workqueues (); + out_fsverity_exit: +xfs_fsverity_exit (); out_destroy_caches:xfs_destroy_caches (); out:
@@ -2763,6 +2785,7 @@ exit_xfs_fs(void)xfs_cleanup_procfs ();xfs_mru_cache_uninit ();xfs_destroy_workqueues (); +xfs_fsverity_exit ();xfs_destroy_caches ();xfs_uuid_table_free (); }
Signature · 1 line
2.54.0
PATCH v19 7/15 xfs: add XFS_BMAPI_UNWRITTEN to unmap unwritten extents in __xfs_bunmapi()
In reply to Andrey AlbershteynThe __xfs_bunmapi() is used to remove all extents past EOF. Add XFS_BMAPI_UNWRITTEN to remove only unwritten extents, while leaving written ones in place. This will be used in following patch to clean up unwritten extents on fsverity inodes.
--- fs/xfs/libxfs/xfs_bmap.c | 22 +++++++++++++++++++++- fs/xfs/libxfs/xfs_bmap.h | 6 +++++- 2 files changed, 26 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +21 -1
@@ -5220,6 +5220,22 @@ __xfs_bunmapi(ASSERT (len >0 );ASSERT (nexts >=0 ); +/* +* XFS_BMAPI_UNWRITTEN is only used by fs-verity to drop unwritten +* blocks past EOF while keeping written ones (fsverity metadata). +* +* The XFS_BMAPI_UNWRITTEN could not be used with realtime inodes with +* realtime extent larger than 1 filesystem block. This is because the +* realtime inode with larger extents could have EOF in the middle of +* the extent. Removing these unwritten extent beyond EOF could lead to +* removal of data before EOF. +* +* fs-verity is not allowed to be enabled on realtime files whose +* extent size is larger than 1. +*/ +ASSERT (!((flags &XFS_BMAPI_UNWRITTEN ) && +xfs_inode_has_bigrtalloc (ip))); + error =xfs_iread_extents (tp, ip, whichfork);if (error)return error;
@@ -5281,6 +5297,10 @@ __xfs_bunmapi(if (del.br_startoff + del.br_blockcount > end +1 ) del.br_blockcount = end +1 - del.br_startoff; +if ((flags &XFS_BMAPI_UNWRITTEN ) && + del.br_state !=XFS_EXT_UNWRITTEN ) + goto skip; +if (!isrt || (flags &XFS_BMAPI_REMAP )) goto delete;
@@ -5415,7 +5435,7 @@ __xfs_bunmapi(if (error) goto error0; } - +skip: end = del.br_startoff -1 ; nodelete:/*
fs/xfs/libxfs/xfs_bmap.h +5 -1
@@ -97,6 +97,9 @@ struct xfs_bmalloca {*/ #define XFS_BMAPI_CONVERT_ONLY (1u << 12) +/* Process unwritten extents only. Used for unmapping */ +#define XFS_BMAPI_UNWRITTEN (1u << 13) +#define XFS_BMAPI_FLAGS \ { XFS_BMAPI_ENTIRE, "ENTIRE" }, \ { XFS_BMAPI_METADATA, "METADATA" }, \
@@ -110,7 +113,8 @@ struct xfs_bmalloca { { XFS_BMAPI_NODISCARD, "NODISCARD" }, \ { XFS_BMAPI_NORMAP, "NORMAP" },\ { XFS_BMAPI_EXTSZALIGN, "EXTSZALIGN" }, \ - { XFS_BMAPI_CONVERT_ONLY, "CONVERT_ONLY" } + { XFS_BMAPI_CONVERT_ONLY, "CONVERT_ONLY" }, \ + { XFS_BMAPI_UNWRITTEN, "UNWRITTEN" } static inline int xfs_bmapi_aflag(int w)
Signature · 1 line
2.54.0
Re: [PATCH v19 07/15] xfs: add XFS_BMAPI_UNWRITTEN to unmap unwritten extents in __xfs_bunmapi()
Looks good:
PATCH v19 8/15 xfs: don't remove written extents past EOF on fsverity inodes
In reply to Andrey Albershteynxfs_free_eofblocks() removes all extents past EOF unless the XFS_DIFLAG_PREALLOC or XFS_DIFLAG_APPEND flags are set. This is undesired for fsverity as it stores metadata beyond EOF. However, while merkle tree is being built, delayed preallocation and unwritten extents are used. After metadata construction is done, fsverity inodes becomes read-only and won't be changed anymore, none of these unwritten extents or preallocations in post EOF region will be used.
Let xfs_free_eofblocks() be called on fsverity inode as usual to remove anything which is not written extent. However, inodes which are undergoing merkle tree construction need to be skipped in case reclaim takes place.
--- fs/xfs/xfs_bmap_util.c | 32 +++++++++++++++++++++++++++++--- fs/xfs/xfs_icache.c | 11 ++++++++++- 2 files changed, 39 insertions(+), 4 deletions(-)
fs/xfs/xfs_bmap_util.c +29 -3
@@ -31,6 +31,7 @@#include "xfs_rtbitmap.h" #include "xfs_rtgroup.h" #include "xfs_zone_alloc.h" +#include <linux/fsverity.h> /* Kernel only BMAP related definitions and functions */
@@ -553,6 +554,17 @@ xfs_can_free_eofblocks(if (last_fsb <= end_fsb)return false; +/* +* Don't clean fsverity inodes as they already have been cleaned up and +* are read-only. Skip inodes which have merkle tree being built, the +* merkle tree is written beyond EOF. Skip inodes which have +* XFS_DIFLAG2_VERITY in case this kernel has fsverity disabled. +*/ +if (fsverity_active (VFS_IC (ip)) || +fsverity_is_building (VFS_I (ip)) || + ip->i_diflags2 &XFS_DIFLAG2_VERITY ) +return false; +/* * Check if there is an post-EOF extent to free. If there are any * delalloc blocks attached to the inode (data fork delalloc
@@ -579,6 +591,8 @@ xfs_free_eofblocks(struct xfs_trans *tp;struct xfs_mount *mp = ip->i_mount;int error; +int bmapi_flags =XFS_BMAPI_NODISCARD ; +bool verity =fsverity_is_building (VFS_I (ip));/* Attach the dquots to the inode up front. */ error =xfs_qm_dqattach (ip);
@@ -593,15 +607,20 @@ xfs_free_eofblocks(* * Note that this means we also leave speculative preallocations in * place for preallocated files. +* +* Clean up delalloc reservations for fsverity too as those won't be +* used */ -if (ip->i_diflags & (XFS_DIFLAG_PREALLOC |XFS_DIFLAG_APPEND )) { +if (ip->i_diflags & (XFS_DIFLAG_PREALLOC |XFS_DIFLAG_APPEND ) || + verity) {if (ip->i_delayed_blks) {xfs_bmap_punch_delalloc_range (ip,XFS_DATA_FORK ,round_up (XFS_ISIZE (ip), mp->m_sb.sb_blocksize),LLONG_MAX ,NULL ); }xfs_inode_clear_eofblocks_tag (ip); -return 0 ; +if (!verity) +return 0 ; } error =xfs_trans_alloc (mp, &M_RES (mp)->tr_itruncate,0 ,0 ,0 , &tp);
@@ -613,6 +632,13 @@ xfs_free_eofblocks(xfs_ilock (ip,XFS_ILOCK_EXCL );xfs_trans_ijoin (tp, ip,0 ); +/* +* While fs-verity writes metadata after EOF, it can leave unwritten +* preallocations. Clear all that out. +*/ +if (verity) + bmapi_flags |=XFS_BMAPI_UNWRITTEN ; +/* * Do not update the on-disk file size. If we update the on-disk file * size and then the system crashes before the contents of the file are
@@ -620,7 +646,7 @@ xfs_free_eofblocks(* bug). */ error =xfs_itruncate_extents_flags (&tp, ip,XFS_DATA_FORK , -XFS_ISIZE (ip),XFS_BMAPI_NODISCARD ); +XFS_ISIZE (ip), bmapi_flags);if (error) goto err_cancel;
fs/xfs/xfs_icache.c +10 -1
@@ -28,7 +28,7 @@#include "xfs_da_format.h" #include "xfs_dir2.h" #include "xfs_metafile.h" - +#include <linux/fsverity.h> #include <linux/iversion.h> /* Radix tree tags for incore inode tree. */
@@ -1260,6 +1260,15 @@ xfs_inode_free_eofblocks(if (xfs_can_free_eofblocks (ip))return xfs_free_eofblocks (ip); +/* +* The above xfs_free_eofblocks() is skipped for inodes with fsverity +* tree is being built. However, we don't want to clear EOF tag in this +* case. If building the tree fails, inode will have EOF blocks which +* needs removal. +*/ +if (fsverity_is_building (VFS_IC (ip))) +return 0 ; +/* inode could be preallocated */ trace_xfs_inode_free_eofblocks_invalid (ip);xfs_inode_clear_eofblocks_tag (ip);
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v19 08/15] xfs: don't remove written extents past EOF on fsverity inodes
Thank you for your contribution! Sashiko AI review found 2 potential issues to consider: - [High] xfs: implicit declaration of fsverity_is_building() breaks build - [Low] xfs: xfs_free_eofblocks()…
Thank you for your contribution! Sashiko AI review found 2 potential issues to consider:
- [High] xfs: implicit declaration of fsverity_is_building() breaks build
- [Low] xfs: xfs_free_eofblocks() clears eofblocks tag before truncating extents
--
commit 9dfe7c39ae9adbec3053517f6ebaa07ffa9e51dc
Author: Andrey Albershteyn <[email protected]>
xfs: don't remove written extents past EOF on fsverity inodes
This commit updates xfs_can_free_eofblocks(), xfs_free_eofblocks(), and xfs_inode_free_eofblocks() to preserve written post-EOF extents on fsverity inodes while punching out delayed allocations and unwritten extents after Merkle tree construction.
Quoted 4 lines
fs/xfs/xfs_bmap_util.c +0
-0
[ ... ]
Quoted 4 lines
fs/xfs/xfs_bmap_util.c +0
-0@@ -553,6 +554,17 @@ xfs_can_free_eofblocks(if (last_fsb <= end_fsb)return false;
fs/xfs/xfs_bmap_util.c xfs_can_free_eofblocks( · line 566
Quoted 10 lines
fs/xfs/xfs_bmap_util.c +10
-0+/* +* Don't clean fsverity inodes as they already have been cleaned up and +* are read-only. Skip inodes which have merkle tree being built, the +* merkle tree is written beyond EOF. Skip inodes which have +* XFS_DIFLAG2_VERITY in case this kernel has fsverity disabled. +*/ +if (fsverity_active (VFS_IC (ip)) || +fsverity_is_building (VFS_I (ip)) || + ip->i_diflags2 &XFS_DIFLAG2_VERITY ) +return false;
[Severity: High]
Where is fsverity_is_building() declared? Neither include/linux/fsverity.h nor any other header defines it, so the calls here, in xfs_free_eofblocks(), and in xfs_inode_free_eofblocks() fail to compile with an implicit function declaration error.
Quoted 11 lines
fs/xfs/xfs_bmap_util.c +5
-1@@ -593,15 +607,20 @@ xfs_free_eofblocks(* * Note that this means we also leave speculative preallocations in * place for preallocated files. +* +* Clean up delalloc reservations for fsverity too as those won't be +* used */ -if (ip->i_diflags & (XFS_DIFLAG_PREALLOC |XFS_DIFLAG_APPEND )) { +if (ip->i_diflags & (XFS_DIFLAG_PREALLOC |XFS_DIFLAG_APPEND ) || + verity) {
fs/xfs/xfs_bmap_util.c xfs_free_eofblocks( · line 624
Quoted 10 lines
fs/xfs/xfs_bmap_util.c +2
-1if (ip->i_delayed_blks) {xfs_bmap_punch_delalloc_range (ip,XFS_DATA_FORK ,round_up (XFS_ISIZE (ip), mp->m_sb.sb_blocksize),LLONG_MAX ,NULL ); }xfs_inode_clear_eofblocks_tag (ip); -return 0 ; +if (!verity) +return 0 ; }
[Severity: Low]
Should xfs_inode_clear_eofblocks_tag(ip) only be called inside the !verity branch here? When verity is true, the tag is cleared before the extent truncation transaction runs (and cleared a second time after xfs_trans_commit()), leaving XFS_IEOFBLOCKS cleared if xfs_trans_alloc(), xfs_itruncate_extents_flags(), or xfs_trans_commit() fails.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Re: [PATCH v19 08/15] xfs: don't remove written extents past EOF on fsverity inodes
Quoted 19 lines · On Fri, Nov 20, 2026 at 04:21:57PM +0000, [email protected] wrote:
Quoted 19 lines
fs/xfs/xfs_bmap_util.c +7
-2* * Note that this means we also leave speculative preallocations in * place for preallocated files. +* +* Clean up delalloc reservations for fsverity too as those won't be +* used */ -if (ip->i_diflags & (XFS_DIFLAG_PREALLOC |XFS_DIFLAG_APPEND )) { +if (ip->i_diflags & (XFS_DIFLAG_PREALLOC |XFS_DIFLAG_APPEND ) || + verity) {if (ip->i_delayed_blks) {xfs_bmap_punch_delalloc_range (ip,XFS_DATA_FORK ,round_up (XFS_ISIZE (ip), mp->m_sb.sb_blocksize),LLONG_MAX ,NULL ); }xfs_inode_clear_eofblocks_tag (ip); -return 0 ; +if (!verity) +return 0 ;
Quoted 8 lines
Quoted 1 line
}
[Severity: Low]
Shouldxfs_inode_clear_eofblocks_tag(ip)only be called inside the !verity branch here? When verity is true, the tag is cleared before the extent truncation transaction runs (and cleared a second time afterxfs_trans_commit()), leavingXFS_IEOFBLOCKScleared ifxfs_trans_alloc(),xfs_itruncate_extents_flags(), orxfs_trans_commit()fails.
This doesn't seem to criticial, but maybe the structure actually is nicer if we do it that way. I.e.:
Quoted 4 lines
fs/xfs/xfs_bmap_util.c xfs_free_eofblocks(
Quoted 4 lines
fs/xfs/xfs_bmap_util.c +1
-0xfs_bmap_punch_delalloc_range (ip,XFS_DATA_FORK ,round_up (XFS_ISIZE (ip), mp->m_sb.sb_blocksize),LLONG_MAX ,NULL ); + verity) {
aligned_size = round_up(XFS_ISIZE(ip), mp->m_sb.sb_blocksize);
if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) {
if (ip->i_delayed_blks)
xfs_bmap_punch_delalloc_range(ip, XFS_DATA_FORK,
aligned_size, LLONG_MAX, NULL);
xfs_inode_clear_eofblocks_tag(ip);
return 0;
}
/* Good comment explaining all fsverity magic here */
if (fsverity_is_building(VFS_I(ip))) {
if (ip->i_delayed_blks)
xfs_bmap_punch_delalloc_range(ip, XFS_DATA_FORK,
aligned_size, LLONG_MAX, NULL);
bmapi_flags |= XFS_BMAPI_UNWRITTEN;
}PATCH v19 9/15 xfs: add fs-verity support
In reply to Andrey AlbershteynAdd integration with fs-verity. XFS stores fs-verity descriptor and Merkle tree in the inode data fork at first block aligned to 64k past EOF.
The Merkle tree reading/writing is done through iomap interface. The data itself is read to the inode's page cache. When XFS reads from this region iomap doesn't call into fsverity to verify it against Merkle tree. For data, verification is done at ioend completion in a workqueue.
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). Lastly, the XFS_IVERITY_CONSTRUCTION is dropped and I_VERITY is set on inode.
The descriptor is stored in a new block aligned to 64k after the last Merkle tree block. The size of the descriptor is stored at the end of the last descriptor block (descriptor can be multiple blocks).
Pro-actively remove any unwritten extents as we use last extent to locate descriptor.
--- fs/xfs/libxfs/xfs_inode_buf.c | 11 + fs/xfs/xfs_fsverity.c | 452 +++++++++++++++++++++++++++++++++- fs/xfs/xfs_fsverity.h | 2 + fs/xfs/xfs_ioctl.c | 19 ++ fs/xfs/xfs_message.c | 4 + fs/xfs/xfs_message.h | 1 + fs/xfs/xfs_mount.h | 2 + fs/xfs/xfs_super.c | 7 + 8 files changed, 497 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_inode_buf.c +11 -0
@@ -764,6 +764,17 @@ xfs_dinode_verify(return __this_address;if (!S_ISREG (mode))return __this_address; +/* +* fs-verity stores the Merkle tree past EOF, so it cannot +* coexist with a realtime allocation unit larger than a single +* filesystem block. This is because we remove any unwritten +* extents beyond EOF for fs-verity inodes. The realtime inode +* with larger extents could have EOF in the middle of the +* extent. Enabling fsverity on such inode could lead to removal +* of data before EOF. +*/ +if ((flags &XFS_DIFLAG_REALTIME ) && mp->m_sb.sb_rextsize >1 ) +return __this_address; } if (xfs_has_zoned(mp) &&
fs/xfs/xfs_fsverity.c +451 -1
467 lines not on this page · raw message
fs/xfs/xfs_fsverity.h +2 -0
@@ -8,9 +8,11 @@#include "xfs_platform.h" #include "xfs_verity.h" #include <linux/iomap.h> +#include <linux/fsverity.h> #include <linux/mempool.h> #ifdef CONFIG_FS_VERITY +extern const struct fsverity_operations xfs_fsverity_ops;int xfs_fsverity_init (void );void xfs_fsverity_exit (void );bool xfs_fsverity_is_file_data (const struct xfs_inode *ip,loff_t offset);
fs/xfs/xfs_ioctl.c +19 -0
@@ -562,6 +562,14 @@ xfs_ioctl_setattr_xflags(if (xfs_inode_has_filedata (ip))return -EINVAL ; +/* +* fs-verity is incompatible with a realtime allocation unit +* larger than a single filesystem block, so don't let a file be +* converted to realtime while verity is being enabled. +*/ +if (fsverity_is_building (VFS_IC (ip))) +return -EINVAL ; +/* * If S_DAX is enabled on this file, we can only switch the * device if both support fsdax. We can't update S_DAX because
@@ -574,6 +582,17 @@ xfs_ioctl_setattr_xflags(return -EINVAL ; } +/* +* fs-verity is incompatible with DAX, and xfs_fsverity_begin_enable() +* verified the inode was not DAX under the inode lock. That lock is +* dropped while the Merkle tree is built, so reject enabling DAX while +* verity is being enabled. +*/ +if ((fa->fsx_xflags &FS_XFLAG_DAX ) && + !(ip->i_diflags2 &XFS_DIFLAG2_DAX ) && +fsverity_is_building (VFS_IC (ip))) +return -EINVAL ; +if (rtflag) {/* If realtime flag is set then must have realtime device */ if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
fs/xfs/xfs_message.c +4 -0
@@ -149,6 +149,10 @@ xfs_warn_experimental( .opstate = XFS_OPSTATE_WARNED_LARP, .name = "logged extended attributes", }, + [XFS_EXPERIMENTAL_FSVERITY] = { + .opstate = XFS_OPSTATE_WARNED_FSVERITY, + .name = "fsverity", + }, };ASSERT (feat >=0 && feat <XFS_EXPERIMENTAL_MAX );BUILD_BUG_ON (ARRAY_SIZE (features) !=XFS_EXPERIMENTAL_MAX );
fs/xfs/xfs_message.h +1 -0
@@ -93,6 +93,7 @@ void xfs_buf_alert_ratelimited(struct xfs_buf *bp, const char *rlmsg,enum xfs_experimental_feat {XFS_EXPERIMENTAL_SHRINK ,XFS_EXPERIMENTAL_LARP , +XFS_EXPERIMENTAL_FSVERITY ,XFS_EXPERIMENTAL_MAX , };
fs/xfs/xfs_mount.h +2 -0
@@ -599,6 +599,8 @@ __XFS_HAS_FEAT(nouuid, NOUUID)#define XFS_OPSTATE_RESUMING_QUOTAON 18/* (Zoned) GC is in progress */ #define XFS_OPSTATE_ZONEGC_RUNNING 20 +/* Kernel has logged a warning about fsverity support */ +#define XFS_OPSTATE_WARNED_FSVERITY 21#define __XFS_IS_OPSTATE (name,NAME ) \ static inline bool xfs_is_ ## name (struct xfs_mount *mp) \
fs/xfs/xfs_super.c +7 -0
@@ -30,6 +30,7 @@#include "xfs_filestream.h" #include "xfs_quota.h" #include "xfs_sysfs.h" +#include "xfs_fsverity.h" #include "xfs_ondisk.h" #include "xfs_rmap_item.h" #include "xfs_refcount_item.h"
@@ -1737,6 +1738,9 @@ 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 + sb->s_vop = &xfs_fsverity_ops; +#endif /* * Delay mount work if the debug hook is set. This is debug
@@ -1989,6 +1993,9 @@ xfs_fs_fill_super(if (error) goto out_filestream_unmount; +if (xfs_has_verity (mp)) +xfs_warn_experimental (mp,XFS_EXPERIMENTAL_FSVERITY ); + root =igrab (VFS_I (mp->m_rootip));if (!root) { error = -ENOENT ;
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v19 09/15] xfs: add fs-verity support
Thank you for your contribution! Sashiko AI review found 7 potential issues to consider: - [High] xfs: skipped post-EOF verity writeback in xfs_fsverity_end_enable() - [High] xfs: undeclared…
Thank you for your contribution! Sashiko AI review found 7 potential issues to consider:
- [High] xfs: skipped post-EOF verity writeback in xfs_fsverity_end_enable()
- [High] xfs: undeclared fsverity_is_building() and missing verity building state
- [Medium] xfs: missing extent bounds check in xfs_fsverity_get_descriptor()
- [Medium] xfs: missing verity di_size check in xfs_dinode_verify() causes overflow
- [Medium] xfs: broken error rollback in xfs_fsverity_reset_inode()
- [Low] xfs: bogus corruption check and bounds checks in xfs_fsverity_get_descriptor()
- [Low] xfs: duplicate inclusion of xfs_fsverity.h in fs/xfs/xfs_super.c --
commit e657f01948f31434d0a0fecaa28699dd1636b20c
Author: Andrey Albershteyn <[email protected]>
xfs: add fs-verity support
This commit integrates XFS with fs-verity by implementing the fsverity_operations callbacks to read and write the Merkle tree and verity descriptor in the inode data fork past EOF.
Quoted 10 lines
fs/xfs/libxfs/xfs_inode_buf.c +2
-0@@ -764,6 +764,17 @@ xfs_dinode_verify(return __this_address;if (!S_ISREG (mode))return __this_address; +/* +* fs-verity stores the Merkle tree past EOF, so it cannot
fs/xfs/libxfs/xfs_inode_buf.c xfs_dinode_verify( · line 778
Quoted 10 lines
fs/xfs/libxfs/xfs_inode_buf.c +9
-0+* coexist with a realtime allocation unit larger than a single +* filesystem block. This is because we remove any unwritten +* extents beyond EOF for fs-verity inodes. The realtime inode +* with larger extents could have EOF in the middle of the +* extent. Enabling fsverity on such inode could lead to removal +* of data before EOF. +*/ +if ((flags &XFS_DIFLAG_REALTIME ) && mp->m_sb.sb_rextsize >1 ) +return __this_address; }
[Severity: Medium]
Should xfs_dinode_verify() also reject XFS_DIFLAG2_VERITY inodes whose di_size exceeds XFS_FSVERITY_LARGEST_FILE_FSB(mp), matching the check in xfs_fsverity_begin_enable()?
Without an upper bound check on di_size, an on-disk verity inode with di_size > LLONG_MAX - XFS_FSVERITY_START_ALIGN + 1 passes verification and overflows signed loff_t to LLONG_MIN in xfs_fsverity_metadata_offset():
fs/xfs/libxfs/xfs_verity.c:xfs_fsverity_metadata_offset() {
return round_up(i_size_read(VFS_IC(ip)), XFS_FSVERITY_START_ALIGN);
}With a negative metadata offset, xfs_fsverity_is_file_data() returns false and xfs_iomap_is_fsverity_metadata() returns true for all non-negative file offsets, causing normal file data reads to be treated as unverified verity metadata.
Quoted 4 lines
fs/xfs/xfs_fsverity.c +0
-0
[ ... ]
Quoted 6 lines
fs/xfs/xfs_fsverity.c +6
-0+static int +xfs_fsverity_get_descriptor ( +struct inode *inode, +void *buf, +size_t buf_size) +{
[ ... ]
Quoted 19 lines
fs/xfs/xfs_fsverity.c +19
-0+/* +* Make sure we can open large file on a 32-bit kernel +*/ +if (rec.br_startoff + rec.br_blockcount > +XFS_B_TO_FSB (mp, inode->i_sb->s_maxbytes)) +return -EFBIG ; + + last_block_offset = +XFS_FSB_TO_B (mp, rec.br_startoff + rec.br_blockcount); +if (last_block_offset <=xfs_fsverity_metadata_offset (ip)) +return -ENODATA ; + + desc_size_pos = last_block_offset -sizeof (__be32); + error =fsverity_pagecache_read (inode, (char *)&d_desc_size, +sizeof (d_desc_size), desc_size_pos); +if (error) +return error; + + desc_size =be32_to_cpu (d_desc_size);
fs/xfs/xfs_fsverity.c xfs_fsverity_is_file_data( · line 132
Quoted 10 lines
fs/xfs/xfs_fsverity.c +10
-0+if (XFS_IS_CORRUPT (mp, desc_size >FS_VERITY_MAX_DESCRIPTOR_SIZE )) +return -ERANGE ; +if (XFS_IS_CORRUPT (mp, desc_size > desc_size_pos)) +return -ERANGE ; + +if (!buf_size) +return desc_size; + +if (XFS_IS_CORRUPT (mp, desc_size > buf_size)) +return -ERANGE ;
[Severity: Low]
Is desc_size > buf_size an on-disk corruption condition? buf_size is the caller-supplied buffer length and desc_size has already been checked against FS_VERITY_MAX_DESCRIPTOR_SIZE, so a caller passing a smaller buffer triggers a false XFS_IS_CORRUPT() report.
Also, returning early when !buf_size skips the desc_pos >= xfs_fsverity_metadata_offset(ip) check below, so the initial size probe in fsverity_get_descriptor() accepts a corrupt desc_size that overlaps the file data region. Finally, XFS_B_TO_FSB(mp, inode->i_sb->s_maxbytes) rounds LLONG_MAX up to 1ULL << (63 - sb_blocklog), which overflows signed xfs_fsize_t in XFS_FSB_TO_B(); using XFS_B_TO_FSBT() avoids that overflow.
fs/xfs/xfs_fsverity.c xfs_fsverity_is_file_data( · line 143
Quoted 10 lines
fs/xfs/xfs_fsverity.c +10
-0+ desc_pos =round_down (desc_size_pos - desc_size, blocksize); +if (desc_pos <xfs_fsverity_metadata_offset (ip)) +return -ERANGE ; + + error =fsverity_pagecache_read (inode, buf, desc_size, desc_pos); +if (error) +return error; + +return desc_size; +}
[Severity: Medium]
Can fsverity_pagecache_read() read across a hole in [desc_pos, last_block_offset) and expose uninitialized pagecache memory?
xfs_fsverity_get_descriptor() checks desc_pos against xfs_fsverity_metadata_offset(ip), but does not verify that rec.br_state == XFS_EXT_NORM or that desc_pos >= XFS_FSB_TO_B(mp, rec.br_startoff) so that the entire descriptor lives within the last written extent.
When xfs_fsverity_get_descriptor() is called from fsverity_ensure_verity_info(), S_VERITY is already set on the inode (so xfs_bmbt_to_iomap() sets IOMAP_F_FSVERITY), while fsverity_get_info(inode) is still NULL. If [desc_pos, desc_pos + desc_size) hits a hole, iomap_read_folio_iter() skips fsverity_fill_zerohash() because ctx->vi is NULL and marks the newly allocated folio uptodate without zeroing it:
fs/iomap/buffered-io.c:iomap_read_folio_iter() {
...
if ((iomap->flags & IOMAP_F_FSVERITY) &&
iomap->type == IOMAP_HOLE) {
if (ctx->vi)
fsverity_fill_zerohash(folio, poff, plen,
ctx->vi);
iomap_set_range_uptodate(folio, poff, plen);
}
...
}That leaves uninitialized kernel page memory cached in inode->i_mapping and readable via FS_IOC_READ_VERITY_METADATA.
[ ... ]
Quoted 25 lines
fs/xfs/xfs_fsverity.c +25
-0+static int +xfs_fsverity_reset_inode ( +struct xfs_inode *ip) +{ +int error; +struct xfs_mount *mp = ip->i_mount; +struct xfs_trans *tp; + + error =xfs_fsverity_delete_metadata (ip); +if (error) +return error; + +/* +* First, let's clean in-memory fsverity flag and then reset it on the +* disk +*/ +inode_set_flags (VFS_I (ip),0 ,S_VERITY ); + +/* +* Set fsverity inode flag +*/ + error =xfs_trans_alloc_inode (ip, &M_RES (mp)->tr_ichange, +0 ,0 , false, &tp); +if (error) +return error;
fs/xfs/xfs_fsverity.c xfs_fsverity_is_file_data( · line 255
Quoted 10 lines
fs/xfs/xfs_fsverity.c +10
-0+ + ip->i_diflags2 &= ~XFS_DIFLAG2_VERITY ; + +xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); +xfs_trans_set_sync (tp); + + error =xfs_trans_commit (tp); +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +return error; +}
[Severity: Medium]
Does xfs_fsverity_reset_inode() leave XFS_DIFLAG2_VERITY set on the in-core inode if xfs_trans_commit() fails in xfs_fsverity_end_enable(), while running an unnecessary synchronous transaction on earlier errors?
In xfs_fsverity_end_enable(), S_VERITY is only set after xfs_trans_commit() succeeds, and ip->i_diflags2 |= XFS_DIFLAG2_VERITY is only set inside that final transaction. If xfs_trans_commit() fails, the filesystem shuts down without persisting XFS_DIFLAG2_VERITY, and xfs_fsverity_delete_metadata() fails immediately in xfs_trans_alloc() and returns before clearing ip->i_diflags2. Conversely, if xfs_fsverity_end_enable() fails before the final transaction, XFS_DIFLAG2_VERITY was never set, so allocating and committing a synchronous tr_ichange transaction here is unnecessary.
[ ... ]
Quoted 7 lines
fs/xfs/xfs_fsverity.c +7
-0+static int +xfs_fsverity_end_enable ( +struct file *file, +const void *desc, +size_t desc_size, +u64 merkle_tree_size) +{
[ ... ]
Quoted 7 lines
fs/xfs/xfs_fsverity.c +7
-0+/* +* Wait for Merkle tree get written to disk before setting on-disk inode +* flag and clearing I_VERITY_BUILDING +*/ + error =filemap_write_and_wait_range (inode->i_mapping, range_start, +LLONG_MAX ); +if (error)
fs/xfs/xfs_fsverity.c xfs_fsverity_is_file_data( · line 361
Quoted 10 lines
fs/xfs/xfs_fsverity.c +10
-0+ goto out; + +/* +* Proactively remove unwritten extents left by COW preallocations and +* write preallocation in the merkle tree holes and past descriptor, +* and any delayed preallocations +*/ + error =xfs_free_eofblocks (ip); +if (error) + goto out;
[Severity: High]
Does filemap_write_and_wait_range() skip writing back every post-EOF Merkle tree and descriptor folio, after which xfs_free_eofblocks() punches out their delayed allocation extents?
xfs_vm_writepages() zero-initializes struct xfs_writepage_ctx wpc (leaving wpc.ctx.iomap.flags == 0) before calling iomap_writepages(). For the first folio at or past range_start (>= i_size), iomap_writeback_folio() calls iomap_writeback_handle_eof() before calling iomap_writeback_range() -> xfs_map_blocks():
fs/iomap/buffered-io.c:iomap_writeback_handle_eof() {
...
if (wpc->iomap.flags & IOMAP_F_FSVERITY) {
WARN_ON_ONCE(folio_pos(folio) < isize);
return true;
}
if (*end_pos > isize) {
size_t poff = offset_in_folio(folio, isize);
pgoff_t end_index = isize >> PAGE_SHIFT;
if (folio->index > end_index ||
(folio->index == end_index && poff == 0))
return false;
...
}Because IOMAP_F_FSVERITY has not been set in wpc->iomap.flags yet and folio_pos(folio) >= round_up(isize, 65536), iomap_writeback_handle_eof() returns false on every post-EOF folio without ever calling xfs_map_blocks(). xfs_free_eofblocks() then punches out all post-EOF delalloc blocks via xfs_bmap_punch_delalloc_range(), leaving the sealed verity inode with no Merkle tree or descriptor extents on disk.
Quoted 23 lines
fs/xfs/xfs_ioctl.c +8
-0@@ -562,6 +562,14 @@ xfs_ioctl_setattr_xflags(if (xfs_inode_has_filedata (ip))return -EINVAL ; +/* +* fs-verity is incompatible with a realtime allocation unit +* larger than a single filesystem block, so don't let a file be +* converted to realtime while verity is being enabled. +*/ +if (fsverity_is_building (VFS_IC (ip))) +return -EINVAL ; +/* * If S_DAX is enabled on this file, we can only switch the * device if both support fsdax. We can't update S_DAX because @@ -574,6 +582,17 @@ xfs_ioctl_setattr_xflags(return -EINVAL ; }
fs/xfs/xfs_ioctl.c xfs_ioctl_setattr_xflags( · line 594
Quoted 10 lines
fs/xfs/xfs_ioctl.c +10
-0+/* +* fs-verity is incompatible with DAX, and xfs_fsverity_begin_enable() +* verified the inode was not DAX under the inode lock. That lock is +* dropped while the Merkle tree is built, so reject enabling DAX while +* verity is being enabled. +*/ +if ((fa->fsx_xflags &FS_XFLAG_DAX ) && + !(ip->i_diflags2 &XFS_DIFLAG2_DAX ) && +fsverity_is_building (VFS_IC (ip))) +return -EINVAL ;
[Severity: High]
Does this fail to build because fsverity_is_building() is neither declared nor defined anywhere in the tree, and is the in-progress verity building state missing from xfs_fsverity_begin_enable() and xfs_fsverity_end_enable()?
The commit message notes that XFS_IVERITY_CONSTRUCTION is set while the Merkle tree is being built, and xfs_fsverity_end_enable() mentions clearing I_VERITY_BUILDING, but neither flag nor fsverity_is_building() is defined, and xfs_fsverity_begin_enable() and xfs_fsverity_end_enable() never set, test, or clear any verity-construction state on the inode.
In addition to the build failure here (and at the fsverity_is_building() callers introduced in commit "xfs: clamp file size for reading for fsverity" and commit "xfs: don't preallocate past descriptor block for fsverity"), nothing returns -EBUSY if a second FS_IOC_ENABLE_VERITY starts after enable_verity() drops inode_lock() to build the Merkle tree, and xfs_iomap_is_fsverity_metadata() and xfs_free_eofblocks() cannot tell that verity is being built before S_VERITY is set.
fs/xfs/xfs_super.c line 33
Quoted 9 lines
fs/xfs/xfs_super.c +1
-0@@ -30,6 +30,7 @@#include "xfs_filestream.h" #include "xfs_quota.h" #include "xfs_sysfs.h" +#include "xfs_fsverity.h"
[Severity: Low]
This isn't a bug, but xfs_fsverity.h is already included in fs/xfs/xfs_super.c by commit "xfs: use read ioend for fsverity data verification".
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9
PATCH v19 10/15 xfs: initialize fs-verity on file open
In reply to Andrey Albershteynfs-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 | 7 +++++++ 1 file changed, 7 insertions(+)
fs/xfs/xfs_file.c +7 -0
@@ -1753,11 +1753,18 @@ 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_CAN_ODIRECT ;if (xfs_get_atomic_write_min (XFS_I (inode)) >0 ) file->f_mode |=FMODE_CAN_ATOMIC_WRITE ; + + error =fsverity_file_open (inode, file); +if (error) +return error; +return generic_file_open (inode, file); }
Signature · 1 line
2.54.0
PATCH v19 11/15 xfs: add fs-verity ioctls
In reply to Andrey AlbershteynAdd fs-verity ioctls to enable, dump metadata (descriptor and Merkle tree pages) and obtain file's digest.
[djwong: remove unnecessary casting]
--- fs/xfs/xfs_ioctl.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
fs/xfs/xfs_ioctl.c +14 -0
@@ -49,6 +49,7 @@#include <linux/mount.h> #include <linux/fileattr.h> +#include <linux/fsverity.h> /* Return 0 on success or positive error */ int
@@ -1594,6 +1595,19 @@ xfs_file_ioctl(case XFS_IOC_VERIFY_MEDIA :return xfs_ioc_verify_media (filp, arg); +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 ; }
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v19 11/15] xfs: add fs-verity ioctls
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider: - [Medium] xfs: xfs_fileattr_set() rejects FS_VERITY_FL during FS_IOC_SETFLAGS --
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider:
- [Medium] xfs: xfs_fileattr_set() rejects FS_VERITY_FL during FS_IOC_SETFLAGS
--
commit 3fae29a529f78f9a34f0fcaea0d85bd2f887a199
Author: Andrey Albershteyn <[email protected]>
xfs: add fs-verity ioctls
This commit wires up FS_IOC_ENABLE_VERITY, FS_IOC_MEASURE_VERITY, and FS_IOC_READ_VERITY_METADATA in xfs_file_ioctl().
Quoted 4 lines
fs/xfs/xfs_ioctl.c +0
-0
[ ... ]
fs/xfs/xfs_ioctl.c xfs_file_ioctl( · line 1601
Quoted 8 lines
fs/xfs/xfs_ioctl.c +4
-0@@ -1594,6 +1595,19 @@ xfs_file_ioctl(case XFS_IOC_VERIFY_MEDIA :return xfs_ioc_verify_media (filp, arg); +case FS_IOC_ENABLE_VERITY : +if (!xfs_has_verity (mp)) +return -EOPNOTSUPP ; +return fsverity_ioctl_enable (filp, arg);
[Severity: Medium]
Once FS_IOC_ENABLE_VERITY sets XFS_DIFLAG2_VERITY on an inode, will xfs_fileattr_set() reject FS_IOC_SETFLAGS updates on that file with -EOPNOTSUPP?
xfs_ip2xflags() reports FS_XFLAG_VERITY, which fileattr_fill_xflags() maps to FS_VERITY_FL in fa->flags during FS_IOC_GETFLAGS. When userspace (such as chattr) modifies another flag and writes the flags word back via FS_IOC_SETFLAGS, fa->fsx_valid is false and FS_VERITY_FL remains set in fa->flags, but xfs_fileattr_set() does not include FS_VERITY_FL in allowed:
fs/xfs/xfs_ioctl.c:xfs_fileattr_set() {
...
if (!fa->fsx_valid) {
unsigned int allowed = FS_IMMUTABLE_FL | FS_APPEND_FL |
FS_NOATIME_FL | FS_NODUMP_FL |
FS_SYNC_FL | FS_DAX_FL |
FS_PROJINHERIT_FL;
if (xfs_has_asciici(mp))
allowed |= FS_CASEFOLD_FL;
if (fa->flags & ~allowed)
return -EOPNOTSUPP;
}
...
}Allowing FS_VERITY_FL in xfs_fileattr_set() when XFS_DIFLAG2_VERITY is already set on the inode (or when xfs_has_verity(mp) is enabled, since vfs_fileattr_set() -> fileattr_set_prepare() already rejects toggling FS_VERITY_FL) would keep FS_IOC_SETFLAGS working on verity files.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11
PATCH v19 12/15 xfs: advertise fs-verity being available on filesystem
In reply to Andrey AlbershteynFrom: "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
@@ -250,6 +250,7 @@ typedef struct xfs_fsop_resblks {#define XFS_FSOP_GEOM_FLAGS_PARENT (1 << 25)/* linux parent pointers */ #define XFS_FSOP_GEOM_FLAGS_METADIR (1 << 26)/* metadata directories */ #define XFS_FSOP_GEOM_FLAGS_ZONED (1 << 27)/* zoned rt device */ +#define XFS_FSOP_GEOM_FLAGS_VERITY (1 << 28)/* fs-verity */ /* * Minimum and maximum sizes need for growth checks.
fs/xfs/libxfs/xfs_sb.c +2 -0
@@ -1546,6 +1546,8 @@ xfs_fs_geometry( geo->flags |=XFS_FSOP_GEOM_FLAGS_METADIR ;if (xfs_has_zoned (mp)) geo->flags |=XFS_FSOP_GEOM_FLAGS_ZONED ; +if (xfs_has_verity (mp)) + geo->flags |=XFS_FSOP_GEOM_FLAGS_VERITY ; geo->rtsectsize = sbp->sb_blocksize; geo->dirblocksize =xfs_dir2_dirblock_bytes (sbp);
Signature · 1 line
2.54.0
PATCH v19 13/15 xfs: check and repair the verity inode flag state
In reply to Andrey AlbershteynFrom: "Darrick J. Wong" <[email protected]>
If an inode has the incore verity iflag set, make sure that we can actually activate fsverity on that inode. If activation fails due to a fsverity metadata validation error, clear the flag and delete fs-verity metadata. The usage model for fsverity requires that any program that cares about verity state is required to call statx/getflags to check that the flag is set after opening the file, so clearing the flag will not compromise that model.
--- fs/xfs/scrub/common.c | 53 +++++++++++++++++++++++++++++++++++++ fs/xfs/scrub/common.h | 2 ++ fs/xfs/scrub/inode.c | 22 +++++++++++++++ fs/xfs/scrub/inode_repair.c | 49 ++++++++++++++++++++++++++++++++++ 4 files changed, 126 insertions(+)
fs/xfs/scrub/common.c +53 -0
@@ -45,6 +45,8 @@#include "scrub/health.h" #include "scrub/tempfile.h" +#include <linux/fsverity.h> +/* Common code for the metadata scrubbers. */ /*
@@ -1765,3 +1767,54 @@ xchk_inode_count_blocks(return xfs_bmap_count_blocks (sc->tp, sc->ip, whichfork, nextents, count); } + +/* +* If this inode has S_VERITY set on it, read the verity info. If the reading +* fails with anything other than ENOMEM, the file is corrupt, which we can +* detect later with fsverity_active. +* +* Callers must hold the IOLOCK and must not hold the ILOCK of sc->ip because +* activation reads inode data. +*/ +int +xchk_inode_setup_verity ( +struct xfs_scrub *sc) +{ +int error; + +if (!fsverity_active (VFS_I (sc->ip))) +return 0 ; + + error =fsverity_ensure_verity_info (VFS_I (sc->ip)); +switch (error) { +case 0 : +/* fsverity is active */ +break ; +case -ENODATA : +case -EMSGSIZE : +case -EFSCORRUPTED : +case -ERANGE : +case -EBADMSG : +/* +* The nonzero errno codes above are the error codes that can +* be returned from fsverity on metadata validation errors. +*/ +return 0 ; +default : +/* runtime errors */ +return error; + } + +return 0 ; +} + +/* +* Is this a verity file that failed to activate? Callers must have tried to +* activate fsverity via xchk_inode_setup_verity. +*/ +bool +xchk_inode_verity_broken ( +struct xfs_inode *ip) +{ +return fsverity_active (VFS_I (ip)) && !fsverity_get_info (VFS_I (ip)); +}
fs/xfs/scrub/common.h +2 -0
@@ -261,6 +261,8 @@ int xchk_inode_is_allocated(struct xfs_scrub *sc, xfs_agino_t agino, bool *inuse);int xchk_inode_count_blocks (struct xfs_scrub *sc,int whichfork,xfs_extnum_t *nextents,xfs_filblks_t *count); +int xchk_inode_setup_verity (struct xfs_scrub *sc); +bool xchk_inode_verity_broken (struct xfs_inode *ip);bool xchk_inode_is_dirtree_root (const struct xfs_inode *ip);bool xchk_inode_is_sb_rooted (const struct xfs_inode *ip);
fs/xfs/scrub/inode.c +22 -0
@@ -33,9 +33,28 @@ xchk_prepare_iscrub( struct xfs_scrub *sc) {int error; +struct xfs_inode *ip = sc->ip;xchk_ilock (sc,XFS_IOLOCK_EXCL ); + error =xchk_inode_setup_verity (sc); +if (error) +return error; + +/* +* If we're going to repair a file whose fsverity descriptor cannot be +* activated, drop the stale Merkle tree folios. Once the +* post-EOF Merkle extents are freed during repair, those uptodate +* folios would otherwise sit over a hole and could be exposed as file +* data by a later extending write or truncate. +* +* The lock would be unlocked by global scrub machinery. +*/ +if (xchk_could_repair (sc) &&xchk_inode_verity_broken (ip)) { +xchk_ilock (sc,XFS_MMAPLOCK_EXCL ); +truncate_inode_pages (VFS_I (ip)->i_mapping,XFS_ISIZE (ip)); + } + error =xchk_trans_alloc (sc,0 );if (error)return error;
@@ -833,6 +852,9 @@ xchk_inode(if (S_ISREG (VFS_I (sc->ip)->i_mode))xchk_inode_check_reflink_iflag (sc,I_INO (sc->ip)); +if (xchk_inode_verity_broken (sc->ip)) +xchk_ino_set_corrupt (sc, sc->sm->sm_ino); +xchk_inode_check_unlinked (sc);xchk_inode_xref (sc,I_INO (sc->ip), &di);
fs/xfs/scrub/inode_repair.c +49 -0
73 lines not on this page · raw message
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v19 13/15] xfs: check and repair the verity inode flag state
Thank you for your contribution! Sashiko AI review found 6 potential issues to consider: - [High] xfs: unhandled verity validation error codes in xchk_inode_setup_verity() - [Medium] xfs: missing…
Thank you for your contribution! Sashiko AI review found 6 potential issues to consider:
- [High] xfs: unhandled verity validation error codes in xchk_inode_setup_verity()
- [Medium] xfs: missing realtime extent size check for verity in xrep_dinode_flags()
- [Medium] xfs: missing post-EOF pagecache truncation in xrep_dinode_core()
- [Medium] xfs: verity scrub and repair mishandle corrupt or zapped data forks
- [Low] xfs: xfs_reflink_clear_inode_flag() runs before xrep_inode_verity()
- [Low] xfs: xchk_inode() passes sm_ino instead of I_INO(sc->ip) on broken verity
--
commit 900d4ad794cd099d5e6c56defb28f056e4bd90b5
Author: Darrick J. Wong <[email protected]>
xfs: check and repair the verity inode flag state
This commit adds scrub and repair logic to activate fsverity on inodes with the verity flag set, clearing the flag and unmapping post-EOF Merkle tree extents if fsverity metadata validation fails.
Quoted 4 lines
fs/xfs/scrub/common.c +0
-0
[ ... ]
Quoted 34 lines
fs/xfs/scrub/common.c +30
-0@@ -1765,3 +1767,54 @@ xchk_inode_count_blocks(return xfs_bmap_count_blocks (sc->tp, sc->ip, whichfork, nextents, count); } + +/* +* If this inode has S_VERITY set on it, read the verity info. If the reading +* fails with anything other than ENOMEM, the file is corrupt, which we can +* detect later with fsverity_active. +* +* Callers must hold the IOLOCK and must not hold the ILOCK of sc->ip because +* activation reads inode data. +*/ +int +xchk_inode_setup_verity ( +struct xfs_scrub *sc) +{ +int error; + +if (!fsverity_active (VFS_I (sc->ip))) +return 0 ; + + error =fsverity_ensure_verity_info (VFS_I (sc->ip)); +switch (error) { +case 0 : +/* fsverity is active */ +break ; +case -ENODATA : +case -EMSGSIZE : +case -EFSCORRUPTED : +case -ERANGE : +case -EBADMSG : +/* +* The nonzero errno codes above are the error codes that can
fs/xfs/scrub/common.c xchk_inode_count_blocks( · line 1809
Quoted 10 lines
fs/xfs/scrub/common.c +10
-0+* be returned from fsverity on metadata validation errors. +*/ +return 0 ; +default : +/* runtime errors */ +return error; + } + +return 0 ; +}
[Severity: High]
Does xchk_inode_setup_verity() miss validation errors such as -EINVAL and -EFBIG from fsverity_ensure_verity_info()?
In fs/verity/open.c, validate_fsverity_descriptor() returns -EINVAL when descriptor fields (such as version, hash algorithm, log_blocksize, or data_size != inode->i_size) are invalid, and fsverity_init_merkle_tree_params() returns -EINVAL or -EFBIG on invalid Merkle tree parameters. xfs_fsverity_get_descriptor() can also return -EFBIG or -EFSBADCRC, and signature verification can return -EKEYREJECTED, -ENOKEY, -EPERM, or -ENOPKG.
Because these error codes hit the default branch, xchk_prepare_iscrub() and xrep_dinode_core() abort the scrub ioctl with a runtime error before xchk_inode() can mark the inode corrupt or xrep_inode_verity() can clear the broken verity state.
Quoted 4 lines
fs/xfs/scrub/inode.c +0
-0
[ ... ]
fs/xfs/scrub/inode.c xchk_inode( · line 860
Quoted 10 lines
fs/xfs/scrub/inode.c +3
-0@@ -833,6 +852,9 @@ xchk_inode(if (S_ISREG (VFS_I (sc->ip)->i_mode))xchk_inode_check_reflink_iflag (sc,I_INO (sc->ip)); +if (xchk_inode_verity_broken (sc->ip)) +xchk_ino_set_corrupt (sc, sc->sm->sm_ino); +xchk_inode_check_unlinked (sc);xchk_inode_xref (sc,I_INO (sc->ip), &di);
[Severity: Low]
Should this pass I_INO(sc->ip) instead of sc->sm->sm_ino to xchk_ino_set_corrupt(), like the surrounding checks in xchk_inode()? When scrubbing by open file descriptor with sm_ino == 0, passing sc->sm->sm_ino logs inode 0x0 in trace_xchk_ino_error().
fs/xfs/scrub/inode_repair.c xrep_dinode_flags( · line 581
Quoted 10 lines
fs/xfs/scrub/inode_repair.c +2
-0@@ -577,6 +577,8 @@ xrep_dinode_flags( dip->di_nrext64_pad =0 ; else if (dip->di_version >= 3) dip->di_v3_pad = 0; +if (!xfs_has_verity (mp) || !S_ISREG (mode)) + flags2 &= ~XFS_DIFLAG2_VERITY ;
[Severity: Medium]
Should xrep_dinode_flags() also clear XFS_DIFLAG2_VERITY when (flags & XFS_DIFLAG_REALTIME) && mp->m_sb.sb_rextsize > 1?
xfs_dinode_verify() rejects dinodes that have both XFS_DIFLAG2_VERITY and XFS_DIFLAG_REALTIME set when sb_rextsize > 1:
fs/xfs/libxfs/xfs_inode_buf.c:xfs_dinode_verify() {
...
if (flags2 & XFS_DIFLAG2_VERITY) {
if (!xfs_has_verity(mp))
return __this_address;
if (!S_ISREG(mode))
return __this_address;
...
if ((flags & XFS_DIFLAG_REALTIME) && mp->m_sb.sb_rextsize > 1)
return __this_address;
}
...
}If a corrupt dinode has realtime extents and XFS_DIFLAG2_VERITY on a filesystem with sb_rextsize > 1, xrep_dinode_core() logs the dinode buffer with both flags still set, fails xchk_iget() with -EFSCORRUPTED, and commits the dirty inode cluster buffer, which will fail xfs_inode_buf_verify() on writeback and shut down the filesystem.
fs/xfs/scrub/inode_repair.c xrep_dinode_core( · line 1670
Quoted 11 lines
fs/xfs/scrub/inode_repair.c +4
-0@@ -1659,6 +1661,10 @@ xrep_dinode_core(if (iget_error)return iget_error; + error =xchk_inode_setup_verity (sc); +if (error) +return error; + error =xchk_trans_alloc (sc,0 );if (error)return error;
[Severity: Medium]
Does xrep_dinode_core() need to lock XFS_MMAPLOCK_EXCL and call truncate_inode_pages(VFS_I(sc->ip)->i_mapping, XFS_ISIZE(sc->ip)) when xchk_inode_verity_broken(sc->ip) is true, just as xchk_prepare_iscrub() does?
When an inode initially fails xfs_iget() and is repaired via xrep_dinode_core(), xchk_prepare_iscrub() does not run before xrep_inode(). xchk_inode_setup_verity() populates uptodate post-EOF pagecache folios while reading the descriptor, and xrep_inode_verity() then unmaps the post-EOF extents and clears S_VERITY without truncating those folios, leaving stale Merkle tree pages over a hole that can be exposed by a later extending write or truncate.
Quoted 27 lines
fs/xfs/scrub/inode_repair.c +23
-0@@ -2198,6 +2204,40 @@ xrep_inode_reset_dquots(# define xrep_inode_reset_dquots (sc) (0)#endif +/* +* If this file is a fsverity file, xchk_prepare_iscrub or xrep_dinode_core +* should have activated it. If it's still not active, then there's something +* wrong with the verity descriptor, so turn verity off and free the orphaned +* Merkle tree that XFS keeps in extents beyond EOF. +*/ +STATIC int +xrep_inode_verity ( +struct xfs_scrub *sc) +{ +struct inode *inode =VFS_I (sc->ip); +struct xfs_mount *mp = sc->mp; +int error; + +if (!xchk_inode_verity_broken (sc->ip)) +return 0 ; + +/* +* The fsverity descriptor cannot be activated, so disable verity and +* free the Merkle tree, which XFS stores in beyond EOF. The stale +* Merkle tree page cache was already dropped during scrub setup. +*/ + error = xfs_bunmapi_range(&sc->tp, sc->ip, 0,
fs/xfs/scrub/inode_repair.c xrep_inode_reset_dquots( · line 2239
Quoted 10 lines
fs/xfs/scrub/inode_repair.c +10
-0+ XFS_B_TO_FSB(mp, XFS_ISIZE(sc->ip)), XFS_MAX_FILEOFF); +if (error) +return error; + + sc->ip->i_diflags2 &= ~XFS_DIFLAG2_VERITY ; +inode_set_flags (inode,0 ,S_VERITY ); + +xfs_trans_log_inode (sc->tp, sc->ip,XFS_ILOG_CORE ); +return 0 ; +}
[Severity: Medium]
What happens if the inode's data fork was zapped by xrep_dinode_zap_dfork() in xrep_dinode_core(), or if its out-of-line data fork BMBT is corrupt?
If xrep_dinode_zap_dfork() zapped the data fork to 0 extents (setting ri->ino_sick_mask |= XFS_SICK_INO_BMBTD_ZAPPED so BMAPBTD repair will rebuild it from rmapbt later), xchk_inode_setup_verity() runs on the empty fork and fails with -ENODATA. xrep_inode_verity() then runs xfs_bunmapi_range() as a no-op on the empty fork and clears XFS_DIFLAG2_VERITY and S_VERITY; when xrep_bmap_data() later rebuilds the data fork from rmapbt, it will reattach the post-EOF Merkle tree extents onto a non-verity file.
Conversely, if the dinode core is valid but the out-of-line data fork BMBT is corrupt, xchk_inode_setup_verity() swallows -EFSCORRUPTED from xfs_iread_extents(), causing xchk_inode() to mark the inode core corrupt and xrep_inode() to fail with -EFSCORRUPTED before XFS_SCRUB_TYPE_BMAPBTD can repair the data fork.
Quoted 6 lines
fs/xfs/scrub/inode_repair.c +2
-0@@ -2247,6 +2287,15 @@ xrep_inode(return error; } +/* +* Disable fsverity if it cannot be activated. Activation failure
fs/xfs/scrub/inode_repair.c xrep_inode( · line 2301
Quoted 10 lines
fs/xfs/scrub/inode_repair.c +7
-0+* prohibits the file from being opened, so there cannot be another +* program with an open fd to what it thinks is a verity file. +*/ + error =xrep_inode_verity (sc); +if (error) +return error; +/* Reconnect incore unlinked list */ error =xrep_inode_unlinked (sc);if (error)
[Severity: Low]
Should xrep_inode_verity() run before xfs_reflink_clear_inode_flag()?
xfs_reflink_inode_has_shared_extents() scans the entire data fork up to XFS_MAX_FILEOFF. If a broken verity inode only had shared extents in the post-EOF Merkle tree region, running xfs_reflink_clear_inode_flag() before xrep_inode_verity() unmaps those extents leaves XFS_DIFLAG2_REFLINK set, causing the post-repair recheck in xchk_inode_check_reflink_iflag() to flag XFS_SCRUB_OFLAG_PREEN.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=13
PATCH v19 14/15 xfs: introduce health state for corrupted fsverity metadata
In reply to Andrey AlbershteynReport corrupted fsverity descriptor through health system.
--- fs/xfs/libxfs/xfs_fs.h | 1 + fs/xfs/libxfs/xfs_health.h | 4 +++- fs/xfs/xfs_fsverity.c | 25 +++++++++++++++++++------ fs/xfs/xfs_health.c | 1 + 4 files changed, 24 insertions(+), 7 deletions(-)
fs/xfs/libxfs/xfs_fs.h +1 -0
@@ -422,6 +422,7 @@ struct xfs_bulkstat {#define XFS_BS_SICK_SYMLINK (1 << 6)/* symbolic link remote target */ #define XFS_BS_SICK_PARENT (1 << 7)/* parent pointers */ #define XFS_BS_SICK_DIRTREE (1 << 8)/* directory tree structure */ +#define XFS_BS_SICK_FSVERITY (1 << 9)/* fsverity metadata */ /* * Project quota id helpers (previously projid was 16bit only
fs/xfs/libxfs/xfs_health.h +3 -1
@@ -104,6 +104,7 @@ struct xfs_rtgroup;/* Don't propagate sick status to ag health summary during inactivation */ #define XFS_SICK_INO_FORGET (1 << 12)#define XFS_SICK_INO_DIRTREE (1 << 13)/* directory tree structure */ +#define XFS_SICK_INO_FSVERITY (1 << 14)/* fsverity metadata */ /* Primary evidence of health problems in a given group. */ #define XFS_SICK_FS_PRIMARY (XFS_SICK_FS_COUNTERS | \
@@ -140,7 +141,8 @@ struct xfs_rtgroup; XFS_SICK_INO_XATTR | \ XFS_SICK_INO_SYMLINK | \ XFS_SICK_INO_PARENT | \ - XFS_SICK_INO_DIRTREE) + XFS_SICK_INO_DIRTREE | \ + XFS_SICK_INO_FSVERITY)#define XFS_SICK_INO_ZAPPED (XFS_SICK_INO_BMBTD_ZAPPED | \ XFS_SICK_INO_BMBTA_ZAPPED | \
fs/xfs/xfs_fsverity.c +19 -6
@@ -98,8 +98,10 @@ xfs_fsverity_get_descriptor(if (error)return error; -if (is_empty) +if (is_empty) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ENODATA ; + }/* * Make sure we can open large file on a 32-bit kernel
@@ -110,8 +112,10 @@ xfs_fsverity_get_descriptor( last_block_offset =XFS_FSB_TO_B (mp, rec.br_startoff + rec.br_blockcount); -if (last_block_offset <=xfs_fsverity_metadata_offset (ip)) +if (last_block_offset <=xfs_fsverity_metadata_offset (ip)) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ENODATA ; + } desc_size_pos = last_block_offset -sizeof (__be32); error = fsverity_pagecache_read(inode, (char *)&d_desc_size,
@@ -120,20 +124,29 @@ xfs_fsverity_get_descriptor(return error; desc_size =be32_to_cpu (d_desc_size); -if (XFS_IS_CORRUPT (mp, desc_size >FS_VERITY_MAX_DESCRIPTOR_SIZE )) +if (XFS_IS_CORRUPT (mp, desc_size >FS_VERITY_MAX_DESCRIPTOR_SIZE )) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ERANGE ; -if (XFS_IS_CORRUPT (mp, desc_size > desc_size_pos)) + } + +if (XFS_IS_CORRUPT (mp, desc_size > desc_size_pos)) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ERANGE ; + }if (!buf_size)return desc_size; -if (XFS_IS_CORRUPT (mp, desc_size > buf_size)) +if (XFS_IS_CORRUPT (mp, desc_size > buf_size)) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ERANGE ; + } desc_pos =round_down (desc_size_pos - desc_size, blocksize); -if (desc_pos <xfs_fsverity_metadata_offset (ip)) +if (desc_pos <xfs_fsverity_metadata_offset (ip)) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ERANGE ; + } error =fsverity_pagecache_read (inode, buf, desc_size, desc_pos);if (error)
fs/xfs/xfs_health.c +1 -0
@@ -625,6 +625,7 @@ static const struct ioctl_sick_map ino_map[] = { { XFS_SICK_INO_DIR_ZAPPED, XFS_BS_SICK_DIR }, { XFS_SICK_INO_SYMLINK_ZAPPED, XFS_BS_SICK_SYMLINK }, { XFS_SICK_INO_DIRTREE, XFS_BS_SICK_DIRTREE }, + { XFS_SICK_INO_FSVERITY, XFS_BS_SICK_FSVERITY }, };/* Fill out bulkstat health info. */
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v19 14/15] xfs: introduce health state for corrupted fsverity metadata
Thank you for your contribution! Sashiko AI review found 2 potential issues to consider: - [Medium] xfs: XFS_SICK_INO_FSVERITY is never cleared by online scrub or repair - [Medium] xfs: race and…
Thank you for your contribution! Sashiko AI review found 2 potential issues to consider:
- [Medium] xfs: XFS_SICK_INO_FSVERITY is never cleared by online scrub or repair
- [Medium] xfs: race and stale XFS_SICK_INO_FSVERITY in xfs_fsverity_get_descriptor()
--
commit d3eed7a2ba01498b4bc83bae6fcdf5fb68591bb5
Author: Andrey Albershteyn <[email protected]>
xfs: introduce health state for corrupted fsverity metadata
This commit adds the XFS_SICK_INO_FSVERITY health flag (exposed to userspace via bulkstat as XFS_BS_SICK_FSVERITY) and marks inodes sick when xfs_fsverity_get_descriptor() detects corrupted fsverity metadata.
Quoted 13 lines
fs/xfs/libxfs/xfs_health.h +1
-0@@ -104,6 +104,7 @@ struct xfs_rtgroup;/* Don't propagate sick status to ag health summary during inactivation */ #define XFS_SICK_INO_FORGET (1 << 12)#define XFS_SICK_INO_DIRTREE (1 << 13)/* directory tree structure */ +#define XFS_SICK_INO_FSVERITY (1 << 14)/* fsverity metadata */ /* Primary evidence of health problems in a given group. */ #define XFS_SICK_FS_PRIMARY (XFS_SICK_FS_COUNTERS | \
fs/xfs/libxfs/xfs_health.h struct xfs_rtgroup; · line 145
Quoted 6 lines
fs/xfs/libxfs/xfs_health.h +2
-1@@ -140,7 +141,8 @@ struct xfs_rtgroup;XFS_SICK_INO_XATTR | \XFS_SICK_INO_SYMLINK | \XFS_SICK_INO_PARENT | \ - XFS_SICK_INO_DIRTREE) +XFS_SICK_INO_DIRTREE | \ + XFS_SICK_INO_FSVERITY)
[Severity: Medium]
Does online scrub or repair ever clear XFS_SICK_INO_FSVERITY once it is set?
When xchk_prepare_iscrub() runs xchk_inode_setup_verity() on an inode with broken verity metadata, xfs_fsverity_get_descriptor() sets XFS_SICK_INO_FSVERITY on ip->i_sick. However, type_to_health_flag for XFS_SCRUB_TYPE_INODE only tracks XFS_SICK_INO_CORE, and neither xchk_inode() nor xrep_inode_verity() adds XFS_SICK_INO_FSVERITY to sc->sick_mask or sc->healthy_mask.
After xrep_inode_verity() repairs the inode and the post-repair re-scrub pass calls xchk_update_health(), xfs_inode_mark_healthy() clears XFS_SICK_INO_CORE and XFS_SICK_INO_FORGET while leaving XFS_SICK_INO_FSVERITY set on ip->i_sick. The repaired inode continues to report XFS_BS_SICK_FSVERITY in bulkstat, cannot be reclaimed by xfs_reclaim_igrab(), and causes xfs_inactive_health() to falsely mark the AG sick with XFS_SICK_AG_INODES when inactivated.
Quoted 29 lines
fs/xfs/xfs_fsverity.c +6
-2@@ -98,8 +98,10 @@ xfs_fsverity_get_descriptor(if (error)return error; -if (is_empty) +if (is_empty) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ENODATA ; + }/* * Make sure we can open large file on a 32-bit kernel @@ -110,8 +112,10 @@ xfs_fsverity_get_descriptor( last_block_offset =XFS_FSB_TO_B (mp, rec.br_startoff + rec.br_blockcount); -if (last_block_offset <=xfs_fsverity_metadata_offset (ip)) +if (last_block_offset <=xfs_fsverity_metadata_offset (ip)) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ENODATA ; + } desc_size_pos = last_block_offset -sizeof (__be32); error = fsverity_pagecache_read(inode, (char *)&d_desc_size,
fs/xfs/xfs_fsverity.c xfs_fsverity_get_descriptor( · line 130
Quoted 9 lines
fs/xfs/xfs_fsverity.c +3
-2@@ -120,20 +124,29 @@ xfs_fsverity_get_descriptor(return error; desc_size =be32_to_cpu (d_desc_size); -if (XFS_IS_CORRUPT (mp, desc_size >FS_VERITY_MAX_DESCRIPTOR_SIZE )) +if (XFS_IS_CORRUPT (mp, desc_size >FS_VERITY_MAX_DESCRIPTOR_SIZE )) { +xfs_inode_mark_sick (XFS_I (inode),XFS_SICK_INO_FSVERITY );return -ERANGE ; -if (XFS_IS_CORRUPT (mp, desc_size > desc_size_pos)) + }
[Severity: Medium]
Can an in-flight xfs_fsverity_get_descriptor() race with online repair and mark the inode sick after S_VERITY has already been cleared?
xfs_fsverity_get_descriptor() checks S_VERITY and reads the last extent under XFS_ILOCK_EXCL, then drops XFS_ILOCK_EXCL before reading from the pagecache and validating the descriptor without holding XFS_IOLOCK or XFS_MMAPLOCK:
CPU0 CPU1xfs_file_open()
...
xfs_fsverity_get_descriptor()
xfs_ilock(ip, XFS_ILOCK_EXCL)
/* sees S_VERITY set */
xfs_bmap_last_extent(...)
xfs_iunlock(ip, XFS_ILOCK_EXCL)
xchk_prepare_iscrub()
xchk_ilock(sc, XFS_IOLOCK_EXCL)
xchk_ilock(sc, XFS_MMAPLOCK_EXCL)
truncate_inode_pages(..., isize)
xchk_ilock(sc, XFS_ILOCK_EXCL)
xrep_inode()
xrep_inode_verity()
xfs_bunmapi_range(...)
inode_set_flags(..., 0, S_VERITY)
xchk_teardown_inode()
fsverity_pagecache_read(...)
xfs_inode_mark_sick(ip,
XFS_SICK_INO_FSVERITY) <-- marks repaired inode sickBesides marking the already-repaired inode sick, if CPU0 runs fsverity_pagecache_read() between truncate_inode_pages() and xfs_bunmapi_range(), it can also repopulate post-EOF folios in the pagecache because read_mapping_folio() does not acquire XFS_MMAPLOCK.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=14
PATCH v19 15/15 xfs: enable ro-compat fs-verity flag
In reply to Andrey AlbershteynFinalize fs-verity integration in XFS by making kernel fs-verity aware with ro-compat flag.
--- fs/xfs/libxfs/xfs_format.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_format.h +3 -2
@@ -378,8 +378,9 @@ xfs_sb_has_compat_feature(#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_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(
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v19 15/15] xfs: enable ro-compat fs-verity flag
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider: - [Medium] xfs: unhandled verity errors and uncleared sickness in xchk_inode() --
Thank you for your contribution! Sashiko AI review found 1 potential issue to consider:
- [Medium] xfs: unhandled verity errors and uncleared sickness in xchk_inode()
--
commit 895a6d1e83651f06565310457271bfd62d56550f
Author: Andrey Albershteyn <[email protected]>
xfs: enable ro-compat fs-verity flag
This commit enables the XFS_SB_FEAT_RO_COMPAT_VERITY superblock feature flag in XFS_SB_FEAT_RO_COMPAT_ALL so that XFS filesystems with fs-verity can be mounted.
Quoted 6 lines
fs/xfs/libxfs/xfs_format.h +0
-0@@ -378,8 +378,9 @@ xfs_sb_has_compat_feature(#define XFS_SB_FEAT_RO_COMPAT_ALL \
fs/xfs/libxfs/xfs_format.h xfs_sb_has_compat_feature( · line 386
Quoted 10 lines
fs/xfs/libxfs/xfs_format.h +3
-2(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_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(
[Severity: Medium]
Can online scrub and repair handle inodes whose fs-verity metadata fails validation with -EINVAL or -EFBIG, and clear XFS_SICK_INO_FSVERITY after repair?
In commit "xfs: check and repair the verity inode flag state", xchk_inode_setup_verity() ignores several validation errnos from fsverity_ensure_verity_info() so that scrub and repair can proceed:
fs/xfs/scrub/common.c:xchk_inode_setup_verity() {
...
error = fsverity_ensure_verity_info(VFS_I(sc->ip));
switch (error) {
case 0:
/* fsverity is active */
break;
case -ENODATA:
case -EMSGSIZE:
case -EFSCORRUPTED:
case -ERANGE:
case -EBADMSG:
/*
* The nonzero errno codes above are the error codes that can
* be returned from fsverity on metadata validation errors.
*/
return 0;
default:
/* runtime errors */
return error;
}
...
}However, validate_fsverity_descriptor() returns -EINVAL for invalid descriptor fields (such as bad version, non-zero reserved bytes, or data_size mismatch), and fsverity_init_merkle_tree_params() returns -EINVAL or -EFBIG for invalid hash algorithms, block sizes, or oversized Merkle trees. Because those hit the default case, xchk_prepare_iscrub() and xrep_dinode_core() abort the scrub or repair ioctl instead of flagging corruption or running xrep_inode_verity().
In addition, commit "xfs: introduce health state for corrupted fsverity metadata" sets XFS_SICK_INO_FSVERITY on ip->i_sick when descriptor loading fails, and includes it in XFS_SICK_INO_PRIMARY. Because type_to_health_flag[XFS_SCRUB_TYPE_INODE] only maps to XFS_SICK_INO_CORE and neither xchk_inode() nor xrep_inode_verity() adds XFS_SICK_INO_FSVERITY to sc->healthy_mask, XFS_SICK_INO_FSVERITY remains set after repair and causes xfs_inactive_health() to mark the AG sick with XFS_SICK_AG_INODES when the inode is evicted.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=15