From: Dave Chinner <dgc@kernel.org>
To: linux-xfs@vger.kernel.org
Cc: cem@kernel.org
Subject: [PATCH 56/59] xfs: validate the whole buffer item during recovery
Date: Tue, 17 Nov 2026 10:15:13 +1100 [thread overview]
Message-ID: <20261116231707.3625263-57-dgc@kernel.org> (raw)
In-Reply-To: <20261116231707.3625263-1-dgc@kernel.org>
Validate a buffer log item once all its regions are decoded from the journal.
The rest of recovery can then trust it. The item size must match the number of
regions attached. The buffer must lie wholly within the data device.
A cancelled buffer is not replayed. It logs only its format header, so it must
be a single region. Nothing further is checked for a cancelled buffer.
Any other buffer must log at least one dirty region. It must record a valid
buffer type. A type flag, if set, must match the buffer type. The type flags
select special replay handling. A buffer logged for full replay carries only
its type, even if it holds inodes or dquots. V4 inode allocation and online
repair log buffers this way, so a missing type flag is valid. The dirty
regions must correspond to the dirty bitmap. They must not describe more than
a buffer's worth of data.
All CRC enabled filesystems record buffer types. Older V4 filesystems may log
buffers without a type. An unknown type is accepted only on those filesystems.
Such a buffer may have no more than one type flag set.
Historically, a dirty region that spanned a page boundary in a buffer could be
split into two logged regions. The runtime code has not triggered this split
logging in kernel git history, so we should never encounter it during recovery.
Hence each run of dirty bits must map to a single region.
The buffer block range is checked against the data device size held in the
buftarg rather than the superblock geometry. Deriving a shared daddr range
helper is left for later.
Assisted-by: LLM
Signed-off-by: Dave Chinner <dgc@kernel.org>
---
fs/xfs/scrub/inode_repair.c | 14 +++
fs/xfs/scrub/quota_repair.c | 7 ++
fs/xfs/xfs_buf_item_recover.c | 185 ++++++++++++++++++++++++++++++++++
3 files changed, 206 insertions(+)
diff --git a/fs/xfs/scrub/inode_repair.c b/fs/xfs/scrub/inode_repair.c
index 2dd3ea7fb361..3eff8cc66d1e 100644
--- a/fs/xfs/scrub/inode_repair.c
+++ b/fs/xfs/scrub/inode_repair.c
@@ -204,6 +204,13 @@ xrep_dinode_buf_core(
if (!unlinked_ok)
dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
xfs_dinode_calc_crc(mp, dip);
+
+ /*
+ * We don't mark the buffer with xfs_trans_inode_buf() as that would
+ * cause recovery to only replay unlinked list pointers. However, we
+ * still need to set the buffer type for recovery to correctly classify
+ * it as an inode buffer.
+ */
xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
xfs_trans_log_buf(tp, bp, ioffset,
ioffset + sizeof(struct xfs_dinode) - 1);
@@ -1632,6 +1639,13 @@ xrep_dinode_core(
/* Write out the inode. */
trace_xrep_dinode_fixed(sc, dip);
xfs_dinode_calc_crc(mp, dip);
+
+ /*
+ * We don't mark the buffer with xfs_trans_inode_buf() as that would
+ * cause recovery to only replay unlinked list pointers. However, we
+ * still need to set the buffer type for recovery to correctly classify
+ * it as an inode buffer.
+ */
xfs_trans_buf_set_type(sc->tp, bp, XFS_BLFT_DINO_BUF);
xfs_trans_log_buf(sc->tp, bp, ri->imap.im_boffset,
ri->imap.im_boffset + mp->m_sb.sb_inodesize - 1);
diff --git a/fs/xfs/scrub/quota_repair.c b/fs/xfs/scrub/quota_repair.c
index 88e341d6d1af..8660cbf4683a 100644
--- a/fs/xfs/scrub/quota_repair.c
+++ b/fs/xfs/scrub/quota_repair.c
@@ -408,6 +408,13 @@ xrep_quota_block(
buftype = XFS_BLFT_PDQUOT_BUF;
break;
}
+
+ /*
+ * We don't mark the buffer with xfs_trans_dquot_buf() as that would
+ * cause recovery to skip replaying it when quotas are not in use.
+ * However, we still need to set the buffer type for recovery to
+ * correctly classify it as a dquot buffer.
+ */
xfs_trans_buf_set_type(sc->tp, bp, buftype);
xfs_trans_log_buf(sc->tp, bp, 0, BBTOB(bp->b_length) - 1);
return xrep_roll_trans(sc);
diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
index 8fb419aba094..d8cec17bbb4e 100644
--- a/fs/xfs/xfs_buf_item_recover.c
+++ b/fs/xfs/xfs_buf_item_recover.c
@@ -1271,11 +1271,196 @@ xlog_recover_buf_validate_region(
return 0;
}
+/* The buffer type flags. A buffer has at most one of these set. */
+#define XFS_BLF_TYPE_MASK \
+ (XFS_BLF_INODE_BUF | XFS_BLF_UDQUOT_BUF | XFS_BLF_PDQUOT_BUF | \
+ XFS_BLF_GDQUOT_BUF)
+
+/*
+ * The buffer type is recorded both in the top bits of the format flags and in
+ * the type flags, and they describe different things. The type field
+ * describes the metadata held in the buffer. The type flags select special
+ * replay handling. An inode buffer flag replays only the unlinked list
+ * pointers, and a dquot buffer flag skips replay when that quota type is not
+ * in use. A buffer logged for full replay carries only its type, even if it
+ * holds inodes or dquots. V4 inode allocation and online repair log buffers
+ * this way.
+ *
+ * A buffer therefore carries at most one type flag, and if it has one it must
+ * be the one the type field describes.
+ */
+static xfs_failaddr_t
+xlog_recover_buf_verify_type(
+ struct xfs_mount *mp,
+ uint16_t blft,
+ unsigned int type)
+{
+ unsigned int expected;
+
+ /*
+ * All CRC enabled filesystems have buffer types defined. Older V4
+ * filesystems may not have types set, so allow an unknown type only in
+ * that case.
+ */
+ if (blft == XFS_BLFT_UNKNOWN_BUF && !xfs_has_crc(mp)) {
+ /*
+ * Only one inode or dquot buffer type flag can be set on a
+ * buffer. Without a buffer type there is nothing to validate
+ * the specific flag against, so only check that no more than
+ * one of them is set.
+ */
+ if (type & (type - 1))
+ return __this_address;
+ return NULL;
+ }
+
+ if (blft <= XFS_BLFT_UNKNOWN_BUF || blft >= XFS_BLFT_MAX_BUF)
+ return __this_address;
+
+ switch (blft) {
+ case XFS_BLFT_DINO_BUF:
+ expected = XFS_BLF_INODE_BUF;
+ break;
+ case XFS_BLFT_UDQUOT_BUF:
+ expected = XFS_BLF_UDQUOT_BUF;
+ break;
+ case XFS_BLFT_PDQUOT_BUF:
+ expected = XFS_BLF_PDQUOT_BUF;
+ break;
+ case XFS_BLFT_GDQUOT_BUF:
+ expected = XFS_BLF_GDQUOT_BUF;
+ break;
+ default:
+ expected = 0;
+ break;
+ }
+
+ if (type && type != expected)
+ return __this_address;
+ return NULL;
+}
+
+/*
+ * Validate the whole buffer item once all regions are assembled. The item size
+ * must match the number of regions attached. A cancelled buffer is not
+ * replayed, so it logs only the format header. Any other buffer must have a
+ * valid type, and its dirty regions must match the dirty bitmap and not
+ * describe more than a buffer's worth of data.
+ */
+static int
+xlog_recover_buf_validate_item(
+ struct xlog *log,
+ struct xlog_recover_item *item)
+{
+ struct xfs_buf_log_format *blf = item->ri_buf[0].iov_base;
+ xfs_daddr_t eofs = log->l_mp->m_ddev_targp->bt_nr_sectors;
+ xfs_failaddr_t fa;
+ size_t total = 0;
+ unsigned int ri = 1;
+ int first_bit;
+
+ if (blf->blf_size != item->ri_total) {
+ xfs_warn(log->l_mp,
+ "BUF: item size %u does not match region count %u recovered.",
+ blf->blf_size, item->ri_total);
+ return -EFSCORRUPTED;
+ }
+
+ /*
+ * The buffer length is an invariant: a buffer cannot be larger than the
+ * most data that can be logged in a single region.
+ */
+ if (blf->blf_len == 0 || BBTOB(blf->blf_len) > XLOG_MAX_REGION_SIZE) {
+ xfs_warn(log->l_mp,
+ "BUF: bad buffer length %u recovered.", blf->blf_len);
+ return -EFSCORRUPTED;
+ }
+
+ /*
+ * The buffer must lie wholly within the data device. Guard against the
+ * end wrapping so an out of range buffer cannot pass the bounds check.
+ */
+ if (blf->blf_blkno < 0 ||
+ blf->blf_blkno >= eofs ||
+ blf->blf_blkno + blf->blf_len < blf->blf_blkno ||
+ blf->blf_blkno + blf->blf_len > eofs) {
+ xfs_warn(log->l_mp,
+ "BUF: bad buffer block 0x%llx length %u recovered.",
+ blf->blf_blkno, blf->blf_len);
+ return -EFSCORRUPTED;
+ }
+
+ /*
+ * A cancelled buffer overrides everything else. It is not replayed, so
+ * it logs only the format header regardless of what the dirty bitmap
+ * holds, and nothing else needs to be checked.
+ */
+ if (blf->blf_flags & XFS_BLF_CANCEL) {
+ if (blf->blf_size != 1) {
+ xfs_warn(log->l_mp,
+ "BUF: cancelled buffer has %u regions recovered.",
+ blf->blf_size);
+ return -EFSCORRUPTED;
+ }
+ return 0;
+ }
+
+ /* A buffer that is not cancelled always logs some dirty data. */
+ if (item->ri_total < 2) {
+ xfs_warn(log->l_mp,
+ "BUF: buffer has no dirty regions recovered.");
+ return -EFSCORRUPTED;
+ }
+
+ fa = xlog_recover_buf_verify_type(log->l_mp, xfs_blft_from_flags(blf),
+ blf->blf_flags & XFS_BLF_TYPE_MASK);
+ if (fa) {
+ xfs_warn(log->l_mp,
+ "BUF: type %u and flags 0x%x disagree recovered at %pS",
+ xfs_blft_from_flags(blf), blf->blf_flags, fa);
+ return -EFSCORRUPTED;
+ }
+
+ /*
+ * Each dirty region covers one contiguous run of set bits in the dirty
+ * bitmap. Walk the bitmap and the regions together: each region size
+ * must match the length of the run it covers, each run must lie within
+ * the buffer, and the regions must exactly cover the bitmap. The dirty
+ * data across all regions cannot be larger than the buffer itself.
+ */
+ first_bit = xfs_next_bit(blf->blf_data_map, blf->blf_map_size, 0);
+ while (first_bit != -1) {
+ int nbits = xfs_contig_bits(blf->blf_data_map,
+ blf->blf_map_size, first_bit);
+
+ if (ri >= item->ri_total ||
+ item->ri_buf[ri].iov_len != (nbits << XFS_BLF_SHIFT) ||
+ ((first_bit + nbits) << XFS_BLF_SHIFT) > BBTOB(blf->blf_len))
+ goto bad_map;
+
+ total += item->ri_buf[ri].iov_len;
+ ri++;
+ first_bit = xfs_next_bit(blf->blf_data_map, blf->blf_map_size,
+ first_bit + nbits + 1);
+ }
+
+ if (ri != item->ri_total || total > BBTOB(blf->blf_len))
+ goto bad_map;
+
+ return 0;
+
+bad_map:
+ xfs_warn(log->l_mp,
+ "BUF: dirty bitmap does not match regions recovered.");
+ return -EFSCORRUPTED;
+}
+
const struct xlog_recover_item_ops xlog_buf_item_ops = {
.item_type = XFS_LI_BUF,
.min_hdr_len = offsetof(struct xfs_buf_log_format, blf_data_map),
.validate_nregions = xlog_recover_buf_nregions,
.validate_region = xlog_recover_buf_validate_region,
+ .validate_item = xlog_recover_buf_validate_item,
.reorder = xlog_recover_buf_reorder,
.ra_pass2 = xlog_recover_buf_ra_pass2,
.commit_pass1 = xlog_recover_buf_commit_pass1,
--
2.55.0
next prev parent reply other threads:[~2026-11-16 23:18 UTC|newest]
Thread overview: 60+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-16 23:14 [V2 PATCH 00/59] Validate journal log items during log recovery Dave Chinner
2026-11-16 23:14 ` [PATCH 01/59] xfs: set the unmount record operation header length Dave Chinner
2026-11-16 23:14 ` [PATCH 02/59] xfs: fix the rt rmap btree maximum level checks Dave Chinner
2026-11-16 23:14 ` [PATCH 03/59] xfs: allow an empty rt refcount btree root before the rt volume exists Dave Chinner
2026-11-16 23:14 ` [PATCH 04/59] xfs: recompute the rt btree maxlevels when growfs changes them Dave Chinner
2026-11-16 23:14 ` [PATCH 05/59] xfs: recompute the transaction reservations after growfs Dave Chinner
2026-11-16 23:14 ` [PATCH 06/59] xfs: skip missing groups when freeing them Dave Chinner
2026-11-16 23:14 ` [PATCH 07/59] xfs: update the rt geometry when recovering a superblock change Dave Chinner
2026-11-16 23:14 ` [PATCH 08/59] xfs: reinitialise the filesystem geometry after log recovery Dave Chinner
2026-11-16 23:14 ` [PATCH 09/59] xfs: apply mount superblock updates " Dave Chinner
2026-11-16 23:14 ` [PATCH 10/59] xfs: check the atomic write reservation against the current log size Dave Chinner
2026-11-16 23:14 ` [PATCH 11/59] xfs: fix the bmap btree maximum height calculation Dave Chinner
2026-11-16 23:14 ` [PATCH 12/59] xfs: add log recovery item validation design document Dave Chinner
2026-11-16 23:14 ` [PATCH 13/59] xfs: lift transaction header parsing out of the region assembly Dave Chinner
2026-11-16 23:14 ` [PATCH 14/59] xfs: track transaction header decode state explicitly Dave Chinner
2026-11-16 23:14 ` [PATCH 15/59] xfs: track the log item being rebuilt with an explicit pointer Dave Chinner
2026-11-16 23:14 ` [PATCH 16/59] xfs: complete log items explicitly during recovery Dave Chinner
2026-11-16 23:14 ` [PATCH 17/59] xfs: add log item validation infrastructure to log recovery Dave Chinner
2026-11-16 23:14 ` [PATCH 18/59] xfs: recover the transaction header as a validated item type Dave Chinner
2026-11-16 23:14 ` [PATCH 19/59] xfs: factor out xlog_recover_validate_ophdr() Dave Chinner
2026-11-16 23:14 ` [PATCH 20/59] xfs: validate operation header length and alignment during recovery Dave Chinner
2026-11-16 23:14 ` [PATCH 21/59] xfs: validate the operation header padding " Dave Chinner
2026-11-16 23:14 ` [PATCH 22/59] xfs: validate the operation header flags " Dave Chinner
2026-11-16 23:14 ` [PATCH 23/59] xfs: enforce zero length control records " Dave Chinner
2026-11-16 23:14 ` [PATCH 24/59] xfs: validate the unmount record " Dave Chinner
2026-11-16 23:14 ` [PATCH 25/59] xfs: handle zero length continuation op headers " Dave Chinner
2026-11-16 23:14 ` [PATCH 26/59] xfs: bound the assembled region size " Dave Chinner
2026-11-16 23:14 ` [PATCH 27/59] xfs: dump the corrupt region when log item validation fails Dave Chinner
2026-11-16 23:14 ` [PATCH 28/59] xfs: validate inode create and quota off log items during recovery Dave Chinner
2026-11-16 23:14 ` [PATCH 29/59] xfs: validate extent free " Dave Chinner
2026-11-16 23:14 ` [PATCH 30/59] xfs: validate and convert extent free intents " Dave Chinner
2026-11-16 23:14 ` [PATCH 31/59] xfs: validate and convert extent free done items " Dave Chinner
2026-11-16 23:14 ` [PATCH 32/59] xfs: validate rmap update intents " Dave Chinner
2026-11-16 23:14 ` [PATCH 33/59] xfs: validate rmap update done items " Dave Chinner
2026-11-16 23:14 ` [PATCH 34/59] xfs: validate refcount update intents " Dave Chinner
2026-11-16 23:14 ` [PATCH 35/59] xfs: validate refcount update done items " Dave Chinner
2026-11-16 23:14 ` [PATCH 36/59] xfs: validate bmap update intents " Dave Chinner
2026-11-16 23:14 ` [PATCH 37/59] xfs: validate bmap update done items " Dave Chinner
2026-11-16 23:14 ` [PATCH 38/59] xfs: validate mapping exchange intents " Dave Chinner
2026-11-16 23:14 ` [PATCH 39/59] xfs: validate mapping exchange done items " Dave Chinner
2026-11-16 23:14 ` [PATCH 40/59] xfs: validate dquot " Dave Chinner
2026-11-16 23:14 ` [PATCH 41/59] xfs: validate attr done " Dave Chinner
2026-11-16 23:14 ` [PATCH 42/59] xfs: validate attr intents " Dave Chinner
2026-11-16 23:15 ` [PATCH 43/59] xfs: convert inode items to host format " Dave Chinner
2026-11-16 23:15 ` [PATCH 44/59] xfs: allow xfs_imap() to map without an inode btree lookup Dave Chinner
2026-11-16 23:15 ` [PATCH 45/59] xfs: validate the inode item format header during recovery Dave Chinner
2026-11-16 23:15 ` [PATCH 46/59] xfs: validate the logged inode core " Dave Chinner
2026-11-16 23:15 ` [PATCH 47/59] xfs: validate the logged inode forks " Dave Chinner
2026-11-16 23:15 ` [PATCH 48/59] xfs: validate logged local fork contents " Dave Chinner
2026-11-16 23:15 ` [PATCH 49/59] xfs: validate logged extent " Dave Chinner
2026-11-16 23:15 ` [PATCH 50/59] xfs: allow a long format btree root to be checked without a cursor Dave Chinner
2026-11-16 23:15 ` [PATCH 51/59] xfs: validate logged btree fork roots during recovery Dave Chinner
2026-11-16 23:15 ` [PATCH 52/59] xfs: validate logged metadata " Dave Chinner
2026-11-16 23:15 ` [PATCH 53/59] xfs: check logged btree fork roots fit in the inode fork " Dave Chinner
2026-11-16 23:15 ` [PATCH 54/59] xfs: validate buffer item region count " Dave Chinner
2026-11-16 23:15 ` [PATCH 55/59] xfs: validate buffer item regions " Dave Chinner
2026-11-16 23:15 ` Dave Chinner [this message]
2026-11-16 23:15 ` [PATCH 57/59] xfs: remove redundant buffer checks from recovery replay Dave Chinner
2026-11-16 23:15 ` [PATCH 58/59] xfs: fail recovery on a buffer type mismatch Dave Chinner
2026-11-16 23:15 ` [PATCH 59/59] xfs: validate logged dquot buffers during recovery Dave Chinner
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=20261116231707.3625263-57-dgc@kernel.org \
--to=dgc@kernel.org \
--cc=cem@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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox