From 993707aa2942d9cc3dd89b9052cbf4e76c124dba Mon Sep 17 00:00:00 2001 From: Kirk McKusick Date: Sat, 9 Jul 1994 06:45:07 -0800 Subject: [PATCH] changes for 64-bit machines (from bostic) SCCS-vsn: sys/ufs/ufs/inode.h 8.5 SCCS-vsn: sys/ufs/ufs/quota.h 8.2 SCCS-vsn: sys/ufs/ufs/ufsmount.h 8.3 SCCS-vsn: sys/ufs/ufs/dir.h 8.3 SCCS-vsn: sys/ufs/ufs/dinode.h 8.4 SCCS-vsn: sys/ufs/ffs/fs.h 8.8 SCCS-vsn: sys/ufs/lfs/lfs.h 8.5 --- usr/src/sys/ufs/ffs/fs.h | 276 +++++++++++++++++---------------- usr/src/sys/ufs/lfs/lfs.h | 239 ++++++++++++++-------------- usr/src/sys/ufs/ufs/dinode.h | 24 +-- usr/src/sys/ufs/ufs/dir.h | 59 ++++--- usr/src/sys/ufs/ufs/inode.h | 70 ++++----- usr/src/sys/ufs/ufs/quota.h | 48 +++--- usr/src/sys/ufs/ufs/ufsmount.h | 13 +- 7 files changed, 370 insertions(+), 359 deletions(-) diff --git a/usr/src/sys/ufs/ffs/fs.h b/usr/src/sys/ufs/ffs/fs.h index 5386b9f05f..247a281cf8 100644 --- a/usr/src/sys/ufs/ffs/fs.h +++ b/usr/src/sys/ufs/ffs/fs.h @@ -4,7 +4,7 @@ * * %sccs.include.redist.c% * - * @(#)fs.h 8.7 (Berkeley) %G% + * @(#)fs.h 8.8 (Berkeley) %G% */ /* @@ -77,12 +77,16 @@ * The path name on which the file system is mounted is maintained * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in * the super block for this name. + */ +#define MAXMNTLEN 512 + +/* * The limit on the amount of summary information per file system * is defined by MAXCSBUFS. It is currently parameterized for a - * maximum of two million cylinders. + * size of 128 bytes (2 million cylinder groups on machines with + * 32-bit pointers, and 1 million on 64-bit machines). */ -#define MAXMNTLEN 512 -#define MAXCSBUFS 32 +#define MAXCSBUFS (128 / sizeof(void *)) /* * A summary of contiguous blocks of various sizes is maintained @@ -117,107 +121,108 @@ * the ``fs_cs'' macro to work (see below). */ struct csum { - long cs_ndir; /* number of directories */ - long cs_nbfree; /* number of free blocks */ - long cs_nifree; /* number of free inodes */ - long cs_nffree; /* number of free frags */ + int32_t cs_ndir; /* number of directories */ + int32_t cs_nbfree; /* number of free blocks */ + int32_t cs_nifree; /* number of free inodes */ + int32_t cs_nffree; /* number of free frags */ }; /* - * Super block for a file system. + * Super block for an FFS file system. */ struct fs { - struct fs *fs_link; /* linked list of file systems */ - struct fs *fs_rlink; /* used for incore super blocks */ - daddr_t fs_sblkno; /* addr of super-block in filesys */ - daddr_t fs_cblkno; /* offset of cyl-block in filesys */ - daddr_t fs_iblkno; /* offset of inode-blocks in filesys */ - daddr_t fs_dblkno; /* offset of first data after cg */ - long fs_cgoffset; /* cylinder group offset in cylinder */ - long fs_cgmask; /* used to calc mod fs_ntrak */ - time_t fs_time; /* last time written */ - long fs_size; /* number of blocks in fs */ - long fs_dsize; /* number of data blocks in fs */ - long fs_ncg; /* number of cylinder groups */ - long fs_bsize; /* size of basic blocks in fs */ - long fs_fsize; /* size of frag blocks in fs */ - long fs_frag; /* number of frags in a block in fs */ + int32_t unused_1; /* historic file system linked list, */ + int32_t unused_2; /* used for incore super blocks */ + daddr_t fs_sblkno; /* addr of super-block in filesys */ + daddr_t fs_cblkno; /* offset of cyl-block in filesys */ + daddr_t fs_iblkno; /* offset of inode-blocks in filesys */ + daddr_t fs_dblkno; /* offset of first data after cg */ + int32_t fs_cgoffset; /* cylinder group offset in cylinder */ + int32_t fs_cgmask; /* used to calc mod fs_ntrak */ + time_t fs_time; /* last time written */ + int32_t fs_size; /* number of blocks in fs */ + int32_t fs_dsize; /* number of data blocks in fs */ + int32_t fs_ncg; /* number of cylinder groups */ + int32_t fs_bsize; /* size of basic blocks in fs */ + int32_t fs_fsize; /* size of frag blocks in fs */ + int32_t fs_frag; /* number of frags in a block in fs */ /* these are configuration parameters */ - long fs_minfree; /* minimum percentage of free blocks */ - long fs_rotdelay; /* num of ms for optimal next block */ - long fs_rps; /* disk revolutions per second */ + int32_t fs_minfree; /* minimum percentage of free blocks */ + int32_t fs_rotdelay; /* num of ms for optimal next block */ + int32_t fs_rps; /* disk revolutions per second */ /* these fields can be computed from the others */ - long fs_bmask; /* ``blkoff'' calc of blk offsets */ - long fs_fmask; /* ``fragoff'' calc of frag offsets */ - long fs_bshift; /* ``lblkno'' calc of logical blkno */ - long fs_fshift; /* ``numfrags'' calc number of frags */ + int32_t fs_bmask; /* ``blkoff'' calc of blk offsets */ + int32_t fs_fmask; /* ``fragoff'' calc of frag offsets */ + int32_t fs_bshift; /* ``lblkno'' calc of logical blkno */ + int32_t fs_fshift; /* ``numfrags'' calc number of frags */ /* these are configuration parameters */ - long fs_maxcontig; /* max number of contiguous blks */ - long fs_maxbpg; /* max number of blks per cyl group */ + int32_t fs_maxcontig; /* max number of contiguous blks */ + int32_t fs_maxbpg; /* max number of blks per cyl group */ /* these fields can be computed from the others */ - long fs_fragshift; /* block to frag shift */ - long fs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ - long fs_sbsize; /* actual size of super block */ - long fs_csmask; /* csum block offset */ - long fs_csshift; /* csum block number */ - long fs_nindir; /* value of NINDIR */ - long fs_inopb; /* value of INOPB */ - long fs_nspf; /* value of NSPF */ + int32_t fs_fragshift; /* block to frag shift */ + int32_t fs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ + int32_t fs_sbsize; /* actual size of super block */ + int32_t fs_csmask; /* csum block offset */ + int32_t fs_csshift; /* csum block number */ + int32_t fs_nindir; /* value of NINDIR */ + int32_t fs_inopb; /* value of INOPB */ + int32_t fs_nspf; /* value of NSPF */ /* yet another configuration parameter */ - long fs_optim; /* optimization preference, see below */ + int32_t fs_optim; /* optimization preference, see below */ /* these fields are derived from the hardware */ - long fs_npsect; /* # sectors/track including spares */ - long fs_interleave; /* hardware sector interleave */ - long fs_trackskew; /* sector 0 skew, per track */ - long fs_headswitch; /* head switch time, usec */ - long fs_trkseek; /* track-to-track seek, usec */ + int32_t fs_npsect; /* # sectors/track including spares */ + int32_t fs_interleave; /* hardware sector interleave */ + int32_t fs_trackskew; /* sector 0 skew, per track */ + int32_t fs_headswitch; /* head switch time, usec */ + int32_t fs_trkseek; /* track-to-track seek, usec */ /* sizes determined by number of cylinder groups and their sizes */ - daddr_t fs_csaddr; /* blk addr of cyl grp summary area */ - long fs_cssize; /* size of cyl grp summary area */ - long fs_cgsize; /* cylinder group size */ + daddr_t fs_csaddr; /* blk addr of cyl grp summary area */ + int32_t fs_cssize; /* size of cyl grp summary area */ + int32_t fs_cgsize; /* cylinder group size */ /* these fields are derived from the hardware */ - long fs_ntrak; /* tracks per cylinder */ - long fs_nsect; /* sectors per track */ - long fs_spc; /* sectors per cylinder */ + int32_t fs_ntrak; /* tracks per cylinder */ + int32_t fs_nsect; /* sectors per track */ + int32_t fs_spc; /* sectors per cylinder */ /* this comes from the disk driver partitioning */ - long fs_ncyl; /* cylinders in file system */ + int32_t fs_ncyl; /* cylinders in file system */ /* these fields can be computed from the others */ - long fs_cpg; /* cylinders per group */ - long fs_ipg; /* inodes per group */ - long fs_fpg; /* blocks per group * fs_frag */ + int32_t fs_cpg; /* cylinders per group */ + int32_t fs_ipg; /* inodes per group */ + int32_t fs_fpg; /* blocks per group * fs_frag */ /* this data must be re-computed after crashes */ struct csum fs_cstotal; /* cylinder summary information */ /* these fields are cleared at mount time */ - char fs_fmod; /* super block modified flag */ - char fs_clean; /* file system is clean flag */ - char fs_ronly; /* mounted read-only flag */ - char fs_flags; /* currently unused flag */ - char fs_fsmnt[MAXMNTLEN]; /* name mounted on */ + int8_t fs_fmod; /* super block modified flag */ + int8_t fs_clean; /* file system is clean flag */ + int8_t fs_ronly; /* mounted read-only flag */ + int8_t fs_flags; /* currently unused flag */ + u_char fs_fsmnt[MAXMNTLEN]; /* name mounted on */ long fs_dbsize; /* hardware sector size */ long fs_sparecon[31]; /* reserved for future constants */ /* these fields retain the current block allocation info */ - long fs_cgrotor; /* last cg searched */ + int32_t fs_cgrotor; /* last cg searched */ struct csum *fs_csp[MAXCSBUFS];/* list of fs_cs info buffers */ - long fs_cpc; /* cyl per cycle in postbl */ - short fs_opostbl[16][8]; /* old rotation block list head */ - long fs_sparecon[50]; /* reserved for future constants */ - long fs_contigsumsize; /* size of cluster summary array */ - long fs_maxsymlinklen; /* max length of an internal symlink */ - long fs_inodefmt; /* format of on-disk inodes */ + int32_t fs_cpc; /* cyl per cycle in postbl */ + int16_t fs_opostbl[16][8]; /* old rotation block list head */ + int32_t fs_sparecon[50]; /* reserved for future constants */ + int32_t fs_contigsumsize; /* size of cluster summary array */ + int32_t fs_maxsymlinklen; /* max length of an internal symlink */ + int32_t fs_inodefmt; /* format of on-disk inodes */ u_quad_t fs_maxfilesize; /* maximum representable file size */ - quad_t fs_qbmask; /* ~fs_bmask - for use with quad size */ - quad_t fs_qfmask; /* ~fs_fmask - for use with quad size */ - long fs_state; /* validate fs_clean field */ - long fs_postblformat; /* format of positional layout tables */ - long fs_nrpos; /* number of rotational positions */ - long fs_postbloff; /* (short) rotation block list head */ - long fs_rotbloff; /* (u_char) blocks for each rotation */ - long fs_magic; /* magic number */ - u_char fs_space[1]; /* list of blocks for each rotation */ + quad_t fs_qbmask; /* ~fs_bmask - for use with quad size */ + quad_t fs_qfmask; /* ~fs_fmask - for use with quad size */ + int32_t fs_state; /* validate fs_clean field */ + int32_t fs_postblformat; /* format of positional layout tables */ + int32_t fs_nrpos; /* number of rotational positions */ + int32_t fs_postbloff; /* (u_int16) rotation block list head */ + int32_t fs_rotbloff; /* (u_int8) blocks for each rotation */ + int32_t fs_magic; /* magic number */ + u_int8_t fs_space[1]; /* list of blocks for each rotation */ /* actually longer */ }; + /* - * Filesystem idetification + * Filesystem identification */ #define FS_MAGIC 0x011954 /* the fast filesystem magic number */ #define FS_OKAY 0x7c269d38 /* superblock checksum */ @@ -240,11 +245,12 @@ struct fs { #define fs_postbl(fs, cylno) \ (((fs)->fs_postblformat == FS_42POSTBLFMT) \ ? ((fs)->fs_opostbl[cylno]) \ - : ((short *)((char *)(fs) + (fs)->fs_postbloff) + (cylno) * (fs)->fs_nrpos)) + : ((int16_t *)((u_int8_t *)(fs) + \ + (fs)->fs_postbloff) + (cylno) * (fs)->fs_nrpos)) #define fs_rotbl(fs) \ (((fs)->fs_postblformat == FS_42POSTBLFMT) \ ? ((fs)->fs_space) \ - : ((u_char *)((char *)(fs) + (fs)->fs_rotbloff))) + : ((u_int8_t *)((u_int8_t *)(fs) + (fs)->fs_rotbloff))) /* * The size of a cylinder group is calculated by CGSIZE. The maximum size @@ -253,13 +259,13 @@ struct fs { * cylinder group and the (struct cg) size. */ #define CGSIZE(fs) \ - /* base cg */ (sizeof(struct cg) + sizeof(long) + \ - /* blktot size */ (fs)->fs_cpg * sizeof(long) + \ - /* blks size */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(short) + \ + /* base cg */ (sizeof(struct cg) + sizeof(int32_t) + \ + /* blktot size */ (fs)->fs_cpg * sizeof(int32_t) + \ + /* blks size */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(int16_t) + \ /* inode map */ howmany((fs)->fs_ipg, NBBY) + \ /* block map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY) +\ /* if present */ ((fs)->fs_contigsumsize <= 0 ? 0 : \ - /* cluster sum */ (fs)->fs_contigsumsize * sizeof(long) + \ + /* cluster sum */ (fs)->fs_contigsumsize * sizeof(int32_t) + \ /* cluster map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPB(fs), NBBY))) /* @@ -274,79 +280,81 @@ struct fs { * Cylinder group block for a file system. */ #define CG_MAGIC 0x090255 -struct cg { - struct cg *cg_link; /* linked list of cyl groups */ - long cg_magic; /* magic number */ - time_t cg_time; /* time last written */ - long cg_cgx; /* we are the cgx'th cylinder group */ - short cg_ncyl; /* number of cyl's this cg */ - short cg_niblk; /* number of inode blocks this cg */ - long cg_ndblk; /* number of data blocks this cg */ +struct cg { + int32_t unused_1; /* historic cyl groups linked list */ + int32_t cg_magic; /* magic number */ + time_t cg_time; /* time last written */ + int32_t cg_cgx; /* we are the cgx'th cylinder group */ + int16_t cg_ncyl; /* number of cyl's this cg */ + int16_t cg_niblk; /* number of inode blocks this cg */ + int32_t cg_ndblk; /* number of data blocks this cg */ struct csum cg_cs; /* cylinder summary information */ - long cg_rotor; /* position of last used block */ - long cg_frotor; /* position of last used frag */ - long cg_irotor; /* position of last used inode */ - long cg_frsum[MAXFRAG]; /* counts of available frags */ - long cg_btotoff; /* (long) block totals per cylinder */ - long cg_boff; /* (short) free block positions */ - long cg_iusedoff; /* (char) used inode map */ - long cg_freeoff; /* (u_char) free block map */ - long cg_nextfreeoff; /* (u_char) next available space */ - long cg_clustersumoff; /* (long) counts of avail clusters */ - long cg_clusteroff; /* (char) free cluster map */ - long cg_nclusterblks; /* number of clusters this cg */ - long cg_sparecon[13]; /* reserved for future use */ - u_char cg_space[1]; /* space for cylinder group maps */ + int32_t cg_rotor; /* position of last used block */ + int32_t cg_frotor; /* position of last used frag */ + int32_t cg_irotor; /* position of last used inode */ + int32_t cg_frsum[MAXFRAG]; /* counts of available frags */ + int32_t cg_btotoff; /* (int32) block totals per cylinder */ + int32_t cg_boff; /* (u_int16) free block positions */ + int32_t cg_iusedoff; /* (u_int8) used inode map */ + int32_t cg_freeoff; /* (u_int8) free block map */ + int32_t cg_nextfreeoff; /* (u_int8) next available space */ + int32_t cg_clustersumoff; /* (u_int32) counts of avail clusters */ + int32_t cg_clusteroff; /* (u_int8) free cluster map */ + int32_t cg_nclusterblks; /* number of clusters this cg */ + int32_t cg_sparecon[13]; /* reserved for future use */ + u_int8_t cg_space[1]; /* space for cylinder group maps */ /* actually longer */ }; + /* * Macros for access to cylinder group array structures */ #define cg_blktot(cgp) \ (((cgp)->cg_magic != CG_MAGIC) \ ? (((struct ocg *)(cgp))->cg_btot) \ - : ((long *)((char *)(cgp) + (cgp)->cg_btotoff))) + : ((int32_t *)((u_int8_t *)(cgp) + (cgp)->cg_btotoff))) #define cg_blks(fs, cgp, cylno) \ (((cgp)->cg_magic != CG_MAGIC) \ ? (((struct ocg *)(cgp))->cg_b[cylno]) \ - : ((short *)((char *)(cgp) + (cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos)) + : ((int16_t *)((u_int8_t *)(cgp) + \ + (cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos)) #define cg_inosused(cgp) \ (((cgp)->cg_magic != CG_MAGIC) \ ? (((struct ocg *)(cgp))->cg_iused) \ - : ((char *)((char *)(cgp) + (cgp)->cg_iusedoff))) + : ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_iusedoff))) #define cg_blksfree(cgp) \ (((cgp)->cg_magic != CG_MAGIC) \ ? (((struct ocg *)(cgp))->cg_free) \ - : ((u_char *)((char *)(cgp) + (cgp)->cg_freeoff))) + : ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_freeoff))) #define cg_chkmagic(cgp) \ ((cgp)->cg_magic == CG_MAGIC || ((struct ocg *)(cgp))->cg_magic == CG_MAGIC) #define cg_clustersfree(cgp) \ - ((u_char *)((char *)(cgp) + (cgp)->cg_clusteroff)) + ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_clusteroff)) #define cg_clustersum(cgp) \ - ((long *)((char *)(cgp) + (cgp)->cg_clustersumoff)) + ((int32_t *)((u_int8_t *)(cgp) + (cgp)->cg_clustersumoff)) /* * The following structure is defined * for compatibility with old file systems. */ -struct ocg { - struct ocg *cg_link; /* linked list of cyl groups */ - struct ocg *cg_rlink; /* used for incore cyl groups */ - time_t cg_time; /* time last written */ - long cg_cgx; /* we are the cgx'th cylinder group */ - short cg_ncyl; /* number of cyl's this cg */ - short cg_niblk; /* number of inode blocks this cg */ - long cg_ndblk; /* number of data blocks this cg */ +struct ocg { + int32_t unused_1; /* historic linked list of cyl groups */ + int32_t unused_2; /* used for incore cyl groups */ + time_t cg_time; /* time last written */ + int32_t cg_cgx; /* we are the cgx'th cylinder group */ + int16_t cg_ncyl; /* number of cyl's this cg */ + int16_t cg_niblk; /* number of inode blocks this cg */ + int32_t cg_ndblk; /* number of data blocks this cg */ struct csum cg_cs; /* cylinder summary information */ - long cg_rotor; /* position of last used block */ - long cg_frotor; /* position of last used frag */ - long cg_irotor; /* position of last used inode */ - long cg_frsum[8]; /* counts of available frags */ - long cg_btot[32]; /* block totals per cylinder */ - short cg_b[32][8]; /* positions of free blocks */ - char cg_iused[256]; /* used inode map */ - long cg_magic; /* magic number */ - u_char cg_free[1]; /* free block map */ + int32_t cg_rotor; /* position of last used block */ + int32_t cg_frotor; /* position of last used frag */ + int32_t cg_irotor; /* position of last used inode */ + int32_t cg_frsum[8]; /* counts of available frags */ + int32_t cg_btot[32]; /* block totals per cylinder */ + int16_t cg_b[32][8]; /* positions of free blocks */ + u_int8_t cg_iused[256]; /* used inode map */ + int32_t cg_magic; /* magic number */ + u_int8_t cg_free[1]; /* free block map */ /* actually longer */ }; @@ -449,20 +457,22 @@ struct ocg { ? (fs)->fs_bsize \ : (fragroundup(fs, blkoff(fs, (dip)->di_size)))) + /* - * Number of disk sectors per block; assumes DEV_BSIZE byte sector size. + * Number of disk sectors per block/fragment; assumes DEV_BSIZE byte + * sector size. */ #define NSPB(fs) ((fs)->fs_nspf << (fs)->fs_fragshift) #define NSPF(fs) ((fs)->fs_nspf) /* - * INOPB is the number of inodes in a secondary storage block. + * Number of inodes in a secondary storage block/fragment. */ #define INOPB(fs) ((fs)->fs_inopb) #define INOPF(fs) ((fs)->fs_inopb >> (fs)->fs_fragshift) /* - * NINDIR is the number of indirects in a file system block. + * Number of indirects in a file system block. */ #define NINDIR(fs) ((fs)->fs_nindir) diff --git a/usr/src/sys/ufs/lfs/lfs.h b/usr/src/sys/ufs/lfs/lfs.h index f9f53e9556..75e4b24b38 100644 --- a/usr/src/sys/ufs/lfs/lfs.h +++ b/usr/src/sys/ufs/lfs/lfs.h @@ -4,7 +4,7 @@ * * %sccs.include.redist.c% * - * @(#)lfs.h 8.4 (Berkeley) %G% + * @(#)lfs.h 8.5 (Berkeley) %G% */ #define LFS_LABELPAD 8192 /* LFS label size */ @@ -29,14 +29,15 @@ /* On-disk and in-memory checkpoint segment usage structure. */ typedef struct segusage SEGUSE; struct segusage { - u_long su_nbytes; /* number of live bytes */ - u_long su_lastmod; /* SEGUSE last modified timestamp */ - u_short su_nsums; /* number of summaries in segment */ - u_short su_ninos; /* number of inode blocks in seg */ -#define SEGUSE_ACTIVE 0x1 /* segment is currently being written */ -#define SEGUSE_DIRTY 0x2 /* segment has data in it */ -#define SEGUSE_SUPERBLOCK 0x4 /* segment contains a superblock */ - u_long su_flags; + u_int32_t su_nbytes; /* number of live bytes */ + u_int32_t su_lastmod; /* SEGUSE last modified timestamp */ + u_int16_t su_nsums; /* number of summaries in segment */ + u_int16_t su_ninos; /* number of inode blocks in seg */ + +#define SEGUSE_ACTIVE 0x01 /* segment is currently being written */ +#define SEGUSE_DIRTY 0x02 /* segment has data in it */ +#define SEGUSE_SUPERBLOCK 0x04 /* segment contains a superblock */ + u_int32_t su_flags; }; #define SEGUPB(fs) (1 << (fs)->lfs_sushift) @@ -46,99 +47,99 @@ struct segusage { /* On-disk file information. One per file with data blocks in the segment. */ typedef struct finfo FINFO; struct finfo { - u_long fi_nblocks; /* number of blocks */ - u_long fi_version; /* version number */ - u_long fi_ino; /* inode number */ - long fi_blocks[1]; /* array of logical block numbers */ + u_int32_t fi_nblocks; /* number of blocks */ + u_int32_t fi_version; /* version number */ + u_int32_t fi_ino; /* inode number */ + daddr_t fi_blocks[1]; /* array of logical block numbers */ }; /* On-disk and in-memory super block. */ struct lfs { #define LFS_MAGIC 0x070162 - u_long lfs_magic; /* magic number */ + u_int32_t lfs_magic; /* magic number */ #define LFS_VERSION 1 - u_long lfs_version; /* version number */ + u_int32_t lfs_version; /* version number */ - u_long lfs_size; /* number of blocks in fs */ - u_long lfs_ssize; /* number of blocks per segment */ - u_long lfs_dsize; /* number of disk blocks in fs */ - u_long lfs_bsize; /* file system block size */ - u_long lfs_fsize; /* size of frag blocks in fs */ - u_long lfs_frag; /* number of frags in a block in fs */ + u_int32_t lfs_size; /* number of blocks in fs */ + u_int32_t lfs_ssize; /* number of blocks per segment */ + u_int32_t lfs_dsize; /* number of disk blocks in fs */ + u_int32_t lfs_bsize; /* file system block size */ + u_int32_t lfs_fsize; /* size of frag blocks in fs */ + u_int32_t lfs_frag; /* number of frags in a block in fs */ /* Checkpoint region. */ - ino_t lfs_free; /* start of the free list */ - u_long lfs_bfree; /* number of free disk blocks */ - u_long lfs_nfiles; /* number of allocated inodes */ - long lfs_avail; /* blocks available for writing */ - u_long lfs_uinodes; /* inodes in cache not yet on disk */ - daddr_t lfs_idaddr; /* inode file disk address */ - ino_t lfs_ifile; /* inode file inode number */ - daddr_t lfs_lastseg; /* address of last segment written */ - daddr_t lfs_nextseg; /* address of next segment to write */ - daddr_t lfs_curseg; /* current segment being written */ - daddr_t lfs_offset; /* offset in curseg for next partial */ - daddr_t lfs_lastpseg; /* address of last partial written */ - u_long lfs_tstamp; /* time stamp */ + ino_t lfs_free; /* start of the free list */ + u_int32_t lfs_bfree; /* number of free disk blocks */ + u_int32_t lfs_nfiles; /* number of allocated inodes */ + int32_t lfs_avail; /* blocks available for writing */ + u_int32_t lfs_uinodes; /* inodes in cache not yet on disk */ + daddr_t lfs_idaddr; /* inode file disk address */ + ino_t lfs_ifile; /* inode file inode number */ + daddr_t lfs_lastseg; /* address of last segment written */ + daddr_t lfs_nextseg; /* address of next segment to write */ + daddr_t lfs_curseg; /* current segment being written */ + daddr_t lfs_offset; /* offset in curseg for next partial */ + daddr_t lfs_lastpseg; /* address of last partial written */ + u_int32_t lfs_tstamp; /* time stamp */ /* These are configuration parameters. */ - u_long lfs_minfree; /* minimum percentage of free blocks */ + u_int32_t lfs_minfree; /* minimum percentage of free blocks */ /* These fields can be computed from the others. */ - u_quad_t lfs_maxfilesize; /* maximum representable file size */ - u_long lfs_dbpseg; /* disk blocks per segment */ - u_long lfs_inopb; /* inodes per block */ - u_long lfs_ifpb; /* IFILE entries per block */ - u_long lfs_sepb; /* SEGUSE entries per block */ - u_long lfs_nindir; /* indirect pointers per block */ - u_long lfs_nseg; /* number of segments */ - u_long lfs_nspf; /* number of sectors per fragment */ - u_long lfs_cleansz; /* cleaner info size in blocks */ - u_long lfs_segtabsz; /* segment table size in blocks */ - - u_long lfs_segmask; /* calculate offset within a segment */ - u_long lfs_segshift; /* fast mult/div for segments */ - u_long lfs_bmask; /* calc block offset from file offset */ - u_long lfs_bshift; /* calc block number from file offset */ - u_long lfs_ffmask; /* calc frag offset from file offset */ - u_long lfs_ffshift; /* fast mult/div for frag from file */ - u_long lfs_fbmask; /* calc frag offset from block offset */ - u_long lfs_fbshift; /* fast mult/div for frag from block */ - u_long lfs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ - u_long lfs_sushift; /* fast mult/div for segusage table */ + u_quad_t lfs_maxfilesize; /* maximum representable file size */ + u_int32_t lfs_dbpseg; /* disk blocks per segment */ + u_int32_t lfs_inopb; /* inodes per block */ + u_int32_t lfs_ifpb; /* IFILE entries per block */ + u_int32_t lfs_sepb; /* SEGUSE entries per block */ + u_int32_t lfs_nindir; /* indirect pointers per block */ + u_int32_t lfs_nseg; /* number of segments */ + u_int32_t lfs_nspf; /* number of sectors per fragment */ + u_int32_t lfs_cleansz; /* cleaner info size in blocks */ + u_int32_t lfs_segtabsz; /* segment table size in blocks */ + + u_int32_t lfs_segmask; /* calculate offset within a segment */ + u_int32_t lfs_segshift; /* fast mult/div for segments */ + u_int32_t lfs_bmask; /* calc block offset from file offset */ + u_int32_t lfs_bshift; /* calc block number from file offset */ + u_int32_t lfs_ffmask; /* calc frag offset from file offset */ + u_int32_t lfs_ffshift; /* fast mult/div for frag from file */ + u_int32_t lfs_fbmask; /* calc frag offset from block offset */ + u_int32_t lfs_fbshift; /* fast mult/div for frag from block */ + u_int32_t lfs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ + u_int32_t lfs_sushift; /* fast mult/div for segusage table */ + + int32_t lfs_maxsymlinklen; /* max length of an internal symlink */ #define LFS_MIN_SBINTERVAL 5 /* minimum superblock segment spacing */ #define LFS_MAXNUMSB 10 /* superblock disk offsets */ - daddr_t lfs_sboffs[LFS_MAXNUMSB]; + daddr_t lfs_sboffs[LFS_MAXNUMSB]; + +/* Checksum -- last valid disk field. */ + u_int32_t lfs_cksum; /* checksum for superblock checking */ /* These fields are set at mount time and are meaningless on disk. */ - struct segment *lfs_sp; /* current segment being written */ - struct vnode *lfs_ivnode; /* vnode for the ifile */ - u_long lfs_seglock; /* single-thread the segment writer */ - pid_t lfs_lockpid; /* pid of lock holder */ - u_long lfs_iocount; /* number of ios pending */ - u_long lfs_writer; /* don't allow any dirops to start */ - u_long lfs_dirops; /* count of active directory ops */ - u_long lfs_doifile; /* Write ifile blocks on next write */ - u_long lfs_nactive; /* Number of segments since last ckp */ - u_char lfs_fmod; /* super block modified flag */ - u_char lfs_clean; /* file system is clean flag */ - u_char lfs_ronly; /* mounted read-only flag */ - u_char lfs_flags; /* currently unused flag */ - u_char lfs_fsmnt[MNAMELEN]; /* name mounted on */ - u_char pad[3]; /* long-align */ - -/* Checksum; valid on disk. */ - u_long lfs_cksum; /* checksum for superblock checking */ - long lfs_maxsymlinklen; /* max length of an internal symlink */ + struct segment *lfs_sp; /* current segment being written */ + struct vnode *lfs_ivnode; /* vnode for the ifile */ + u_long lfs_seglock; /* single-thread the segment writer */ + pid_t lfs_lockpid; /* pid of lock holder */ + u_long lfs_iocount; /* number of ios pending */ + u_long lfs_writer; /* don't allow any dirops to start */ + u_long lfs_dirops; /* count of active directory ops */ + u_long lfs_doifile; /* Write ifile blocks on next write */ + u_long lfs_nactive; /* Number of segments since last ckp */ + int8_t lfs_fmod; /* super block modified flag */ + int8_t lfs_clean; /* file system is clean flag */ + int8_t lfs_ronly; /* mounted read-only flag */ + int8_t lfs_flags; /* currently unused flag */ + u_char lfs_fsmnt[MNAMELEN]; /* name mounted on */ }; /* - * Inode 0 is the out-of-band inode number, inode 1 is the inode number for - * the IFILE, the root inode is 2 and the lost+found inode is 3. + * Inode 0: out-of-band inode number + * Inode 1: IFILE inode number + * Inode 2: root inode + * Inode 3: lost+found inode number */ - -/* Fixed inode numbers. */ #define LFS_UNUSED_INUM 0 /* out of band inode number */ #define LFS_IFILE_INUM 1 /* IFILE inode number */ #define LOSTFOUNDINO 3 /* lost+found inode number */ @@ -157,10 +158,10 @@ struct lfs { typedef struct ifile IFILE; struct ifile { - u_long if_version; /* inode version number */ + u_int32_t if_version; /* inode version number */ #define LFS_UNUSED_DADDR 0 /* out-of-band daddr */ - daddr_t if_daddr; /* inode disk address */ - ino_t if_nextfree; /* next-unallocated inode */ + daddr_t if_daddr; /* inode disk address */ + ino_t if_nextfree; /* next-unallocated inode */ }; /* @@ -168,8 +169,8 @@ struct ifile { * to pass information between the cleaner and the kernel. */ typedef struct _cleanerinfo { - u_long clean; /* K: number of clean segments */ - u_long dirty; /* K: number of dirty segments */ + u_int32_t clean; /* K: number of clean segments */ + u_int32_t dirty; /* K: number of dirty segments */ } CLEANERINFO; #define CLEANSIZE_SU(fs) \ @@ -184,16 +185,17 @@ typedef struct _cleanerinfo { /* On-disk segment summary information */ typedef struct segsum SEGSUM; struct segsum { - u_long ss_sumsum; /* check sum of summary block */ - u_long ss_datasum; /* check sum of data */ - daddr_t ss_next; /* next segment */ - u_long ss_create; /* creation time stamp */ - u_short ss_nfinfo; /* number of file info structures */ - u_short ss_ninos; /* number of inodes in summary */ + u_int32_t ss_sumsum; /* check sum of summary block */ + u_int32_t ss_datasum; /* check sum of data */ + daddr_t ss_next; /* next segment */ + u_int32_t ss_create; /* creation time stamp */ + u_int16_t ss_nfinfo; /* number of file info structures */ + u_int16_t ss_ninos; /* number of inodes in summary */ + #define SS_DIROP 0x01 /* segment begins a dirop */ #define SS_CONT 0x02 /* more partials to finish this write*/ - u_short ss_flags; /* used for directory operations */ - u_short ss_pad; /* extra space */ + u_int16_t ss_flags; /* used for directory operations */ + u_int16_t ss_pad; /* extra space */ /* FINFO's and inode daddr's... */ }; @@ -256,8 +258,8 @@ struct segsum { * the segment usage table, plus an ifile page. */ #define LFS_FITS(fs, db) \ - ((long)((db + ((fs)->lfs_uinodes + INOPB((fs))) / INOPB((fs)) + \ - fsbtodb(fs, 1) + LFS_SUMMARY_SIZE / DEV_BSIZE + \ + ((int32_t)((db + ((fs)->lfs_uinodes + INOPB((fs))) / \ + INOPB((fs)) + fsbtodb(fs, 1) + LFS_SUMMARY_SIZE / DEV_BSIZE + \ (fs)->lfs_segtabsz)) < (fs)->lfs_avail) /* Determine if a buffer belongs to the ifile */ @@ -278,23 +280,24 @@ typedef struct block_info { /* In-memory description of a segment about to be written. */ struct segment { - struct lfs *fs; /* file system pointer */ + struct lfs *fs; /* file system pointer */ struct buf **bpp; /* pointer to buffer array */ struct buf **cbpp; /* pointer to next available bp */ struct buf **start_bpp; /* pointer to first bp in this set */ - struct buf *ibp; /* buffer pointer to inode page */ - struct finfo *fip; /* current fileinfo pointer */ - struct vnode *vp; /* vnode being gathered */ - void *segsum; /* segment summary info */ - u_long ninodes; /* number of inodes in this segment */ - u_long seg_bytes_left; /* bytes left in segment */ - u_long sum_bytes_left; /* bytes left in summary block */ - u_long seg_number; /* number of this segment */ - daddr_t *start_lbp; /* beginning lbn for this set */ + struct buf *ibp; /* buffer pointer to inode page */ + struct finfo *fip; /* current fileinfo pointer */ + struct vnode *vp; /* vnode being gathered */ + void *segsum; /* segment summary info */ + u_int32_t ninodes; /* number of inodes in this segment */ + u_int32_t seg_bytes_left; /* bytes left in segment */ + u_int32_t sum_bytes_left; /* bytes left in summary block */ + u_int32_t seg_number; /* number of this segment */ + daddr_t *start_lbp; /* beginning lbn for this set */ + #define SEGM_CKP 0x01 /* doing a checkpoint */ #define SEGM_CLEAN 0x02 /* cleaner call; don't sort */ #define SEGM_SYNC 0x04 /* wait for segment */ - u_long seg_flags; /* run-time flags for this segment */ + u_int16_t seg_flags; /* run-time flags for this segment */ }; #define ISSPACE(F, BB, C) \ @@ -311,18 +314,18 @@ struct segment { #ifdef DOSTATS /* Statistics Counters */ struct lfs_stats { - int segsused; - int psegwrites; - int psyncwrites; - int pcleanwrites; - int blocktot; - int cleanblocks; - int ncheckpoints; - int nwrites; - int nsync_writes; - int wait_exceeded; - int write_exceeded; - int flush_invoked; + u_int segsused; + u_int psegwrites; + u_int psyncwrites; + u_int pcleanwrites; + u_int blocktot; + u_int cleanblocks; + u_int ncheckpoints; + u_int nwrites; + u_int nsync_writes; + u_int wait_exceeded; + u_int write_exceeded; + u_int flush_invoked; }; extern struct lfs_stats lfs_stats; #endif diff --git a/usr/src/sys/ufs/ufs/dinode.h b/usr/src/sys/ufs/ufs/dinode.h index f7cad98faa..4553690089 100644 --- a/usr/src/sys/ufs/ufs/dinode.h +++ b/usr/src/sys/ufs/ufs/dinode.h @@ -9,7 +9,7 @@ * * %sccs.include.redist.c% * - * @(#)dinode.h 8.3 (Berkeley) %G% + * @(#)dinode.h 8.4 (Berkeley) %G% */ /* @@ -29,11 +29,11 @@ #define NIADDR 3 /* Indirect addresses in inode. */ struct dinode { - u_short di_mode; /* 0: IFMT and permissions. */ - short di_nlink; /* 2: File link count. */ + u_int16_t di_mode; /* 0: IFMT, permissions; see below. */ + int16_t di_nlink; /* 2: File link count. */ union { - u_short oldids[2]; /* 4: Ffs: old user and group ids. */ - ino_t inumber; /* 4: Lfs: inode number. */ + u_int16_t oldids[2]; /* 4: Ffs: old user and group ids. */ + ino_t inumber; /* 4: Lfs: inode number. */ } di_u; u_quad_t di_size; /* 8: File byte count. */ struct timespec di_atime; /* 16: Last access time. */ @@ -41,12 +41,12 @@ struct dinode { struct timespec di_ctime; /* 32: Last inode change time. */ daddr_t di_db[NDADDR]; /* 40: Direct disk blocks. */ daddr_t di_ib[NIADDR]; /* 88: Indirect disk blocks. */ - u_long di_flags; /* 100: Status flags (chflags). */ - long di_blocks; /* 104: Blocks actually held. */ - long di_gen; /* 108: Generation number. */ - u_long di_uid; /* 112: File owner. */ - u_long di_gid; /* 116: File group. */ - long di_spare[2]; /* 120: Reserved; currently unused */ + u_int32_t di_flags; /* 100: Status flags (chflags). */ + int32_t di_blocks; /* 104: Blocks actually held. */ + int32_t di_gen; /* 108: Generation number. */ + u_int32_t di_uid; /* 112: File owner. */ + u_int32_t di_gid; /* 116: File group. */ + int32_t di_spare[2]; /* 120: Reserved; currently unused */ }; /* @@ -63,7 +63,7 @@ struct dinode { #define di_shortlink di_db #define MAXSYMLINKLEN ((NDADDR + NIADDR) * sizeof(daddr_t)) -/* File modes. */ +/* File permissions. */ #define IEXEC 0000100 /* Executable. */ #define IWRITE 0000200 /* Writeable. */ #define IREAD 0000400 /* Readable. */ diff --git a/usr/src/sys/ufs/ufs/dir.h b/usr/src/sys/ufs/ufs/dir.h index 68145b47d6..1d4eeaf410 100644 --- a/usr/src/sys/ufs/ufs/dir.h +++ b/usr/src/sys/ufs/ufs/dir.h @@ -9,7 +9,7 @@ * * %sccs.include.redist.c% * - * @(#)dir.h 8.2 (Berkeley) %G% + * @(#)dir.h 8.3 (Berkeley) %G% */ #ifndef _DIR_H_ @@ -44,11 +44,11 @@ #define MAXNAMLEN 255 struct direct { - u_long d_ino; /* inode number of entry */ - u_short d_reclen; /* length of this record */ - u_char d_type; /* file type, see below */ - u_char d_namlen; /* length of string in d_name */ - char d_name[MAXNAMLEN + 1]; /* name with length <= MAXNAMLEN */ + u_int32_t d_ino; /* inode number of entry */ + u_int16_t d_reclen; /* length of this record */ + u_int8_t d_type; /* file type, see below */ + u_int8_t d_namlen; /* length of string in d_name */ + char d_name[MAXNAMLEN + 1];/* name with length <= MAXNAMLEN */ }; /* @@ -78,44 +78,43 @@ struct direct { #if (BYTE_ORDER == LITTLE_ENDIAN) #define DIRSIZ(oldfmt, dp) \ ((oldfmt) ? \ - ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((dp)->d_type+1 + 3) &~ 3)) : \ - ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))) + ((sizeof(struct direct) - (MAXNAMLEN+1)) + (((dp)->d_type+1 + 3) &~ 3)) : \ + ((sizeof(struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3))) #else #define DIRSIZ(oldfmt, dp) \ - ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3)) + ((sizeof(struct direct) - (MAXNAMLEN+1)) + (((dp)->d_namlen+1 + 3) &~ 3)) #endif #define OLDDIRFMT 1 #define NEWDIRFMT 0 /* - * Template for manipulating directories. - * Should use struct direct's, but the name field - * is MAXNAMLEN - 1, and this just won't do. + * Template for manipulating directories. Should use struct direct's, + * but the name field is MAXNAMLEN - 1, and this just won't do. */ struct dirtemplate { - u_long dot_ino; - short dot_reclen; - u_char dot_type; - u_char dot_namlen; - char dot_name[4]; /* must be multiple of 4 */ - u_long dotdot_ino; - short dotdot_reclen; - u_char dotdot_type; - u_char dotdot_namlen; - char dotdot_name[4]; /* ditto */ + u_int32_t dot_ino; + int16_t dot_reclen; + u_int8_t dot_type; + u_int8_t dot_namlen; + char dot_name[4]; /* must be multiple of 4 */ + u_int32_t dotdot_ino; + int16_t dotdot_reclen; + u_int8_t dotdot_type; + u_int8_t dotdot_namlen; + char dotdot_name[4]; /* ditto */ }; /* * This is the old format of directories, sanz type element. */ struct odirtemplate { - u_long dot_ino; - short dot_reclen; - u_short dot_namlen; - char dot_name[4]; /* must be multiple of 4 */ - u_long dotdot_ino; - short dotdot_reclen; - u_short dotdot_namlen; - char dotdot_name[4]; /* ditto */ + u_int32_t dot_ino; + int16_t dot_reclen; + u_int16_t dot_namlen; + char dot_name[4]; /* must be multiple of 4 */ + u_int32_t dotdot_ino; + int16_t dotdot_reclen; + u_int16_t dotdot_namlen; + char dotdot_name[4]; /* ditto */ }; #endif /* !_DIR_H_ */ diff --git a/usr/src/sys/ufs/ufs/inode.h b/usr/src/sys/ufs/ufs/inode.h index 039fd8cb2d..4489485a63 100644 --- a/usr/src/sys/ufs/ufs/inode.h +++ b/usr/src/sys/ufs/ufs/inode.h @@ -9,59 +9,57 @@ * * %sccs.include.redist.c% * - * @(#)inode.h 8.4 (Berkeley) %G% + * @(#)inode.h 8.5 (Berkeley) %G% */ #include /* * Theoretically, directories can be more than 2Gb in length, however, in - * practice this seems unlikely. So, we define the type doff_t as a long - * to keep down the cost of doing lookup on a 32-bit machine. If you are - * porting to a 64-bit architecture, you should make doff_t the same as off_t. + * practice this seems unlikely. So, we define the type doff_t as a 32-bit + * quantity to keep down the cost of doing lookup on a 32-bit machine. */ -#define doff_t long +#define doff_t int32_t /* - * The inode is used to describe each active (or recently active) - * file in the UFS filesystem. It is composed of two types of - * information. The first part is the information that is needed - * only while the file is active (such as the identity of the file - * and linkage to speed its lookup). The second part is the - * permannent meta-data associated with the file which is read - * in from the permanent dinode from long term storage when the - * file becomes active, and is put back when the file is no longer - * being used. + * The inode is used to describe each active (or recently active) file in the + * UFS filesystem. It is composed of two types of information. The first part + * is the information that is needed only while the file is active (such as + * the identity of the file and linkage to speed its lookup). The second part + * is * the permanent meta-data associated with the file which is read in + * from the permanent dinode from long term storage when the file becomes + * active, and is put back when the file is no longer being used. */ struct inode { - struct inode *i_next; /* Hash chain forward. */ + struct inode *i_next; /* Hash chain forward. */ struct inode **i_prev; /* Hash chain back. */ - struct vnode *i_vnode; /* Vnode associated with this inode. */ - struct vnode *i_devvp; /* Vnode for block I/O. */ - u_long i_flag; /* I* flags. */ - dev_t i_dev; /* Device associated with the inode. */ - ino_t i_number; /* The identity of the inode. */ + struct vnode *i_vnode;/* Vnode associated with this inode. */ + struct vnode *i_devvp;/* Vnode for block I/O. */ + u_int32_t i_flag; /* flags, see below */ + dev_t i_dev; /* Device associated with the inode. */ + ino_t i_number; /* The identity of the inode. */ + union { /* Associated filesystem. */ struct fs *fs; /* FFS */ struct lfs *lfs; /* LFS */ } inode_u; #define i_fs inode_u.fs #define i_lfs inode_u.lfs - struct dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */ - u_quad_t i_modrev; /* Revision level for lease. */ - struct lockf *i_lockf; /* Head of byte-level lock list. */ - pid_t i_lockholder; /* DEBUG: holder of inode lock. */ - pid_t i_lockwaiter; /* DEBUG: latest blocked for inode lock. */ + + struct dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */ + u_quad_t i_modrev; /* Revision level for NFS lease. */ + struct lockf *i_lockf;/* Head of byte-level lock list. */ + pid_t i_lockholder; /* DEBUG: holder of inode lock. */ + pid_t i_lockwaiter; /* DEBUG: latest blocked for inode lock. */ /* * Side effects; used during directory lookup. */ - long i_count; /* Size of free slot in directory. */ - doff_t i_endoff; /* End of useful stuff in directory. */ - doff_t i_diroff; /* Offset in dir, where we found last entry. */ - doff_t i_offset; /* Offset of free space in directory. */ - ino_t i_ino; /* Inode number of found directory. */ - u_long i_reclen; /* Size of found directory entry. */ - long i_spare[11]; /* Spares to round up to 128 bytes. */ + int32_t i_count; /* Size of free slot in directory. */ + doff_t i_endoff; /* End of useful stuff in directory. */ + doff_t i_diroff; /* Offset in dir, where we found last entry. */ + doff_t i_offset; /* Offset of free space in directory. */ + ino_t i_ino; /* Inode number of found directory. */ + u_int32_t i_reclen; /* Size of found directory entry. */ /* * The on-disk dinode itself. */ @@ -128,9 +126,9 @@ struct indir { /* This overlays the fid structure (see mount.h). */ struct ufid { - u_short ufid_len; /* Length of structure. */ - u_short ufid_pad; /* Force long alignment. */ - ino_t ufid_ino; /* File number (ino). */ - long ufid_gen; /* Generation number. */ + u_int16_t ufid_len; /* Length of structure. */ + u_int16_t ufid_pad; /* Force 32-bit alignment. */ + ino_t ufid_ino; /* File number (ino). */ + int32_t ufid_gen; /* Generation number. */ }; #endif /* KERNEL */ diff --git a/usr/src/sys/ufs/ufs/quota.h b/usr/src/sys/ufs/ufs/quota.h index db96d1fa98..071ae7a5c0 100644 --- a/usr/src/sys/ufs/ufs/quota.h +++ b/usr/src/sys/ufs/ufs/quota.h @@ -7,7 +7,7 @@ * * %sccs.include.redist.c% * - * @(#)quota.h 8.1 (Berkeley) %G% + * @(#)quota.h 8.2 (Berkeley) %G% */ #ifndef _QUOTA_ @@ -22,8 +22,8 @@ * failure). The timer is started when the user crosses their soft limit, it * is reset when they go below their soft limit. */ -#define MAX_IQ_TIME (7*24*60*60) /* 1 week */ -#define MAX_DQ_TIME (7*24*60*60) /* 1 week */ +#define MAX_IQ_TIME (7*24*60*60) /* seconds in 1 week */ +#define MAX_DQ_TIME (7*24*60*60) /* seconds in 1 week */ /* * The following constants define the usage of the quota file array in the @@ -70,15 +70,15 @@ * the vnode for each quota file (a pointer is retained in the ufsmount * structure). */ -struct dqblk { - u_long dqb_bhardlimit; /* absolute limit on disk blks alloc */ - u_long dqb_bsoftlimit; /* preferred limit on disk blks */ - u_long dqb_curblocks; /* current block count */ - u_long dqb_ihardlimit; /* maximum # allocated inodes + 1 */ - u_long dqb_isoftlimit; /* preferred inode limit */ - u_long dqb_curinodes; /* current # allocated inodes */ - time_t dqb_btime; /* time limit for excessive disk use */ - time_t dqb_itime; /* time limit for excessive files */ +struct dqblk { + u_int32_t dqb_bhardlimit; /* absolute limit on disk blks alloc */ + u_int32_t dqb_bsoftlimit; /* preferred limit on disk blks */ + u_int32_t dqb_curblocks; /* current block count */ + u_int32_t dqb_ihardlimit; /* maximum # allocated inodes + 1 */ + u_int32_t dqb_isoftlimit; /* preferred inode limit */ + u_int32_t dqb_curinodes; /* current # allocated inodes */ + time_t dqb_btime; /* time limit for excessive disk use */ + time_t dqb_itime; /* time limit for excessive files */ }; /* @@ -87,14 +87,14 @@ struct dqblk { * filesystem for the current user or group. A cache is kept of recently * used entries. */ -struct dquot { - struct dquot *dq_forw, **dq_back; /* hash list */ - struct dquot *dq_freef, **dq_freeb; /* free list */ - short dq_flags; /* flags, see below */ - short dq_cnt; /* count of active references */ - short dq_spare; /* unused spare padding */ - short dq_type; /* quota type of this dquot */ - u_long dq_id; /* identifier this applies to */ +struct dquot { + struct dquot *dq_forw, **dq_back; /* hash list */ + struct dquot *dq_freef, **dq_freeb; /* free list */ + u_int16_t dq_flags; /* flags, see below */ + u_int16_t dq_cnt; /* count of active references */ + u_int16_t dq_spare; /* unused spare padding */ + u_int16_t dq_type; /* quota type of this dquot */ + u_int32_t dq_id; /* identifier this applies to */ struct ufsmount *dq_ump; /* filesystem that this is taken from */ struct dqblk dq_dqb; /* actual usage & quotas */ }; @@ -120,11 +120,11 @@ struct dquot { #define dq_itime dq_dqb.dqb_itime /* - * If the system has never checked for a quota for this file, then it is set - * to NODQUOT. Once a write attempt is made the inode pointer is set to - * reference a dquot structure. + * If the system has never checked for a quota for this file, then it is + * set to NODQUOT. Once a write attempt is made the inode pointer is set + * to reference a dquot structure. */ -#define NODQUOT ((struct dquot *) 0) +#define NODQUOT NULL /* * Flags to chkdq() and chkiq() diff --git a/usr/src/sys/ufs/ufs/ufsmount.h b/usr/src/sys/ufs/ufs/ufsmount.h index 4d6e52572c..06d830b777 100644 --- a/usr/src/sys/ufs/ufs/ufsmount.h +++ b/usr/src/sys/ufs/ufs/ufsmount.h @@ -4,7 +4,7 @@ * * %sccs.include.redist.c% * - * @(#)ufsmount.h 8.2 (Berkeley) %G% + * @(#)ufsmount.h 8.3 (Berkeley) %G% */ struct buf; @@ -21,12 +21,14 @@ struct ufsmount { struct mount *um_mountp; /* filesystem vfs structure */ dev_t um_dev; /* device mounted */ struct vnode *um_devvp; /* block device mounted vnode */ + union { /* pointer to superblock */ struct lfs *lfs; /* LFS */ struct fs *fs; /* FFS */ } ufsmount_u; #define um_fs ufsmount_u.fs #define um_lfs ufsmount_u.lfs + struct vnode *um_quotas[MAXQUOTAS]; /* pointer to quota files */ struct ucred *um_cred[MAXQUOTAS]; /* quota file access cred */ u_long um_nindir; /* indirect ptrs per block */ @@ -37,6 +39,7 @@ struct ufsmount { char um_qflags[MAXQUOTAS]; /* quota specific flags */ struct netexport um_export; /* export information */ }; + /* * Flags describing the state of quotas. */ @@ -50,8 +53,6 @@ struct ufsmount { * Macros to access file system parameters in the ufsmount structure. * Used by ufs_bmap. */ -#define blkptrtodb(ump, b) ((b) << (ump)->um_bptrtodb) -#define is_sequential(ump, a, b) ((b) == (a) + ump->um_seqinc) -#define MNINDIR(ump) ((ump)->um_nindir) - - +#define MNINDIR(ump) ((ump)->um_nindir) +#define blkptrtodb(ump, b) ((b) << (ump)->um_bptrtodb) +#define is_sequential(ump, a, b) ((b) == (a) + ump->um_seqinc) -- 2.20.1