From: Andrey Albershteyn <aalbersh@kernel.org>
To: "Eric Biggers" <ebiggers@kernel.org>,
"Christoph Hellwig" <hch@lst.de>,
"Carlos Maiolino" <cem@kernel.org>,
"fsverity" <fsverity@lists.linux.dev>,
"linux-xfs" <linux-xfs@vger.kernel.org>
Cc: Andrey Albershteyn <aalbersh@kernel.org>,
"fsdevel" <linux-fsdevel@vger.kernel.org>,
david@fromorbit.com
Subject: [PATCH v19 00/15] fs-verity support for XFS with post EOF merkle tree
Date: Fri, 20 Nov 2026 16:57:34 +0100 [thread overview]
Message-ID: <20261120155752.192025-1-aalbersh@kernel.org> (raw)
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/20261120155032.187246-1-aalbersh@kernel.org
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/20261102144147.2393369-1-aalbersh@kernel.org/T/#t
v17:
https://lore.kernel.org/fsverity/20261002223705.2175542-1-aalbersh@kernel.org/T/#u
v16:
https://lore.kernel.org/fsverity/arJC542mXklAeswE@aalbersh-thinkpadx1carbongen13.rmtcz.csb/T/#t
v15:
https://lore.kernel.org/fsverity/20260817070240.GA17371@lst.de/T/#t
To: ebiggers@kernel.org
To: hch@lst.de
To: Carlos Maiolino <cem@kernel.org>
To: fsverity@lists.linux.dev
To: linux-xfs@vger.kernel.org
Cc: linux-fsdevel@vger.kernel.org
Cc: david@fromorbit.com
---
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/20260217231937.1183679-1-aalbersh@kernel.org/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/20250728-fsverity-v1-0-9e5443af0e34@kernel.org
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 <aalbersh@kernel.org>
Acked-by: Eric Biggers <ebiggers@kernel.org>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
+ Reviewed-by: Christoph Hellwig <hch@lst.de>
## 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.
-
Signed-off-by: Andrey Albershteyn <aalbersh@kernel.org>
- Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
- Reviewed-by: Christoph Hellwig <hch@lst.de>
## 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 <aalbersh@kernel.org>
+ Reviewed-by: Christoph Hellwig <hch@lst.de>
## 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" <djwong@kernel.org>
## 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 <aalbersh@kernel.org>
- Reviewed-by: Christoph Hellwig <hch@lst.de>
+
+ ## 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 <djwong@kernel.org>
Signed-off-by: Andrey Albershteyn <aalbersh@kernel.org>
- Reviewed-by: Christoph Hellwig <hch@lst.de>
## 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
--
2.54.0
next reply other threads:[~2026-11-20 15:58 UTC|newest]
Thread overview: 24+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 15:57 Andrey Albershteyn [this message]
2026-11-20 15:57 ` [PATCH v19 01/15] xfs: introduce fsverity on-disk changes Andrey Albershteyn
2026-11-20 16:26 ` sashiko-bot
2026-11-20 15:57 ` [PATCH v19 02/15] xfs: don't allow to enable DAX on fs-verity sealed inode Andrey Albershteyn
2026-11-20 15:57 ` [PATCH v19 03/15] xfs: disable direct read path for fs-verity files Andrey Albershteyn
2026-11-20 15:57 ` [PATCH v19 04/15] xfs: don't report dio_mem_align and dio_offset_align for fsverity files Andrey Albershteyn
2026-11-20 15:57 ` [PATCH v19 05/15] xfs: handle fsverity I/O in write/read path Andrey Albershteyn
2026-11-20 16:27 ` sashiko-bot
2026-11-20 15:57 ` [PATCH v19 06/15] xfs: use read ioend for fsverity data verification Andrey Albershteyn
2026-11-20 15:57 ` [PATCH v19 07/15] xfs: add XFS_BMAPI_UNWRITTEN to unmap unwritten extents in __xfs_bunmapi() Andrey Albershteyn
2026-11-20 15:57 ` [PATCH v19 08/15] xfs: don't remove written extents past EOF on fsverity inodes Andrey Albershteyn
2026-11-20 16:21 ` sashiko-bot
2026-11-20 15:57 ` [PATCH v19 09/15] xfs: add fs-verity support Andrey Albershteyn
2026-11-20 16:51 ` sashiko-bot
2026-11-20 15:57 ` [PATCH v19 10/15] xfs: initialize fs-verity on file open Andrey Albershteyn
2026-11-20 15:57 ` [PATCH v19 11/15] xfs: add fs-verity ioctls Andrey Albershteyn
2026-11-20 16:19 ` sashiko-bot
2026-11-20 15:57 ` [PATCH v19 12/15] xfs: advertise fs-verity being available on filesystem Andrey Albershteyn
2026-11-20 15:57 ` [PATCH v19 13/15] xfs: check and repair the verity inode flag state Andrey Albershteyn
2026-11-20 16:28 ` sashiko-bot
2026-11-20 15:57 ` [PATCH v19 14/15] xfs: introduce health state for corrupted fsverity metadata Andrey Albershteyn
2026-11-20 16:36 ` sashiko-bot
2026-11-20 15:57 ` [PATCH v19 15/15] xfs: enable ro-compat fs-verity flag Andrey Albershteyn
2026-11-20 16:38 ` sashiko-bot
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261120155752.192025-1-aalbersh@kernel.org \
--to=aalbersh@kernel.org \
--cc=cem@kernel.org \
--cc=david@fromorbit.com \
--cc=ebiggers@kernel.org \
--cc=fsverity@lists.linux.dev \
--cc=hch@lst.de \
--cc=linux-fsdevel@vger.kernel.org \
--cc=linux-xfs@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.