kgess-mirror/freebsd-src
1
0
Fork 0
mirror of https://git.freebsd.org/src.git synced 2026-01-11 19:57:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Standardize the definition of a UFS dinode.

Browse source 
Each program that operates on UFS on-disk inodes defines its own
version of a dinode. They all (of necessity) define the same
layout but use different names. This change adds a definition of
a dinode (a union of a UFS1 on-disk inode and a UFS2 on-disk inode)
as well as a dinodep (a union of a pointer to a UFS1 on-disk inode
and a pointer to a UFS2 on-disk inode) in sys/ufs/ufs/dinode.h.
It then deletes the definitions of dinode and dinodep in all the
programs that operate on them and instead uses these standard
definitions.

No functional change intended.

MFC-after: 1 week
This commit is contained in:
Kirk McKusick 2025-01-27 17:39:45 -08:00
parent 9257fe124f
commit aa90fbed15
12 changed files with 82 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
lib/libufs/libufs.h
View file

@ -37,14 +37,6 @@
*/
#define LIBUFS_BUFALIGN 128
/*
* libufs structures.
*/
union dinodep {
struct ufs1_dinode *dp1;
struct ufs2_dinode *dp2;
};
/*
* userland ufs disk.
*/

4
sbin/dump/traverse.c
View file

@ -51,10 +51,6 @@
#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)

4
sbin/fsck_ffs/fsck.h
View file

@ -75,10 +75,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)

12
sbin/fsck_ffs/inode.c
View file

@ -429,6 +429,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)
@ -466,11 +467,12 @@ 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;
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");
@ -520,6 +522,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;
@ -550,10 +553,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);

4
sbin/newfs/mkfs.c
View file

@ -89,10 +89,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)

4
sbin/quotacheck/quotacheck.c
View file

@ -77,10 +77,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)

11
stand/libsa/ufs.c
View file

@ -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)];
/*

20
sys/ufs/ufs/dinode.h
View file

@ -111,12 +111,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. */
@ -210,4 +211,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_ */

9
sys/ufs/ufs/inode.h
View file

@ -88,10 +88,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 */
@ -204,8 +201,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)

22
usr.sbin/makefs/ffs.c
View file

@ -106,7 +106,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)).
@ -853,10 +853,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) {
@ -942,11 +942,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 */
@ -1176,16 +1176,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);

81
usr.sbin/makefs/ffs/ufs_inode.h
View file

@ -37,11 +37,6 @@
* SUCH DAMAGE.
*/
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) */
@ -50,45 +45,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) \

4
usr.sbin/quot/quot.c
View file

@ -97,10 +97,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)