From nobody Wed Mar 19 23:34:31 2025 X-Original-To: dev-commits-src-main@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4ZJ4ml67jXz5qsym; Wed, 19 Mar 2025 23:34:31 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "R10" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4ZJ4ml4Py0z3kJZ; Wed, 19 Mar 2025 23:34:31 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1742427271; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=0R0ZwhjNH4MQ0sXjN/XYNK95I61yrDolMdkh0ndegBs=; b=hKz5LHIj9sTrovivVyhNf3qAzzgSM8MqoPqDNdvyh6pqqX4pL9qDhuIRBOrotQfjRRjI51 dSX5/EcEAo+xJopQxZtkyf7Am8PcMokyKGHQjgW+lPo779e1PTI26tJTwFCosITObeuQtM 42QVhjX2TqcbVvbIyzATL0jQrBVfWT2wpp5EnCWBB6CeUYdxHl2yMF8jgybbDgsMqS+F9m 4nw33JaNVY/8mMhVDU1tawyq+GDbmzSkZMcAJMqpIZ0fJ+q1MgZDyir85eWQoeNXUyGzrW HNghuiYmAiNK0LSvOY1PrX8X7zM4b36jC+BzIDh4M3ESW6mgxrrvnenbhP9/sg== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1742427271; a=rsa-sha256; cv=none; b=UgqIkqG7QDS2iV1xMieTJw7aqiPi5hwFn42tvhllD4fDMe7Nm5vo9gUigORl/Oo3r8eMiD V53wgiviD3HpRZoj01QAGJrg4uBcu4XC2wb2QxtedqBs6hUsFCevR3cBeRnIPxk+LBvR6m aDqUlkoFa9QwaO6JAduUEdHDDUqQJ/AZHsp8XCz+8ZTDZUN+q5pfV/WTv7bpk+V+wTB8Wx 7TmfGGAvuKU/iKGl92z8aIaoOvXxbyAc2uZiRd2bBb8Zj5xZWUf+mqphz764j8BCaEmy0P dtVynkfk+2q7j4U45t5ka8H6vIR1DYhsy3hHQPRpSjqvau/5JM4dBEcHJLvVOA== ARC-Authentication-Results: i=1; mx1.freebsd.org; none ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1742427271; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=0R0ZwhjNH4MQ0sXjN/XYNK95I61yrDolMdkh0ndegBs=; b=kvvjTPeAta5jnzPTG9pnUX1i3hp02xA6F23TzIIEcHGwaOj4MK8b4dqrirR3J2cSuXfpaJ J8CIl7CsShyH6FEm9b2BtVNTA+ksEwycbA/B6VzbYuhvwxyxvcC9ZTxmD4kAsXTGgM335/ dZCJULvlbC7I70OWKS+k1FmuX9WRWHAsYZkcHLz9rj4UceLjFJopMAIH4f1CkkKUaXu9zA b4MaXhjWhzzWYehmLk9f0su1VkaV0Up3M2kF3grI27AQoqsMbHSeLieqHZnNhccLOyNrNT dnUgZbsc7X0F3xcohJqZ0+mS6DSFhKnrBZn6a2u+0yVySBWPvVf/wmSPR9aPtw== Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 4ZJ4ml31Cxzgnd; Wed, 19 Mar 2025 23:34:31 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org ([127.0.1.44]) by gitrepo.freebsd.org (8.18.1/8.18.1) with ESMTP id 52JNYVT2074082; Wed, 19 Mar 2025 23:34:31 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.18.1/8.18.1/Submit) id 52JNYV6O074079; Wed, 19 Mar 2025 23:34:31 GMT (envelope-from git) Date: Wed, 19 Mar 2025 23:34:31 GMT Message-Id: <202503192334.52JNYV6O074079@gitrepo.freebsd.org> To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org From: Kirk McKusick Subject: git: c2cd605e8c8a - main - Get consistent updates for UFS superblocks. List-Id: Commit messages for the main branch of the src repository List-Archive: https://lists.freebsd.org/archives/dev-commits-src-main List-Help: List-Post: List-Subscribe: List-Unsubscribe: X-BeenThere: dev-commits-src-main@freebsd.org Sender: owner-dev-commits-src-main@FreeBSD.org MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: mckusick X-Git-Repository: src X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: c2cd605e8c8a15e545dfd3e50aef2f660d460b30 Auto-Submitted: auto-generated The branch main has been updated by mckusick: URL: https://cgit.FreeBSD.org/src/commit/?id=c2cd605e8c8a15e545dfd3e50aef2f660d460b30 commit c2cd605e8c8a15e545dfd3e50aef2f660d460b30 Author: Kirk McKusick AuthorDate: 2025-03-19 23:32:39 +0000 Commit: Kirk McKusick CommitDate: 2025-03-19 23:33:59 +0000 Get consistent updates for UFS superblocks. Superblocks are written by Freebsd clients using the ffs_sbput() routine (exported from the kernel in sys/ufs/ffs/ffs_subr.c). These clients include the kernel, some geom modules, and system utilities using libufs. Currently backward compatible updates of UFS superblocks are done only when the kernel writes them. These updates should be done whenever any call to ffs_sbput() is done. This commit moves these UFS superblock compatibility updates from the kernel-specific superblock update to ffs_sbput() so that all clients make these compatibility updates when they write superblocks. Reviewed-by: kib Tested-by: Peter Holm MFC-after: 1 week Differential Revision: https://reviews.freebsd.org/D49276 Sponsored-by: Netflix --- sys/ufs/ffs/ffs_subr.c | 62 +++++++++++++++++++++++++++++++++--------------- sys/ufs/ffs/ffs_vfsops.c | 42 +++++++++++++------------------- 2 files changed, 59 insertions(+), 45 deletions(-) diff --git a/sys/ufs/ffs/ffs_subr.c b/sys/ufs/ffs/ffs_subr.c index c293cbbcbfb0..67c423d3127c 100644 --- a/sys/ufs/ffs/ffs_subr.c +++ b/sys/ufs/ffs/ffs_subr.c @@ -384,16 +384,35 @@ void ffs_oldfscompat_write(struct fs *fs) { - /* - * Copy back UFS2 updated fields that UFS1 inspects. - */ - if (fs->fs_magic == FS_UFS1_MAGIC) { + switch (fs->fs_magic) { + case FS_UFS1_MAGIC: + if (fs->fs_sblockloc != SBLOCK_UFS1 && + (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) { + printf( + "WARNING: %s: correcting fs_sblockloc from %jd to %d\n", + fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1); + fs->fs_sblockloc = SBLOCK_UFS1; + } + /* + * Copy back UFS2 updated fields that UFS1 inspects. + */ fs->fs_old_time = fs->fs_time; fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir; fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree; fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree; fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree; - fs->fs_maxfilesize = fs->fs_save_maxfilesize; + if (fs->fs_save_maxfilesize != 0) + fs->fs_maxfilesize = fs->fs_save_maxfilesize; + break; + case FS_UFS2_MAGIC: + if (fs->fs_sblockloc != SBLOCK_UFS2 && + (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) { + printf( + "WARNING: %s: correcting fs_sblockloc from %jd to %d\n", + fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2); + fs->fs_sblockloc = SBLOCK_UFS2; + } + break; } } @@ -931,6 +950,7 @@ int ffs_sbput(void *devfd, struct fs *fs, off_t loc, int (*writefunc)(void *devfd, off_t loc, void *buf, int size)) { + struct fs_summary_info *fs_si; int i, error, blks, size; uint8_t *space; @@ -953,23 +973,27 @@ ffs_sbput(void *devfd, struct fs *fs, off_t loc, } } fs->fs_fmod = 0; -#ifndef _KERNEL - { - struct fs_summary_info *fs_si; - - fs->fs_time = time(NULL); - /* Clear the pointers for the duration of writing. */ - fs_si = fs->fs_si; - fs->fs_si = NULL; - fs->fs_ckhash = ffs_calc_sbhash(fs); - error = (*writefunc)(devfd, loc, fs, fs->fs_sbsize); - fs->fs_si = fs_si; - } -#else /* _KERNEL */ + ffs_oldfscompat_write(fs); +#ifdef _KERNEL fs->fs_time = time_second; +#else /* User Code */ + fs->fs_time = time(NULL); +#endif + /* Clear the pointers for the duration of writing. */ + fs_si = fs->fs_si; + fs->fs_si = NULL; fs->fs_ckhash = ffs_calc_sbhash(fs); error = (*writefunc)(devfd, loc, fs, fs->fs_sbsize); -#endif /* _KERNEL */ + /* + * A negative error code is returned when a copy of the + * superblock has been made which is discarded when the I/O + * is done. So the fs_si field does not and indeed cannot be + * restored after the write is done. Convert the error code + * back to its usual positive value when returning it. + */ + if (error < 0) + return (-error - 1); + fs->fs_si = fs_si; return (error); } diff --git a/sys/ufs/ffs/ffs_vfsops.c b/sys/ufs/ffs/ffs_vfsops.c index 498ef61d7cf1..891e490a7031 100644 --- a/sys/ufs/ffs/ffs_vfsops.c +++ b/sys/ufs/ffs/ffs_vfsops.c @@ -2032,9 +2032,15 @@ ffs_sbupdate(struct ufsmount *ump, int waitfor, int suspended) panic("ffs_sbupdate: write read-only filesystem"); /* * We use the superblock's buf to serialize calls to ffs_sbupdate(). + * Copy superblock to this buffer and have it written out. */ sbbp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc), (int)fs->fs_sbsize, 0, 0, 0); + UFS_LOCK(ump); + fs->fs_fmod = 0; + bcopy((caddr_t)fs, sbbp->b_data, (uint64_t)fs->fs_sbsize); + UFS_UNLOCK(ump); + fs = (struct fs *)sbbp->b_data; /* * Initialize info needed for write function. */ @@ -2060,7 +2066,8 @@ ffs_use_bwrite(void *devfd, off_t loc, void *buf, int size) devfdp = devfd; ump = devfdp->ump; - fs = ump->um_fs; + bp = devfdp->sbbp; + fs = (struct fs *)bp->b_data; /* * Writing the superblock summary information. */ @@ -2077,44 +2084,27 @@ ffs_use_bwrite(void *devfd, off_t loc, void *buf, int size) } /* * Writing the superblock itself. We need to do special checks for it. + * A negative error code is returned to indicate that a copy of the + * superblock has been made and that the copy is discarded when the + * I/O is done. So the the caller should not attempt to restore the + * fs_si field after the write is done. The caller will convert the + * error code back to its usual positive value when returning it. */ - bp = devfdp->sbbp; if (ffs_fsfail_cleanup(ump, devfdp->error)) devfdp->error = 0; if (devfdp->error != 0) { brelse(bp); - return (devfdp->error); - } - if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_sblockloc != SBLOCK_UFS1 && - (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) { - printf("WARNING: %s: correcting fs_sblockloc from %jd to %d\n", - fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1); - fs->fs_sblockloc = SBLOCK_UFS1; - } - if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_sblockloc != SBLOCK_UFS2 && - (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) { - printf("WARNING: %s: correcting fs_sblockloc from %jd to %d\n", - fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2); - fs->fs_sblockloc = SBLOCK_UFS2; + return (-devfdp->error - 1); } if (MOUNTEDSOFTDEP(ump->um_mountp)) - softdep_setup_sbupdate(ump, (struct fs *)bp->b_data, bp); - UFS_LOCK(ump); - bcopy((caddr_t)fs, bp->b_data, (uint64_t)fs->fs_sbsize); - UFS_UNLOCK(ump); - fs = (struct fs *)bp->b_data; - fs->fs_fmod = 0; - ffs_oldfscompat_write(fs); - fs->fs_si = NULL; - /* Recalculate the superblock hash */ - fs->fs_ckhash = ffs_calc_sbhash(fs); + softdep_setup_sbupdate(ump, fs, bp); if (devfdp->suspended) bp->b_flags |= B_VALIDSUSPWRT; if (devfdp->waitfor != MNT_WAIT) bawrite(bp); else if ((error = bwrite(bp)) != 0) devfdp->error = error; - return (devfdp->error); + return (-devfdp->error - 1); } static int