Defer the January 19, 2038 date limit in UFS1 filesystems to February 7, 2106

Standardize the definition of a UFS dinode

Differential Revision: https://reviews.freebsd.org/D48472

(cherry picked from commit 1111a44301da39d7b7459c784230e1405e8980f8)
(cherry picked from commit aa90fbed151de512ab6e59f75df009533a15751f)
(cherry picked from commit 256389eaf158acaf67f0530764be8af68edee78c)
(cherry picked from commit 6cd973d903c8f214d84daf91eb75047631bf1618)
(cherry picked from commit e1ebda4458bbaf7d85fb803e20f3afc5441f24d9)

18 files changed, 192 insertions, 108 deletions

diff --git a/lib/libufs/inode.c b/lib/libufs/inode.c
index fe34fd45b815..efaaa4e5e3da 100644
--- a/lib/libufs/inode.c
+++ b/lib/libufs/inode.c
@@ -44,6 +44,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 
 #include <libufs.h>
@@ -54,6 +55,7 @@ getinode(struct uufsd *disk, union dinodep *dp, ino_t inum)
 	ino_t min, max;
 	caddr_t inoblock;
 	struct fs *fs;
+	struct timespec now;
 
 	ERROR(disk, NULL);
 
@@ -74,6 +76,10 @@ getinode(struct uufsd *disk, union dinodep *dp, ino_t inum)
 		}
 		disk->d_inoblock = inoblock;
 	}
+	if (clock_gettime(CLOCK_REALTIME_FAST, &now) != 0) {
+		ERROR(disk, "cannot get current time of day");
+		return (-1);
+	}
 	if (inum >= min && inum < max)
 		goto gotit;
 	bread(disk, fsbtodb(fs, ino_to_fsba(fs, inum)), inoblock,
@@ -83,6 +89,8 @@ getinode(struct uufsd *disk, union dinodep *dp, ino_t inum)
 gotit:	switch (disk->d_ufs) {
 	case 1:
 		disk->d_dp.dp1 = &((struct ufs1_dinode *)inoblock)[inum - min];
+		if (ffs_oldfscompat_inode_read(fs, disk->d_dp, now.tv_sec))
+			putinode(disk);
 		if (dp != NULL)
 			*dp = disk->d_dp;
 		return (0);
@@ -90,8 +98,12 @@ gotit:	switch (disk->d_ufs) {
 		disk->d_dp.dp2 = &((struct ufs2_dinode *)inoblock)[inum - min];
 		if (dp != NULL)
 			*dp = disk->d_dp;
-		if (ffs_verify_dinode_ckhash(fs, disk->d_dp.dp2) == 0)
+		if (ffs_verify_dinode_ckhash(fs, disk->d_dp.dp2) == 0) {
+			if (ffs_oldfscompat_inode_read(fs, disk->d_dp,
+			    now.tv_sec))
+				putinode(disk);
 			return (0);
+		}
 		ERROR(disk, "check-hash failed for inode read from disk");
 		return (-1);
 	default:
diff --git a/lib/libufs/libufs.h b/lib/libufs/libufs.h
index 4c6242e9daef..43936c71b8ad 100644
--- a/lib/libufs/libufs.h
+++ b/lib/libufs/libufs.h
@@ -29,14 +29,7 @@
 
 #ifndef	__LIBUFS_H__
 #define	__LIBUFS_H__
-
-/*
- * libufs structures.
- */
-union dinodep {
-	struct ufs1_dinode *dp1;
-	struct ufs2_dinode *dp2;
-};
+#include <stdbool.h>
 
 /*
  * userland ufs disk.
@@ -109,6 +102,7 @@ void	ffs_clusteracct(struct fs *, struct cg *, ufs1_daddr_t, int);
 void	ffs_fragacct(struct fs *, int, int32_t [], int);
 int	ffs_isblock(struct fs *, u_char *, ufs1_daddr_t);
 int	ffs_isfreeblock(struct fs *, u_char *, ufs1_daddr_t);
+bool	ffs_oldfscompat_inode_read(struct fs *, union dinodep, time_t);
 int	ffs_sbsearch(void *, struct fs **, int, char *,
 	    int (*)(void *, off_t, void **, int));
 void	ffs_setblock(struct fs *, u_char *, ufs1_daddr_t);
diff --git a/sbin/dump/traverse.c b/sbin/dump/traverse.c
index 281cffcdf6f2..e18c2ac86bf7 100644
--- a/sbin/dump/traverse.c
+++ b/sbin/dump/traverse.c
@@ -57,10 +57,6 @@ static char sccsid[] = "@(#)traverse.c	8.7 (Berkeley) 6/15/95";
 
 #include "dump.h"
 
-union dinode {
-	struct ufs1_dinode dp1;
-	struct ufs2_dinode dp2;
-};
 #define	DIP(dp, field) \
 	((sblock->fs_magic == FS_UFS1_MAGIC) ? \
 	(dp)->dp1.field : (dp)->dp2.field)
diff --git a/sbin/fsck_ffs/fsck.h b/sbin/fsck_ffs/fsck.h
index 3b795783f39c..2e15dad00d12 100644
--- a/sbin/fsck_ffs/fsck.h
+++ b/sbin/fsck_ffs/fsck.h
@@ -76,10 +76,6 @@
 #define	INOBUFSIZE	64*1024	/* size of buffer to read inodes in pass1 */
 #define	ZEROBUFSIZE	(dev_bsize * 128) /* size of zero buffer used by -Z */
 
-union dinode {
-	struct ufs1_dinode dp1;
-	struct ufs2_dinode dp2;
-};
 #define	DIP(dp, field) \
 	((sblock.fs_magic == FS_UFS1_MAGIC) ? \
 	(dp)->dp1.field : (dp)->dp2.field)
diff --git a/sbin/fsck_ffs/inode.c b/sbin/fsck_ffs/inode.c
index 3db8a5e5c23d..f7b9b941fdb4 100644
--- a/sbin/fsck_ffs/inode.c
+++ b/sbin/fsck_ffs/inode.c
@@ -53,6 +53,7 @@ static const char sccsid[] = "@(#)inode.c	8.8 (Berkeley) 4/28/95";
 #include "fsck.h"
 
 struct bufarea *icachebp;	/* inode cache buffer */
+static time_t now;		/* current time of day */
 
 static int iblock(struct inodesc *, off_t isize, int type);
 static ufs2_daddr_t indir_blkatoff(ufs2_daddr_t, ino_t, ufs_lbn_t, ufs_lbn_t,
@@ -436,6 +437,7 @@ void
 ginode(ino_t inumber, struct inode *ip)
 {
 	ufs2_daddr_t iblk;
+	union dinodep dpp;
 	struct ufs2_dinode *dp;
 
 	if (inumber < UFS_ROOTINO || inumber >= maxino)
@@ -473,11 +475,14 @@ ginode(ino_t inumber, struct inode *ip)
 	if (sblock.fs_magic == FS_UFS1_MAGIC) {
 		ip->i_dp = (union dinode *)
 		    &ip->i_bp->b_un.b_dinode1[inumber - ip->i_bp->b_index];
+		dpp.dp1 = (struct ufs1_dinode *)ip->i_dp;
+		if (ffs_oldfscompat_inode_read(&sblock, dpp, now))
+			inodirty(ip);
 		return;
 	}
 	ip->i_dp = (union dinode *)
 	    &ip->i_bp->b_un.b_dinode2[inumber - ip->i_bp->b_index];
-	dp = (struct ufs2_dinode *)ip->i_dp;
+	dpp.dp2 = dp = (struct ufs2_dinode *)ip->i_dp;
 	/* Do not check hash of inodes being created */
 	if (dp->di_mode != 0 && ffs_verify_dinode_ckhash(&sblock, dp)) {
 		pwarn("INODE CHECK-HASH FAILED");
@@ -489,6 +494,8 @@ ginode(ino_t inumber, struct inode *ip)
 			inodirty(ip);
 		}
 	}
+	if (ffs_oldfscompat_inode_read(&sblock, dpp, now))
+		inodirty(ip);
 }
 
 /*
@@ -527,6 +534,7 @@ getnextinode(ino_t inumber, int rebuiltcg)
 	mode_t mode;
 	ufs2_daddr_t ndb, blk;
 	union dinode *dp;
+	union dinodep dpp;
 	struct inode ip;
 	static caddr_t nextinop;
 
@@ -557,10 +565,13 @@ getnextinode(ino_t inumber, int rebuiltcg)
 		nextinop = inobuf.b_un.b_buf;
 	}
 	dp = (union dinode *)nextinop;
-	if (sblock.fs_magic == FS_UFS1_MAGIC)
+	if (sblock.fs_magic == FS_UFS1_MAGIC) {
 		nextinop += sizeof(struct ufs1_dinode);
-	else
+		dpp.dp1 = (struct ufs1_dinode *)dp;
+	} else {
 		nextinop += sizeof(struct ufs2_dinode);
+		dpp.dp2 = (struct ufs2_dinode *)dp;
+	}
 	if ((ckhashadd & CK_INODE) != 0) {
 		ffs_update_dinode_ckhash(&sblock, (struct ufs2_dinode *)dp);
 		dirty(&inobuf);
@@ -579,6 +590,8 @@ getnextinode(ino_t inumber, int rebuiltcg)
 			dirty(&inobuf);
 		}
 	}
+	if (ffs_oldfscompat_inode_read(&sblock, dpp, now))
+		dirty(&inobuf);
 	if (rebuiltcg && (char *)dp == inobuf.b_un.b_buf) {
 		/*
 		 * Try to determine if we have reached the end of the
@@ -632,8 +645,19 @@ getnextinode(ino_t inumber, int rebuiltcg)
 void
 setinodebuf(int cg, ino_t inosused)
 {
+	struct timespec time;
 	ino_t inum;
 
+	/*
+	 * Get the current value of the present time.
+	 * This will happen before each cylinder group is scanned.
+	 * If for some reason getting the time fails, we will use
+	 * the last time that the superblock was updated.
+	 */
+	if (clock_gettime(CLOCK_REALTIME_FAST, &time) == 0)
+		now = time.tv_sec;
+	else
+		now = sblock.fs_time;
 	inum = cg * sblock.fs_ipg;
 	lastvalidinum = inum + inosused - 1;
 	nextinum = inum;
diff --git a/sbin/newfs/mkfs.c b/sbin/newfs/mkfs.c
index b0d178de984e..0101c8bdf893 100644
--- a/sbin/newfs/mkfs.c
+++ b/sbin/newfs/mkfs.c
@@ -95,10 +95,6 @@ static struct	csum *fscs;
 #define	sblock	disk.d_fs
 #define	acg	disk.d_cg
 
-union dinode {
-	struct ufs1_dinode dp1;
-	struct ufs2_dinode dp2;
-};
 #define DIP(dp, field) \
 	((sblock.fs_magic == FS_UFS1_MAGIC) ? \
 	(dp)->dp1.field : (dp)->dp2.field)
diff --git a/sbin/quotacheck/quotacheck.c b/sbin/quotacheck/quotacheck.c
index 3f608c103b1d..4837dd4dba04 100644
--- a/sbin/quotacheck/quotacheck.c
+++ b/sbin/quotacheck/quotacheck.c
@@ -89,10 +89,6 @@ union {
 long dev_bsize = 1;
 ino_t maxino;
 
-union dinode {
-	struct ufs1_dinode dp1;
-	struct ufs2_dinode dp2;
-};
 #define	DIP(dp, field) \
 	((sblock.fs_magic == FS_UFS1_MAGIC) ? \
 	(dp)->dp1.field : (dp)->dp2.field)
diff --git a/share/man/man7/ffs.7 b/share/man/man7/ffs.7
index 7d003443f32a..a1a319ae47dd 100644
--- a/share/man/man7/ffs.7
+++ b/share/man/man7/ffs.7
@@ -28,7 +28,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.Dd May 3, 2020
+.Dd January 19, 2025
 .Dt FFS 7
 .Os
 .Sh NAME
@@ -285,6 +285,10 @@ upon reallocating file system blocks to be contiguous.
 Enable support for the rearrangement of blocks
 to be contiguous.
 .Pq Default: 1 .
+.It Va vfs.ffs.prttimechgs
+Print a console message when timestamps for UFS1 filesystems are found
+to be in the future and are changed to be the present time.
+.Pq Default: 0 .
 .El
 .Sh HISTORY
 The
diff --git a/stand/libsa/ufs.c b/stand/libsa/ufs.c
index 2c3b3764bd74..e1d540ed2321 100644
--- a/stand/libsa/ufs.c
+++ b/stand/libsa/ufs.c
@@ -110,10 +110,7 @@ struct fs_ops ufs_fsops = {
 struct file {
 	off_t		f_seekp;	/* seek pointer */
 	struct fs	*f_fs;		/* pointer to super-block */
-	union dinode {
-		struct ufs1_dinode di1;
-		struct ufs2_dinode di2;
-	}		f_di;		/* copy of on-disk inode */
+	union dinode	f_dp;		/* copy of on-disk inode */
 	int		f_nindir[UFS_NIADDR];
 					/* number of blocks mapped by
 					   indirect block at level i */
@@ -129,7 +126,7 @@ struct file {
 };
 #define DIP(fp, field) \
 	((fp)->f_fs->fs_magic == FS_UFS1_MAGIC ? \
-	(fp)->f_di.di1.field : (fp)->f_di.di2.field)
+	(fp)->f_dp.dp1.field : (fp)->f_dp.dp2.field)
 
 typedef struct ufs_mnt {
 	char			*um_dev;
@@ -185,10 +182,10 @@ read_inode(ino_t inumber, struct open_file *f)
 	}
 
 	if (fp->f_fs->fs_magic == FS_UFS1_MAGIC)
-		fp->f_di.di1 = ((struct ufs1_dinode *)buf)
+		fp->f_dp.dp1 = ((struct ufs1_dinode *)buf)
 		    [ino_to_fsbo(fs, inumber)];
 	else
-		fp->f_di.di2 = ((struct ufs2_dinode *)buf)
+		fp->f_dp.dp2 = ((struct ufs2_dinode *)buf)
 		    [ino_to_fsbo(fs, inumber)];
 
 	/*
diff --git a/sys/ufs/ffs/ffs_alloc.c b/sys/ufs/ffs/ffs_alloc.c
index b586ab8e126a..d4f733553071 100644
--- a/sys/ufs/ffs/ffs_alloc.c
+++ b/sys/ufs/ffs/ffs_alloc.c
@@ -491,8 +491,7 @@ nospace:
  * allocation will be used.
  */
 
-SYSCTL_NODE(_vfs, OID_AUTO, ffs, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
-    "FFS filesystem");
+SYSCTL_DECL(_vfs_ffs);
 
 static int doasyncfree = 1;
 SYSCTL_INT(_vfs_ffs, OID_AUTO, doasyncfree, CTLFLAG_RW, &doasyncfree, 0,
diff --git a/sys/ufs/ffs/ffs_extern.h b/sys/ufs/ffs/ffs_extern.h
index 56e2fdd6ce51..fc55267eca0c 100644
--- a/sys/ufs/ffs/ffs_extern.h
+++ b/sys/ufs/ffs/ffs_extern.h
@@ -85,6 +85,7 @@ int	ffs_inotovp(struct mount *, ino_t, uint64_t, int, struct vnode **,
 int	ffs_isblock(struct fs *, uint8_t *, ufs1_daddr_t);
 int	ffs_isfreeblock(struct fs *, uint8_t *, ufs1_daddr_t);
 void	ffs_oldfscompat_write(struct fs *);
+bool	ffs_oldfscompat_inode_read(struct fs *, union dinodep, time_t);
 int	ffs_own_mount(const struct mount *mp);
 int	ffs_sbsearch(void *, struct fs **, int, struct malloc_type *,
 	    int (*)(void *, off_t, void **, int));
diff --git a/sys/ufs/ffs/ffs_subr.c b/sys/ufs/ffs/ffs_subr.c
index 1792e1628a48..c0221c8ee2da 100644
--- a/sys/ufs/ffs/ffs_subr.c
+++ b/sys/ufs/ffs/ffs_subr.c
@@ -37,6 +37,7 @@
 #include <sys/limits.h>
 
 #ifndef _KERNEL
+#include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -62,6 +63,7 @@ struct malloc_type;
 #include <sys/bio.h>
 #include <sys/buf.h>
 #include <sys/ucred.h>
+#include <sys/sysctl.h>
 
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>
@@ -399,6 +401,65 @@ ffs_oldfscompat_write(struct fs *fs)
 }
 
 /*
+ * Sanity checks for loading old filesystem inodes.
+ *
+ * XXX - Parts get retired eventually.
+ * Unfortunately new bits get added.
+ */
+static int prttimechgs = 0;
+#ifdef _KERNEL
+SYSCTL_NODE(_vfs, OID_AUTO, ffs, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
+    "FFS filesystem");
+
+SYSCTL_INT(_vfs_ffs, OID_AUTO, prttimechgs, CTLFLAG_RWTUN, &prttimechgs, 0,
+	"print UFS1 time changes made to inodes");
+#endif /* _KERNEL */
+bool
+ffs_oldfscompat_inode_read(struct fs *fs, union dinodep dp, time_t now)
+{
+	bool change;
+
+	change = false;
+	switch (fs->fs_magic) {
+	case FS_UFS2_MAGIC:
+		/* No changes for now */
+		break;
+
+	case FS_UFS1_MAGIC:
+		/*
+		 * With the change to unsigned time values in UFS1, times set
+		 * before Jan 1, 1970 will appear to be in the future. Check
+		 * for future times and set them to be the current time.
+		 */
+		if (dp.dp1->di_ctime > now) {
+			if (prttimechgs)
+				printf("ctime %ud changed to %ld\n",
+				    dp.dp1->di_ctime, (long)now);
+			dp.dp1->di_ctime = now;
+			change = true;
+		}
+		if (dp.dp1->di_mtime > now) {
+			if (prttimechgs)
+				printf("mtime %ud changed to %ld\n",
+				    dp.dp1->di_mtime, (long)now);
+			dp.dp1->di_mtime = now;
+			dp.dp1->di_ctime = now;
+			change = true;
+		}
+		if (dp.dp1->di_atime > now) {
+			if (prttimechgs)
+				printf("atime %ud changed to %ld\n",
+				    dp.dp1->di_atime, (long)now);
+			dp.dp1->di_atime = now;
+			dp.dp1->di_ctime = now;
+			change = true;
+		}
+		break;
+	}
+	return (change);
+}
+
+/*
  * Verify the filesystem values.
  */
 #define ILOG2(num)	(fls(num) - 1)
diff --git a/sys/ufs/ffs/ffs_vfsops.c b/sys/ufs/ffs/ffs_vfsops.c
index be24ba1e733a..eadd5815eaf7 100644
--- a/sys/ufs/ffs/ffs_vfsops.c
+++ b/sys/ufs/ffs/ffs_vfsops.c
@@ -205,6 +205,9 @@ ffs_load_inode(struct buf *bp, struct inode *ip, struct fs *fs, ino_t ino)
 		ip->i_gen = dip1->di_gen;
 		ip->i_uid = dip1->di_uid;
 		ip->i_gid = dip1->di_gid;
+		if (ffs_oldfscompat_inode_read(fs, ip->i_dp, time_second) &&
+		    fs->fs_ronly == 0)
+			UFS_INODE_SET_FLAG(ip, IN_MODIFIED);
 		return (0);
 	}
 	dip2 = ((struct ufs2_dinode *)bp->b_data + ino_to_fsbo(fs, ino));
@@ -224,6 +227,9 @@ ffs_load_inode(struct buf *bp, struct inode *ip, struct fs *fs, ino_t ino)
 	ip->i_gen = dip2->di_gen;
 	ip->i_uid = dip2->di_uid;
 	ip->i_gid = dip2->di_gid;
+	if (ffs_oldfscompat_inode_read(fs, ip->i_dp, time_second) &&
+	    fs->fs_ronly == 0)
+		UFS_INODE_SET_FLAG(ip, IN_MODIFIED);
 	return (0);
 }
 
diff --git a/sys/ufs/ufs/dinode.h b/sys/ufs/ufs/dinode.h
index b4117a99c262..49f7fd91aa26 100644
--- a/sys/ufs/ufs/dinode.h
+++ b/sys/ufs/ufs/dinode.h
@@ -113,12 +113,13 @@ typedef int64_t ufs_time_t;
 #define	IFWHT		0160000		/* Whiteout. */
 
 /*
- * A dinode contains all the meta-data associated with a UFS2 file.
- * This structure defines the on-disk format of a dinode. Since
+ * Each UFS filesystem version defines the on-disk format of its dinode.
+ *
+ * A UFS2 dinode contains all the meta-data associated with a UFS2 file.
+ * This structure defines the on-disk format of a UFS2 dinode. Since
  * this structure describes an on-disk structure, all its fields
  * are defined by types with precise widths.
  */
-
 #define	UFS_NXADDR	2		/* External addresses in inode. */
 #define	UFS_NDADDR	12		/* Direct addresses in inode. */
 #define	UFS_NIADDR	3		/* Indirect addresses in inode. */
@@ -186,11 +187,11 @@ struct ufs1_dinode {
 		uint32_t di_dirdepth;	/*   4: IFDIR: depth from root dir */
 	};
 	uint64_t	di_size;	/*   8: File byte count. */
-	int32_t		di_atime;	/*  16: Last access time. */
+	uint32_t	di_atime;	/*  16: Last access time. */
 	int32_t		di_atimensec;	/*  20: Last access time. */
-	int32_t		di_mtime;	/*  24: Last modified time. */
+	uint32_t	di_mtime;	/*  24: Last modified time. */
 	int32_t		di_mtimensec;	/*  28: Last modified time. */
-	int32_t		di_ctime;	/*  32: Last inode change time. */
+	uint32_t	di_ctime;	/*  32: Last inode change time. */
 	int32_t		di_ctimensec;	/*  36: Last inode change time. */
 	union {
 		struct {
@@ -212,4 +213,17 @@ struct ufs1_dinode {
 
 #define	UFS_LINK_MAX	65500	/* leave a few spare for special values */
 
+/*
+ * These structures hold or reference an on-disk dinode.
+ */
+union dinode {
+	struct ufs1_dinode dp1;
+	struct ufs2_dinode dp2;
+};
+
+union dinodep {
+	struct ufs1_dinode *dp1;
+	struct ufs2_dinode *dp2;
+};
+
 #endif /* _UFS_UFS_DINODE_H_ */
diff --git a/sys/ufs/ufs/inode.h b/sys/ufs/ufs/inode.h
index dc7e2560d6e3..607f19c5b946 100644
--- a/sys/ufs/ufs/inode.h
+++ b/sys/ufs/ufs/inode.h
@@ -90,10 +90,7 @@ struct inode {
 	/*
 	 * The real copy of the on-disk inode.
 	 */
-	union {
-		struct ufs1_dinode *din1;	/* UFS1 on-disk dinode. */
-		struct ufs2_dinode *din2;	/* UFS2 on-disk dinode. */
-	} dinode_u;
+	union dinodep i_dp;	/* On-disk dinode */
 
 	ino_t	  i_number;	/* The identity of the inode. */
 	uint32_t  i_flag;	/* flags, see below */
@@ -206,8 +203,8 @@ struct inode {
 
 #define	i_dirhash i_un.dirhash
 #define	i_snapblklist i_un.snapblklist
-#define	i_din1 dinode_u.din1
-#define	i_din2 dinode_u.din2
+#define	i_din1 i_dp.dp1
+#define	i_din2 i_dp.dp2
 
 #define	ITOUMP(ip)	((ip)->i_ump)
 #define	ITODEV(ip)	(ITOUMP(ip)->um_dev)
diff --git a/usr.sbin/makefs/ffs.c b/usr.sbin/makefs/ffs.c
index 97c1d6ccefda..8c4b790f53b0 100644
--- a/usr.sbin/makefs/ffs.c
+++ b/usr.sbin/makefs/ffs.c
@@ -108,7 +108,7 @@
 #undef DIP
 #define DIP(dp, field) \
 	((ffs_opts->version == 1) ? \
-	(dp)->ffs1_din.di_##field : (dp)->ffs2_din.di_##field)
+	(dp)->dp1.di_##field : (dp)->dp2.di_##field)
 
 /*
  * Various file system defaults (cribbed from newfs(8)).
@@ -855,10 +855,10 @@ ffs_populate_dir(const char *dir, fsnode *root, fsinfo_t *fsopts)
 
 				/* build on-disk inode */
 		if (ffs_opts->version == 1)
-			membuf = ffs_build_dinode1(&din.ffs1_din, &dirbuf, cur,
+			membuf = ffs_build_dinode1(&din.dp1, &dirbuf, cur,
 			    root, fsopts);
 		else
-			membuf = ffs_build_dinode2(&din.ffs2_din, &dirbuf, cur,
+			membuf = ffs_build_dinode2(&din.dp2, &dirbuf, cur,
 			    root, fsopts);
 
 		if (debug & DEBUG_FS_POPULATE_NODE) {
@@ -944,11 +944,11 @@ ffs_write_file(union dinode *din, uint32_t ino, void *buf, fsinfo_t *fsopts)
 	in.i_number = ino;
 	in.i_size = DIP(din, size);
 	if (ffs_opts->version == 1)
-		memcpy(&in.i_din.ffs1_din, &din->ffs1_din,
-		    sizeof(in.i_din.ffs1_din));
+		memcpy(&in.i_din.dp1, &din->dp1,
+		    sizeof(in.i_din.dp1));
 	else
-		memcpy(&in.i_din.ffs2_din, &din->ffs2_din,
-		    sizeof(in.i_din.ffs2_din));
+		memcpy(&in.i_din.dp2, &din->dp2,
+		    sizeof(in.i_din.dp2));
 
 	if (DIP(din, size) == 0)
 		goto write_inode_and_leave;		/* mmm, cheating */
@@ -1178,16 +1178,16 @@ ffs_write_inode(union dinode *dp, uint32_t ino, const fsinfo_t *fsopts)
 	ffs_rdfs(d, fs->fs_bsize, buf, fsopts);
 	if (fsopts->needswap) {
 		if (ffs_opts->version == 1)
-			ffs_dinode1_swap(&dp->ffs1_din,
+			ffs_dinode1_swap(&dp->dp1,
 			    &dp1[ino_to_fsbo(fs, ino)]);
 		else
-			ffs_dinode2_swap(&dp->ffs2_din,
+			ffs_dinode2_swap(&dp->dp2,
 			    &dp2[ino_to_fsbo(fs, ino)]);
 	} else {
 		if (ffs_opts->version == 1)
-			dp1[ino_to_fsbo(fs, ino)] = dp->ffs1_din;
+			dp1[ino_to_fsbo(fs, ino)] = dp->dp1;
 		else
-			dp2[ino_to_fsbo(fs, ino)] = dp->ffs2_din;
+			dp2[ino_to_fsbo(fs, ino)] = dp->dp2;
 	}
 	ffs_wtfs(d, fs->fs_bsize, buf, fsopts);
 	free(buf);
diff --git a/usr.sbin/makefs/ffs/ufs_inode.h b/usr.sbin/makefs/ffs/ufs_inode.h
index 67581dda3359..e84fa57f6540 100644
--- a/usr.sbin/makefs/ffs/ufs_inode.h
+++ b/usr.sbin/makefs/ffs/ufs_inode.h
@@ -39,11 +39,6 @@
  *	@(#)inode.h	8.9 (Berkeley) 5/14/95
  */
 
-union dinode {
-	struct ufs1_dinode ffs1_din;
-	struct ufs2_dinode ffs2_din;
-};
-
 struct inode {
 	ino_t		i_number;	/* The identity of the inode. */
 	struct vnode	*i_devvp;	/* vnode pointer (contains fsopts) */
@@ -52,45 +47,45 @@ struct inode {
 	uint64_t	i_size;
 };
 
-#define	i_ffs1_atime		i_din.ffs1_din.di_atime
-#define	i_ffs1_atimensec	i_din.ffs1_din.di_atimensec
-#define	i_ffs1_blocks		i_din.ffs1_din.di_blocks
-#define	i_ffs1_ctime		i_din.ffs1_din.di_ctime
-#define	i_ffs1_ctimensec	i_din.ffs1_din.di_ctimensec
-#define	i_ffs1_db		i_din.ffs1_din.di_db
-#define	i_ffs1_flags		i_din.ffs1_din.di_flags
-#define	i_ffs1_gen		i_din.ffs1_din.di_gen
-#define	i_ffs11_gid		i_din.ffs1_din.di_gid
-#define	i_ffs1_ib		i_din.ffs1_din.di_ib
-#define	i_ffs1_mode		i_din.ffs1_din.di_mode
-#define	i_ffs1_mtime		i_din.ffs1_din.di_mtime
-#define	i_ffs1_mtimensec	i_din.ffs1_din.di_mtimensec
-#define	i_ffs1_nlink		i_din.ffs1_din.di_nlink
-#define	i_ffs1_rdev		i_din.ffs1_din.di_rdev
-#define	i_ffs1_shortlink	i_din.ffs1_din.di_shortlink
-#define	i_ffs1_size		i_din.ffs1_din.di_size
-#define	i_ffs1_uid		i_din.ffs1_din.di_uid
+#define	i_ffs1_atime		i_din.dp1.di_atime
+#define	i_ffs1_atimensec	i_din.dp1.di_atimensec
+#define	i_ffs1_blocks		i_din.dp1.di_blocks
+#define	i_ffs1_ctime		i_din.dp1.di_ctime
+#define	i_ffs1_ctimensec	i_din.dp1.di_ctimensec
+#define	i_ffs1_db		i_din.dp1.di_db
+#define	i_ffs1_flags		i_din.dp1.di_flags
+#define	i_ffs1_gen		i_din.dp1.di_gen
+#define	i_ffs11_gid		i_din.dp1.di_gid
+#define	i_ffs1_ib		i_din.dp1.di_ib
+#define	i_ffs1_mode		i_din.dp1.di_mode
+#define	i_ffs1_mtime		i_din.dp1.di_mtime
+#define	i_ffs1_mtimensec	i_din.dp1.di_mtimensec
+#define	i_ffs1_nlink		i_din.dp1.di_nlink
+#define	i_ffs1_rdev		i_din.dp1.di_rdev
+#define	i_ffs1_shortlink	i_din.dp1.di_shortlink
+#define	i_ffs1_size		i_din.dp1.di_size
+#define	i_ffs1_uid		i_din.dp1.di_uid
 
-#define	i_ffs2_atime		i_din.ffs2_din.di_atime
-#define	i_ffs2_atimensec	i_din.ffs2_din.di_atimensec
-#define	i_ffs2_blocks		i_din.ffs2_din.di_blocks
-#define	i_ffs2_ctime		i_din.ffs2_din.di_ctime
-#define	i_ffs2_ctimensec	i_din.ffs2_din.di_ctimensec
-#define	i_ffs2_birthtime	i_din.ffs2_din.di_birthtime
-#define	i_ffs2_birthnsec	i_din.ffs2_din.di_birthnsec
-#define	i_ffs2_db		i_din.ffs2_din.di_db
-#define	i_ffs2_flags		i_din.ffs2_din.di_flags
-#define	i_ffs2_gen		i_din.ffs2_din.di_gen
-#define	i_ffs21_gid		i_din.ffs2_din.di_gid
-#define	i_ffs2_ib		i_din.ffs2_din.di_ib
-#define	i_ffs2_mode		i_din.ffs2_din.di_mode
-#define	i_ffs2_mtime		i_din.ffs2_din.di_mtime
-#define	i_ffs2_mtimensec	i_din.ffs2_din.di_mtimensec
-#define	i_ffs2_nlink		i_din.ffs2_din.di_nlink
-#define	i_ffs2_rdev		i_din.ffs2_din.di_rdev
-#define	i_ffs2_shortlink	i_din.ffs2_din.di_shortlink
-#define	i_ffs2_size		i_din.ffs2_din.di_size
-#define	i_ffs2_uid		i_din.ffs2_din.di_uid
+#define	i_ffs2_atime		i_din.dp2.di_atime
+#define	i_ffs2_atimensec	i_din.dp2.di_atimensec
+#define	i_ffs2_blocks		i_din.dp2.di_blocks
+#define	i_ffs2_ctime		i_din.dp2.di_ctime
+#define	i_ffs2_ctimensec	i_din.dp2.di_ctimensec
+#define	i_ffs2_birthtime	i_din.dp2.di_birthtime
+#define	i_ffs2_birthnsec	i_din.dp2.di_birthnsec
+#define	i_ffs2_db		i_din.dp2.di_db
+#define	i_ffs2_flags		i_din.dp2.di_flags
+#define	i_ffs2_gen		i_din.dp2.di_gen
+#define	i_ffs21_gid		i_din.dp2.di_gid
+#define	i_ffs2_ib		i_din.dp2.di_ib
+#define	i_ffs2_mode		i_din.dp2.di_mode
+#define	i_ffs2_mtime		i_din.dp2.di_mtime
+#define	i_ffs2_mtimensec	i_din.dp2.di_mtimensec
+#define	i_ffs2_nlink		i_din.dp2.di_nlink
+#define	i_ffs2_rdev		i_din.dp2.di_rdev
+#define	i_ffs2_shortlink	i_din.dp2.di_shortlink
+#define	i_ffs2_size		i_din.dp2.di_size
+#define	i_ffs2_uid		i_din.dp2.di_uid
 
 #undef DIP
 #define DIP(ip, field) \
diff --git a/usr.sbin/quot/quot.c b/usr.sbin/quot/quot.c
index dc189f0b8e42..27f0c1ee0068 100644
--- a/usr.sbin/quot/quot.c
+++ b/usr.sbin/quot/quot.c
@@ -98,10 +98,6 @@ static void	quot(char *, char *);
 	(((fs)->fs_magic == FS_UFS1_MAGIC ? sizeof(struct ufs1_dinode) : \
 	sizeof(struct ufs2_dinode)) * INOCNT(fs))
 
-union dinode {
-	struct ufs1_dinode dp1;
-	struct ufs2_dinode dp2;
-};
 #define	DIP(fs, dp, field) \
 	(((fs)->fs_magic == FS_UFS1_MAGIC) ? \
 	(dp)->dp1.field : (dp)->dp2.field)