Date: Fri, 7 Feb 2025 00:28:02 GMT From: Kirk McKusick <mckusick@FreeBSD.org> To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-branches@FreeBSD.org Subject: git: 6f87402a02f0 - stable/13 - Defer the January 19, 2038 date limit in UFS1 filesystems to February 7, 2106 Message-ID: <202502070028.5170S2Rw094957@gitrepo.freebsd.org>
next in thread | raw e-mail | index | archive | help
The branch stable/13 has been updated by mckusick: URL: https://cgit.FreeBSD.org/src/commit/?id=6f87402a02f0801942fe8f0d9a8f7f3e04dfbb01 commit 6f87402a02f0801942fe8f0d9a8f7f3e04dfbb01 Author: Kirk McKusick <mckusick@FreeBSD.org> AuthorDate: 2025-01-28 01:39:45 +0000 Commit: Kirk McKusick <mckusick@FreeBSD.org> CommitDate: 2025-02-07 00:27:15 +0000 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) --- lib/libufs/inode.c | 14 ++++++- lib/libufs/libufs.h | 10 +---- sbin/dump/traverse.c | 4 -- sbin/fsck_ffs/fsck.h | 4 -- sbin/fsck_ffs/inode.c | 30 +++++++++++++-- sbin/newfs/mkfs.c | 4 -- sbin/quotacheck/quotacheck.c | 4 -- share/man/man7/ffs.7 | 6 ++- stand/libsa/ufs.c | 11 ++---- sys/ufs/ffs/ffs_alloc.c | 3 +- sys/ufs/ffs/ffs_extern.h | 1 + sys/ufs/ffs/ffs_subr.c | 61 +++++++++++++++++++++++++++++++ sys/ufs/ffs/ffs_vfsops.c | 6 +++ sys/ufs/ufs/dinode.h | 26 ++++++++++--- sys/ufs/ufs/inode.h | 9 ++--- usr.sbin/makefs/ffs.c | 22 +++++------ usr.sbin/makefs/ffs/ufs_inode.h | 81 +++++++++++++++++++---------------------- usr.sbin/quot/quot.c | 4 -- 18 files changed, 192 insertions(+), 108 deletions(-) diff --git a/lib/libufs/inode.c b/lib/libufs/inode.c index 780e863928aa..48f2e8b0ff08 100644 --- a/lib/libufs/inode.c +++ b/lib/libufs/inode.c @@ -42,6 +42,7 @@ #include <stdio.h> #include <stdlib.h> #include <string.h> +#include <time.h> #include <unistd.h> #include <libufs.h> @@ -52,6 +53,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); @@ -72,6 +74,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, @@ -81,6 +87,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); @@ -88,8 +96,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 b26e0c263ce3..8acb365f1f44 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. @@ -107,6 +100,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); void ffs_setblock(struct fs *, u_char *, ufs1_daddr_t); int ffs_sbget(void *, struct fs **, off_t, char *, int (*)(void *, off_t, void **, int)); 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 1a4cc24e63db..899d70e3dcfc 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 a9bae0c64703..0ba99a22a006 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 fbc8fbce5e77..2ae163545953 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 6c2de232ddbd..8911a84ee3c2 100644 --- a/stand/libsa/ufs.c +++ b/stand/libsa/ufs.c @@ -111,10 +111,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 */ @@ -130,7 +127,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; @@ -188,10 +185,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 09028456435e..163ef4a11e50 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 2e9b485d482b..15688943fa34 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_reallocblks(struct vop_reallocblks_args *); int ffs_realloccg(struct inode *, ufs2_daddr_t, ufs2_daddr_t, diff --git a/sys/ufs/ffs/ffs_subr.c b/sys/ufs/ffs/ffs_subr.c index 351559882ca2..af0e2ac74427 100644 --- a/sys/ufs/ffs/ffs_subr.c +++ b/sys/ufs/ffs/ffs_subr.c @@ -35,6 +35,7 @@ #include <sys/param.h> #ifndef _KERNEL +#include <stdbool.h> #include <stdio.h> #include <string.h> #include <stdlib.h> @@ -66,6 +67,7 @@ struct malloc_type; #include <sys/buf.h> #include <sys/sysctl.h> #include <sys/ucred.h> +#include <sys/sysctl.h> #include <ufs/ufs/quota.h> #include <ufs/ufs/inode.h> @@ -396,6 +398,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. */ diff --git a/sys/ufs/ffs/ffs_vfsops.c b/sys/ufs/ffs/ffs_vfsops.c index a77784b32d78..2cc22ffa32d4 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 afe49bdba882..0fae4c11e309 100644 --- a/sys/ufs/ufs/inode.h +++ b/sys/ufs/ufs/inode.h @@ -89,10 +89,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 */ @@ -203,8 +200,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 #ifdef _KERNEL diff --git a/usr.sbin/makefs/ffs.c b/usr.sbin/makefs/ffs.c index cc83f2f2d3d2..c42641fff778 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 e1f8b96acbc6..037db7ba3f55 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)
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?202502070028.5170S2Rw094957>