Linux XFS filesystem development
 help / color / mirror / Atom feed
From: Dave Chinner <dgc@kernel.org>
To: linux-xfs@vger.kernel.org
Cc: cem@kernel.org
Subject: [PATCH 24/59] xfs: validate the unmount record during recovery
Date: Tue, 17 Nov 2026 10:14:41 +1100	[thread overview]
Message-ID: <20261116231707.3625263-25-dgc@kernel.org> (raw)
In-Reply-To: <20261116231707.3625263-1-dgc@kernel.org>

The unmount record is the only record the log writes itself rather than
through a transaction. The log item processing loop skips it, so its contents
were never validated on recovery. A clean unmount is detected by inspecting it
during the head and tail scan, which trusted the operation header flags
without validating the header first.

Add xlog_recover_validate_unmount_record() to check the record is written by
the log, is the expected length, and carries the expected magic and zeroed
padding. Call it from the operation header validation.

The head and tail scan now validates the operation header before trusting its
flags. That scan runs before torn writes have been trimmed from the head of the
log, so an invalid record there is not treated as corruption. The log is only
considered clean if the record is a valid unmount record. Otherwise the log is
treated as dirty, and head verification and recovery deal with the record. The
scan validates quietly, as a record that is not an unmount record is expected
there.

A clean log can be mounted on a host of either endianness. The unmount record
magic is written in host byte order, so both byte orders are accepted.

The unmount record length was incorrectly written as zero for a period of time.
A zero length record has no payload to check, so accept it with a warning so
that filesystems written by those kernels still recover.

Assisted-by: LLM
Signed-off-by: Dave Chinner <dgc@kernel.org>
---
 fs/xfs/xfs_log_recover.c | 144 +++++++++++++++++++++++++++++++++------
 1 file changed, 123 insertions(+), 21 deletions(-)

diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index bb3e23c20069..0c7788345cd3 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -42,6 +42,8 @@ xlog_clear_stale_blocks(
 STATIC int
 xlog_do_recovery_pass(
         struct xlog *, xfs_daddr_t, xfs_daddr_t, int, xfs_daddr_t *);
+STATIC struct xlog_op_header *
+xlog_recover_validate_ophdr(struct xlog *log, char *dp, char *end, bool quiet);
 
 /*
  * Sector aligned buffer routines for buffer create/read/write/access
@@ -1169,8 +1171,18 @@ xlog_check_unmount_rec(
 		if (error)
 			return error;
 
-		op_head = (struct xlog_op_header *)offset;
-		if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
+		/*
+		 * The log has not been checked for torn writes yet, so this
+		 * record cannot be trusted until its ophdr has been validated.
+		 * Only a valid unmount record makes the log clean. Anything else
+		 * is not an error here: the log is treated as dirty, and head
+		 * verification and recovery deal with the record.
+		 */
+		op_head = xlog_recover_validate_ophdr(log, offset,
+				offset + BBSIZE, true);
+		if (IS_ERR(op_head))
+			return 0;
+		if (op_head->oh_flags == XLOG_UNMOUNT_TRANS) {
 			/*
 			 * Set tail and last sync so that newly written log
 			 * records will point recovery to after the current
@@ -2583,9 +2595,11 @@ xlog_recovery_process_trans(
 
 	/* unexpected flag values */
 	case XLOG_UNMOUNT_TRANS:
-		/* just skip trans */
-		xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
-		freeit = true;
+		/* An unmount record never belongs to a checkpoint. */
+		xfs_warn(log->l_mp,
+			"%s: unmount record in transaction 0x%x",
+			__func__, trans->r_log_tid);
+		error = -EFSCORRUPTED;
 		break;
 	case XLOG_START_TRANS:
 	default:
@@ -2649,6 +2663,72 @@ xlog_recover_ophdr_to_trans(
 	return NULL;
 }
 
+/*
+ * Validate an unmount record. The unmount record is the only record written by
+ * the log itself rather than by a transaction, and the log item processing loop
+ * skips it, so it can only be validated here. It is a single fixed size region,
+ * written by the log with the XFS_LOG clientid, containing an unmount format
+ * structure with a known magic number and zeroed padding.
+ *
+ * The ophdr has already been validated, so oh_len is known to be within the
+ * record. The unmount format length was incorrectly written for a period of
+ * time as zero rather than the region length. Such a record has no payload to
+ * read, so accept it with a warning and stop, so that filesystems written by
+ * those kernels still recover. That warning is always emitted, as the record
+ * is accepted. @quiet suppresses only the warnings for a rejected record.
+ */
+STATIC int
+xlog_recover_validate_unmount_record(
+	struct xlog			*log,
+	struct xlog_op_header		*ohead,
+	bool				quiet)
+{
+	struct xfs_unmount_log_format	*ulf;
+	unsigned int			len = be32_to_cpu(ohead->oh_len);
+
+	if (ohead->oh_clientid != XFS_LOG) {
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: bad unmount clientid 0x%x",
+				__func__, ohead->oh_clientid);
+		return -EFSCORRUPTED;
+	}
+
+	if (len == 0) {
+		xfs_warn(log->l_mp,
+			"%s: zero length unmount record recovered.", __func__);
+		return 0;
+	}
+
+	if (len != sizeof(*ulf)) {
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: bad unmount record length 0x%x",
+				__func__, len);
+		return -EFSCORRUPTED;
+	}
+
+	/*
+	 * The magic number is written in host byte order, and a clean log can be
+	 * mounted on a host of either endianness, so accept both byte orders.
+	 */
+	ulf = (struct xfs_unmount_log_format *)(ohead + 1);
+	if (ulf->magic != XLOG_UNMOUNT_TYPE &&
+	    ulf->magic != swab16(XLOG_UNMOUNT_TYPE)) {
+		if (!quiet)
+			xfs_warn(log->l_mp,
+				"%s: bad unmount magic 0x%x, expected 0x%x",
+				__func__, ulf->magic, XLOG_UNMOUNT_TYPE);
+		return -EFSCORRUPTED;
+	}
+
+	if (ulf->pad1 != 0 || ulf->pad2 != 0) {
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: bad unmount padding", __func__);
+		return -EFSCORRUPTED;
+	}
+
+	return 0;
+}
+
 /*
  * Decode and validate an operation header from the journal. dp points at the
  * ophdr within the log record and end is the end of the record data. The ophdr
@@ -2656,16 +2736,21 @@ xlog_recover_ophdr_to_trans(
  * so decode the header in place and check its fields for known values and
  * obvious corruption here, in one place, before anything acts on them.
  *
+ * A caller probing for a record that may legitimately not be there sets @quiet
+ * to suppress the warnings for an ophdr that fails validation.
+ *
  * Returns the validated ophdr, or an ERR_PTR() on corruption.
  */
 STATIC struct xlog_op_header *
 xlog_recover_validate_ophdr(
 	struct xlog		*log,
 	char			*dp,
-	char			*end)
+	char			*end,
+	bool			quiet)
 {
 	struct xlog_op_header	*ohead;
 	unsigned int		len;
+	int			error;
 
 	/*
 	 * All log regions are 32 bit aligned, so the ophdr must be too. A
@@ -2673,13 +2758,15 @@ xlog_recover_validate_ophdr(
 	 * the on-disk layout.
 	 */
 	if (dp != PTR_ALIGN(dp, sizeof(uint32_t))) {
-		xfs_warn(log->l_mp, "%s: unaligned op header", __func__);
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: unaligned op header", __func__);
 		return ERR_PTR(-EFSCORRUPTED);
 	}
 
 	/* The ophdr itself must fit within the record. */
 	if (dp + sizeof(*ohead) > end) {
-		xfs_warn(log->l_mp, "%s: op header overrun", __func__);
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: op header overrun", __func__);
 		return ERR_PTR(-EFSCORRUPTED);
 	}
 
@@ -2689,7 +2776,9 @@ xlog_recover_validate_ophdr(
 
 	/* Check the ophdr contains all the data it is supposed to contain. */
 	if (dp + len > end) {
-		xfs_warn(log->l_mp, "%s: bad length 0x%x", __func__, len);
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: bad length 0x%x", __func__,
+				len);
 		return ERR_PTR(-EFSCORRUPTED);
 	}
 
@@ -2698,7 +2787,9 @@ xlog_recover_validate_ophdr(
 	 * misaligned length desyncs the walk over the ophdrs in the record.
 	 */
 	if (!IS_ALIGNED(len, sizeof(uint32_t))) {
-		xfs_warn(log->l_mp, "%s: unaligned length 0x%x", __func__, len);
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: unaligned length 0x%x",
+				__func__, len);
 		return ERR_PTR(-EFSCORRUPTED);
 	}
 
@@ -2711,22 +2802,26 @@ xlog_recover_validate_ophdr(
 	 */
 	BUILD_BUG_ON(XFS_XATTR_SIZE_MAX > XFS_MAX_BLOCKSIZE);
 	if (len > XFS_MAX_BLOCKSIZE) {
-		xfs_warn(log->l_mp, "%s: length 0x%x too large", __func__, len);
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: length 0x%x too large",
+				__func__, len);
 		return ERR_PTR(-EFSCORRUPTED);
 	}
 
 	/* Do we understand who wrote this op? */
 	if (ohead->oh_clientid != XFS_TRANSACTION &&
 	    ohead->oh_clientid != XFS_LOG) {
-		xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
-			__func__, ohead->oh_clientid);
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
+				__func__, ohead->oh_clientid);
 		return ERR_PTR(-EFSCORRUPTED);
 	}
 
 	/* The padding is always written as zero. */
 	if (ohead->oh_res2 != 0) {
-		xfs_warn(log->l_mp, "%s: bad padding 0x%x",
-			__func__, ohead->oh_res2);
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: bad padding 0x%x",
+				__func__, ohead->oh_res2);
 		return ERR_PTR(-EFSCORRUPTED);
 	}
 
@@ -2744,20 +2839,27 @@ xlog_recover_validate_ophdr(
 		 * no data of their own.
 		 */
 		if (len != 0) {
-			xfs_warn(log->l_mp, "%s: bad control record length 0x%x",
-				__func__, len);
+			if (!quiet)
+				xfs_warn(log->l_mp,
+					"%s: bad control record length 0x%x",
+					__func__, len);
 			return ERR_PTR(-EFSCORRUPTED);
 		}
 		break;
+	case XLOG_UNMOUNT_TRANS:
+		error = xlog_recover_validate_unmount_record(log, ohead, quiet);
+		if (error)
+			return ERR_PTR(error);
+		break;
 	case 0:
 	case XLOG_CONTINUE_TRANS:
 	case XLOG_WAS_CONT_TRANS | XLOG_CONTINUE_TRANS:
 	case XLOG_WAS_CONT_TRANS | XLOG_END_TRANS:
-	case XLOG_UNMOUNT_TRANS:
 		break;
 	default:
-		xfs_warn(log->l_mp, "%s: bad flags 0x%x",
-			__func__, ohead->oh_flags);
+		if (!quiet)
+			xfs_warn(log->l_mp, "%s: bad flags 0x%x",
+				__func__, ohead->oh_flags);
 		return ERR_PTR(-EFSCORRUPTED);
 	}
 
@@ -2779,7 +2881,7 @@ xlog_recover_process_ophdr(
 	unsigned int		len;
 	int			error;
 
-	ohead = xlog_recover_validate_ophdr(log, dp, end);
+	ohead = xlog_recover_validate_ophdr(log, dp, end, false);
 	if (IS_ERR(ohead))
 		return PTR_ERR(ohead);
 
-- 
2.55.0


  parent reply	other threads:[~2026-11-16 23:17 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 ` Dave Chinner [this message]
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 ` [PATCH 56/59] xfs: validate the whole buffer item " Dave Chinner
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-25-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