On Fri, May 29, 2020 at 09:30:04AM +0200, Otto Moerbeek wrote:
> On Thu, May 28, 2020 at 12:54:41PM -0600, Todd C. Miller wrote:
>
> > On Thu, 28 May 2020 20:53:07 +0200, Otto Moerbeek wrote:
> >
> > > Here's the separate diff for the prefcg loops. From FreeBSD.
> >
> > OK millert@
> >
> > - todd
> >
>
> And here's the updated diff against -current. I removed a redundant
> cast in a fs_ipg * fs_ncg multiplication in fsck_ffs. Since both are
> u_int32 and we know the product is <= UINT_MAX, so we do not need to
> cast.
>
> I would like to make some progress here, I have a followup diff to
> speed up Phase 5 of fsck_ffs...
Did anyone look closer at this?
Did anyone test?
-Otto
>
> Index: sbin/clri/clri.c
> ===================================================================
> RCS file: /cvs/src/sbin/clri/clri.c,v
> retrieving revision 1.20
> diff -u -p -r1.20 clri.c
> --- sbin/clri/clri.c 28 Jun 2019 13:32:43 -0000 1.20
> +++ sbin/clri/clri.c 29 May 2020 07:23:27 -0000
> @@ -68,7 +68,8 @@ main(int argc, char *argv[])
> char *fs, sblock[SBLOCKSIZE];
> size_t bsize;
> off_t offset;
> - int i, fd, imax, inonum;
> + int i, fd;
> + ino_t imax, inonum;
>
> if (argc < 3)
> usage();
> Index: sbin/dumpfs/dumpfs.c
> ===================================================================
> RCS file: /cvs/src/sbin/dumpfs/dumpfs.c,v
> retrieving revision 1.35
> diff -u -p -r1.35 dumpfs.c
> --- sbin/dumpfs/dumpfs.c 17 Feb 2020 16:11:25 -0000 1.35
> +++ sbin/dumpfs/dumpfs.c 29 May 2020 07:23:27 -0000
> @@ -69,7 +69,7 @@ union {
> #define acg cgun.cg
>
> int dumpfs(int, const char *);
> -int dumpcg(const char *, int, int);
> +int dumpcg(const char *, int, u_int);
> int marshal(const char *);
> int open_disk(const char *);
> void pbits(void *, int);
> @@ -163,6 +163,7 @@ dumpfs(int fd, const char *name)
> size_t size;
> off_t off;
> int i, j;
> + u_int cg;
>
> switch (afs.fs_magic) {
> case FS_UFS2_MAGIC:
> @@ -172,7 +173,7 @@ dumpfs(int fd, const char *name)
> afs.fs_magic, ctime(&fstime));
> printf("superblock location\t%jd\tid\t[ %x %x ]\n",
> (intmax_t)afs.fs_sblockloc, afs.fs_id[0], afs.fs_id[1]);
> - printf("ncg\t%d\tsize\t%jd\tblocks\t%jd\n",
> + printf("ncg\t%u\tsize\t%jd\tblocks\t%jd\n",
> afs.fs_ncg, (intmax_t)fssize, (intmax_t)afs.fs_dsize);
> break;
> case FS_UFS1_MAGIC:
> @@ -198,7 +199,7 @@ dumpfs(int fd, const char *name)
> printf("cylgrp\t%s\tinodes\t%s\tfslevel %d\n",
> i < 1 ? "static" : "dynamic",
> i < 2 ? "4.2/4.3BSD" : "4.4BSD", i);
> - printf("ncg\t%d\tncyl\t%d\tsize\t%d\tblocks\t%d\n",
> + printf("ncg\t%u\tncyl\t%d\tsize\t%d\tblocks\t%d\n",
> afs.fs_ncg, afs.fs_ncyl, afs.fs_ffs1_size,
> afs.fs_ffs1_dsize);
> break;
> default:
> @@ -223,9 +224,9 @@ dumpfs(int fd, const char *name)
> (intmax_t)afs.fs_cstotal.cs_ndir,
> (intmax_t)afs.fs_cstotal.cs_nifree,
> (intmax_t)afs.fs_cstotal.cs_nffree);
> - printf("bpg\t%d\tfpg\t%d\tipg\t%d\n",
> + printf("bpg\t%d\tfpg\t%d\tipg\t%u\n",
> afs.fs_fpg / afs.fs_frag, afs.fs_fpg, afs.fs_ipg);
> - printf("nindir\t%d\tinopb\t%d\tmaxfilesize\t%ju\n",
> + printf("nindir\t%d\tinopb\t%u\tmaxfilesize\t%ju\n",
> afs.fs_nindir, afs.fs_inopb,
> (uintmax_t)afs.fs_maxfilesize);
> printf("sbsize\t%d\tcgsize\t%d\tcsaddr\t%jd\tcssize\t%d\n",
> @@ -238,10 +239,10 @@ dumpfs(int fd, const char *name)
> printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n",
> afs.fs_ffs1_cstotal.cs_nbfree, afs.fs_ffs1_cstotal.cs_ndir,
> afs.fs_ffs1_cstotal.cs_nifree,
> afs.fs_ffs1_cstotal.cs_nffree);
> - printf("cpg\t%d\tbpg\t%d\tfpg\t%d\tipg\t%d\n",
> + printf("cpg\t%d\tbpg\t%d\tfpg\t%d\tipg\t%u\n",
> afs.fs_cpg, afs.fs_fpg / afs.fs_frag, afs.fs_fpg,
> afs.fs_ipg);
> - printf("nindir\t%d\tinopb\t%d\tnspf\t%d\tmaxfilesize\t%ju\n",
> + printf("nindir\t%d\tinopb\t%u\tnspf\t%d\tmaxfilesize\t%ju\n",
> afs.fs_nindir, afs.fs_inopb, afs.fs_nspf,
> (uintmax_t)afs.fs_maxfilesize);
> printf("sbsize\t%d\tcgsize\t%d\tcgoffset %d\tcgmask\t0x%08x\n",
> @@ -261,7 +262,7 @@ dumpfs(int fd, const char *name)
> afs.fs_sblkno, afs.fs_cblkno, afs.fs_iblkno, afs.fs_dblkno);
> printf("cgrotor\t%d\tfmod\t%d\tronly\t%d\tclean\t%d\n",
> afs.fs_cgrotor, afs.fs_fmod, afs.fs_ronly, afs.fs_clean);
> - printf("avgfpdir %d\tavgfilesize %d\n",
> + printf("avgfpdir %u\tavgfilesize %u\n",
> afs.fs_avgfpdir, afs.fs_avgfilesize);
> printf("flags\t");
> if (afs.fs_magic == FS_UFS2_MAGIC ||
> @@ -296,8 +297,8 @@ dumpfs(int fd, const char *name)
> if (pread(fd, (char *)afs.fs_csp + i, size, off) != size)
> goto err;
> }
> - for (i = 0; i < afs.fs_ncg; i++) {
> - struct csum *cs = &afs.fs_cs(&afs, i);
> + for (cg = 0; cg < afs.fs_ncg; cg++) {
> + struct csum *cs = &afs.fs_cs(&afs, cg);
> if (i && i % 4 == 0)
> printf("\n\t");
> printf("(%d,%d,%d,%d) ",
> @@ -312,8 +313,8 @@ dumpfs(int fd, const char *name)
> printf("blocks in last group %ld\n\n",
> (long)((fssize % afs.fs_fpg) / afs.fs_frag));
> }
> - for (i = 0; i < afs.fs_ncg; i++)
> - if (dumpcg(name, fd, i))
> + for (cg = 0; cg < afs.fs_ncg; cg++)
> + if (dumpcg(name, fd, cg))
> goto err;
> return (0);
>
> @@ -322,13 +323,13 @@ err: warn("%s", name);
> }
>
> int
> -dumpcg(const char *name, int fd, int c)
> +dumpcg(const char *name, int fd, u_int c)
> {
> time_t cgtime;
> off_t cur;
> int i, j;
>
> - printf("\ncg %d:\n", c);
> + printf("\ncg %u:\n", c);
> cur = (off_t)fsbtodb(&afs, cgtod(&afs, c)) * DEV_BSIZE;
> if (pread(fd, &acg, afs.fs_bsize, cur) != afs.fs_bsize) {
> warn("%s: error reading cg", name);
> @@ -339,7 +340,7 @@ dumpcg(const char *name, int fd, int c)
> cgtime = acg.cg_ffs2_time;
> printf("magic\t%x\ttell\t%jx\ttime\t%s",
> acg.cg_magic, (intmax_t)cur, ctime(&cgtime));
> - printf("cgx\t%d\tndblk\t%d\tniblk\t%d\tinitiblk %d\n",
> + printf("cgx\t%u\tndblk\t%u\tniblk\t%u\tinitiblk %u\n",
> acg.cg_cgx, acg.cg_ndblk, acg.cg_ffs2_niblk,
> acg.cg_initediblk);
> break;
> @@ -349,7 +350,7 @@ dumpcg(const char *name, int fd, int c)
> afs.fs_postblformat == FS_42POSTBLFMT ?
> ((struct ocg *)&acg)->cg_magic : acg.cg_magic,
> (intmax_t)cur, ctime(&cgtime));
> - printf("cgx\t%d\tncyl\t%d\tniblk\t%d\tndblk\t%d\n",
> + printf("cgx\t%u\tncyl\t%d\tniblk\t%d\tndblk\t%u\n",
> acg.cg_cgx, acg.cg_ncyl, acg.cg_niblk, acg.cg_ndblk);
> break;
> default:
> @@ -358,10 +359,10 @@ dumpcg(const char *name, int fd, int c)
> printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n",
> acg.cg_cs.cs_nbfree, acg.cg_cs.cs_ndir,
> acg.cg_cs.cs_nifree, acg.cg_cs.cs_nffree);
> - printf("rotor\t%d\tirotor\t%d\tfrotor\t%d\nfrsum",
> + printf("rotor\t%u\tirotor\t%u\tfrotor\t%u\nfrsum",
> acg.cg_rotor, acg.cg_irotor, acg.cg_frotor);
> for (i = 1, j = 0; i < afs.fs_frag; i++) {
> - printf("\t%d", acg.cg_frsum[i]);
> + printf("\t%u", acg.cg_frsum[i]);
> j += i * acg.cg_frsum[i];
> }
> printf("\nsum of frsum: %d", j);
> @@ -416,8 +417,8 @@ marshal(const char *name)
> /* -c unimplemented */
> printf("-e %d ", afs.fs_maxbpg);
> printf("-f %d ", afs.fs_fsize);
> - printf("-g %d ", afs.fs_avgfilesize);
> - printf("-h %d ", afs.fs_avgfpdir);
> + printf("-g %u ", afs.fs_avgfilesize);
> + printf("-h %u ", afs.fs_avgfpdir);
> /* -i unimplemented */
> printf("-m %d ", afs.fs_minfree);
> printf("-o ");
> Index: sbin/fsck_ffs/pass1.c
> ===================================================================
> RCS file: /cvs/src/sbin/fsck_ffs/pass1.c,v
> retrieving revision 1.45
> diff -u -p -r1.45 pass1.c
> --- sbin/fsck_ffs/pass1.c 12 Apr 2017 15:23:08 -0000 1.45
> +++ sbin/fsck_ffs/pass1.c 29 May 2020 07:23:27 -0000
> @@ -66,7 +66,7 @@ pass1(void)
> ino_t inumber, inosused, ninosused;
> size_t inospace;
> struct inostat *info;
> - int c;
> + u_int c;
> struct inodesc idesc;
> daddr_t i, cgd;
> u_int8_t *cp;
> Index: sbin/fsck_ffs/pass1b.c
> ===================================================================
> RCS file: /cvs/src/sbin/fsck_ffs/pass1b.c,v
> retrieving revision 1.21
> diff -u -p -r1.21 pass1b.c
> --- sbin/fsck_ffs/pass1b.c 20 Jan 2015 18:22:21 -0000 1.21
> +++ sbin/fsck_ffs/pass1b.c 29 May 2020 07:23:27 -0000
> @@ -55,7 +55,7 @@ pass1b_info(char *buf, size_t buflen)
> void
> pass1b(void)
> {
> - int c, i;
> + u_int c, i;
> union dinode *dp;
> struct inodesc idesc;
> ino_t inumber;
> Index: sbin/fsck_ffs/pass4.c
> ===================================================================
> RCS file: /cvs/src/sbin/fsck_ffs/pass4.c,v
> retrieving revision 1.25
> diff -u -p -r1.25 pass4.c
> --- sbin/fsck_ffs/pass4.c 13 Apr 2017 07:30:21 -0000 1.25
> +++ sbin/fsck_ffs/pass4.c 29 May 2020 07:23:27 -0000
> @@ -59,7 +59,8 @@ pass4(void)
> struct zlncnt *zlnp;
> union dinode *dp;
> struct inodesc idesc;
> - int n, c, i;
> + int n, i;
> + u_int c;
>
> memset(&idesc, 0, sizeof(struct inodesc));
> idesc.id_type = ADDR;
> Index: sbin/fsck_ffs/pass5.c
> ===================================================================
> RCS file: /cvs/src/sbin/fsck_ffs/pass5.c,v
> retrieving revision 1.48
> diff -u -p -r1.48 pass5.c
> --- sbin/fsck_ffs/pass5.c 20 Jan 2015 18:22:21 -0000 1.48
> +++ sbin/fsck_ffs/pass5.c 29 May 2020 07:23:27 -0000
> @@ -48,26 +48,28 @@
>
> #define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
>
> -static int info_cg;
> -static int info_maxcg;
> +static u_int info_cg;
> +static u_int info_maxcg;
>
> static int
> pass5_info(char *buf, size_t buflen)
> {
> - return (snprintf(buf, buflen, "phase 5, cg %d/%d",
> + return (snprintf(buf, buflen, "phase 5, cg %u/%u",
> info_cg, info_maxcg) > 0);
> }
>
> void
> pass5(void)
> {
> - int c, blk, frags, basesize, sumsize, mapsize, savednrpos=0;
> + int blk, frags, basesize, sumsize, mapsize, savednrpos=0;
> + u_int c;
> int inomapsize, blkmapsize;
> struct fs *fs = &sblock;
> struct cg *cg = &cgrp;
> daddr_t dbase, dmax;
> daddr_t d;
> - long i, j, k, rewritecg = 0;
> + long i, k, rewritecg = 0;
> + ino_t j;
> struct csum *cs;
> struct csum_total cstotal;
> struct inodesc idesc[3];
> @@ -179,7 +181,7 @@ pass5(void)
> info_cg = c;
> getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize);
> if (!cg_chkmagic(cg))
> - pfatal("CG %d: BAD MAGIC NUMBER\n", c);
> + pfatal("CG %u: BAD MAGIC NUMBER\n", c);
> dbase = cgbase(fs, c);
> dmax = dbase + fs->fs_fpg;
> if (dmax > fs->fs_size)
> @@ -215,7 +217,7 @@ pass5(void)
> newcg->cg_irotor = cg->cg_irotor;
> } else {
> newcg->cg_ncyl = 0;
> - if ((unsigned)cg->cg_initediblk > fs->fs_ipg)
> + if (cg->cg_initediblk > fs->fs_ipg)
> newcg->cg_initediblk = fs->fs_ipg;
> else
> newcg->cg_initediblk = cg->cg_initediblk;
> @@ -339,8 +341,8 @@ pass5(void)
> continue;
> if (cg_inosused(cg)[i] & (1 << k))
> continue;
> - pwarn("ALLOCATED INODE %lld MARKED
> FREE\n",
> - ((long long)c * fs->fs_ipg + i *
> 8) + k);
> + pwarn("ALLOCATED INODE %llu MARKED
> FREE\n",
> + ((ino_t)c * fs->fs_ipg + i * 8) +
> k);
> }
> }
> for (i = 0; i < blkmapsize; i++) {
> Index: sbin/fsck_ffs/setup.c
> ===================================================================
> RCS file: /cvs/src/sbin/fsck_ffs/setup.c,v
> retrieving revision 1.66
> diff -u -p -r1.66 setup.c
> --- sbin/fsck_ffs/setup.c 28 Jun 2019 13:32:43 -0000 1.66
> +++ sbin/fsck_ffs/setup.c 29 May 2020 07:23:27 -0000
> @@ -366,7 +366,7 @@ found:
> else
> inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);
> if (INOPB(&sblock) != inopb) {
> - pwarn("INCONSISTENT INOPB=%d\n", INOPB(&sblock));
> + pwarn("INCONSISTENT INOPB=%u\n", INOPB(&sblock));
> sblock.fs_inopb = inopb;
> if (preen)
> printf(" (FIXED)\n");
> Index: sbin/fsck_ffs/utilities.c
> ===================================================================
> RCS file: /cvs/src/sbin/fsck_ffs/utilities.c,v
> retrieving revision 1.52
> diff -u -p -r1.52 utilities.c
> --- sbin/fsck_ffs/utilities.c 6 Feb 2019 13:26:13 -0000 1.52
> +++ sbin/fsck_ffs/utilities.c 29 May 2020 07:23:27 -0000
> @@ -581,7 +581,7 @@ dofix(struct inodesc *idesc, char *msg)
> return (0);
>
> default:
> - errexit("UNKNOWN INODESC FIX MODE %d\n", idesc->id_fix);
> + errexit("UNKNOWN INODESC FIX MODE %u\n", idesc->id_fix);
> }
> /* NOTREACHED */
> }
> Index: sbin/fsirand/fsirand.c
> ===================================================================
> RCS file: /cvs/src/sbin/fsirand/fsirand.c,v
> retrieving revision 1.42
> diff -u -p -r1.42 fsirand.c
> --- sbin/fsirand/fsirand.c 17 Feb 2020 19:00:58 -0000 1.42
> +++ sbin/fsirand/fsirand.c 29 May 2020 07:23:27 -0000
> @@ -101,7 +101,8 @@ fsirand(char *device)
> ino_t inumber;
> daddr_t sblockloc, dblk;
> char sbuf[SBSIZE], sbuftmp[SBSIZE];
> - int devfd, n, cg, i;
> + int devfd, n, i;
> + u_int cg;
> char *devpath, *ib;
> u_int32_t bsize = DEV_BSIZE;
> struct disklabel label;
> Index: sbin/growfs/growfs.c
> ===================================================================
> RCS file: /cvs/src/sbin/growfs/growfs.c,v
> retrieving revision 1.53
> diff -u -p -r1.53 growfs.c
> --- sbin/growfs/growfs.c 3 Jul 2019 03:24:01 -0000 1.53
> +++ sbin/growfs/growfs.c 29 May 2020 07:23:27 -0000
> @@ -136,8 +136,8 @@ static void usage(void);
> static int isblock(struct fs *, unsigned char *, int);
> static void clrblock(struct fs *, unsigned char *, int);
> static void setblock(struct fs *, unsigned char *, int);
> -static void initcg(int, time_t, int, unsigned int);
> -static void updjcg(int, time_t, int, int, unsigned int);
> +static void initcg(u_int, time_t, int, unsigned int);
> +static void updjcg(u_int, time_t, int, int, unsigned int);
> static void updcsloc(time_t, int, int, unsigned int);
> static struct disklabel *get_disklabel(int);
> static void return_disklabel(int, struct disklabel *, unsigned int);
> @@ -167,8 +167,8 @@ int colwidth;
> static void
> growfs(int fsi, int fso, unsigned int Nflag)
> {
> - int i;
> - int cylno, j;
> + int i, j;
> + u_int cg;
> time_t utime;
> char tmpbuf[100];
>
> @@ -199,7 +199,7 @@ growfs(int fsi, int fso, unsigned int Nf
> (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
> (intmax_t)fsbtodb(&sblock, sblock.fs_size), sblock.fs_bsize,
> sblock.fs_fsize);
> - printf("\tusing %d cylinder groups of %.2fMB, %d blks, %d inodes.\n",
> + printf("\tusing %u cylinder groups of %.2fMB, %d blks, %u inodes.\n",
> sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
> sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);
> if (sblock.fs_flags & FS_DOSOFTDEP)
> @@ -217,13 +217,13 @@ growfs(int fsi, int fso, unsigned int Nf
> /*
> * Iterate for only the new cylinder groups.
> */
> - for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
> - initcg(cylno, utime, fso, Nflag);
> + for (cg = osblock.fs_ncg; cg < sblock.fs_ncg; cg++) {
> + initcg(cg, utime, fso, Nflag);
> if (quiet)
> continue;
> j = snprintf(tmpbuf, sizeof(tmpbuf), " %lld%s",
> - fsbtodb(&sblock, cgsblock(&sblock, cylno)),
> - cylno < (sblock.fs_ncg - 1) ? "," : "");
> + fsbtodb(&sblock, cgsblock(&sblock, cg)),
> + cg < (sblock.fs_ncg - 1) ? "," : "");
> if (j >= sizeof(tmpbuf))
> j = sizeof(tmpbuf) - 1;
> if (j < 0 || i + j >= colwidth) {
> @@ -310,8 +310,8 @@ growfs(int fsi, int fso, unsigned int Nf
> /*
> * Write out the duplicate superblocks.
> */
> - for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
> - wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
> + for (cg = 0; cg < sblock.fs_ncg; cg++) {
> + wtfs(fsbtodb(&sblock, cgsblock(&sblock, cg)),
> (size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);
> }
> }
> @@ -323,7 +323,7 @@ growfs(int fsi, int fso, unsigned int Nf
> * provisions for that case are removed here.
> */
> static void
> -initcg(int cylno, time_t utime, int fso, unsigned int Nflag)
> +initcg(u_int cg, time_t utime, int fso, unsigned int Nflag)
> {
> static char *iobuf;
> daddr_t d, dlower, dupper, blkno, start;
> @@ -348,19 +348,19 @@ initcg(int cylno, time_t utime, int fso,
> * Allow space for super block summary information in first
> * cylinder group.
> */
> - cbase = cgbase(&sblock, cylno);
> + cbase = cgbase(&sblock, cg);
> dmax = cbase + sblock.fs_fpg;
> if (dmax > sblock.fs_size)
> dmax = sblock.fs_size;
> - dlower = cgsblock(&sblock, cylno) - cbase;
> - dupper = cgdmin(&sblock, cylno) - cbase;
> - if (cylno == 0) /* XXX fscs may be relocated */
> + dlower = cgsblock(&sblock, cg) - cbase;
> + dupper = cgdmin(&sblock, cg) - cbase;
> + if (cg == 0) /* XXX fscs may be relocated */
> dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
> - cs = &fscs[cylno];
> + cs = &fscs[cg];
> memset(&acg, 0, sblock.fs_cgsize);
> acg.cg_ffs2_time = utime;
> acg.cg_magic = CG_MAGIC;
> - acg.cg_cgx = cylno;
> + acg.cg_cgx = cg;
> acg.cg_ffs2_niblk = sblock.fs_ipg;
> acg.cg_initediblk = MINIMUM(sblock.fs_ipg, 2 * INOPB(&sblock));
> acg.cg_ndblk = dmax - cbase;
> @@ -370,7 +370,7 @@ initcg(int cylno, time_t utime, int fso,
> if (sblock.fs_magic == FS_UFS2_MAGIC) {
> acg.cg_iusedoff = start;
> } else {
> - if (cylno == sblock.fs_ncg - 1)
> + if (cg == sblock.fs_ncg - 1)
> acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
> else
> acg.cg_ncyl = sblock.fs_cpg;
> @@ -404,15 +404,15 @@ initcg(int cylno, time_t utime, int fso,
> errx(37, "panic: cylinder group too big");
> }
> acg.cg_cs.cs_nifree += sblock.fs_ipg;
> - if (cylno == 0) {
> + if (cg == 0) {
> for (i = 0; i < ROOTINO; i++) {
> setbit(cg_inosused(&acg), i);
> acg.cg_cs.cs_nifree--;
> }
> }
> - if (cylno > 0) {
> + if (cg > 0) {
> /*
> - * In cylno 0, beginning space is reserved
> + * In cg 0, beginning space is reserved
> * for boot and super blocks.
> */
> for (d = 0; d < dlower; d += sblock.fs_frag) {
> @@ -501,7 +501,7 @@ initcg(int cylno, time_t utime, int fso,
> dp2++;
> }
> }
> - wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), iobufsize,
> + wtfs(fsbtodb(&sblock, cgsblock(&sblock, cg)), iobufsize,
> iobuf, fso, Nflag);
>
> /* Initialize inodes for FFS1. */
> @@ -513,7 +513,7 @@ initcg(int cylno, time_t utime, int fso,
> dp1->di_gen = arc4random();
> dp1++;
> }
> - wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
> + wtfs(fsbtodb(&sblock, cgimin(&sblock, cg) + i),
> (size_t)sblock.fs_bsize, &iobuf[start], fso, Nflag);
> }
> }
> @@ -626,7 +626,7 @@ cond_bl_upd(daddr_t *block, struct gfs_b
> * tables and cluster summary during all those operations.
> */
> static void
> -updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag)
> +updjcg(u_int cg, time_t utime, int fsi, int fso, unsigned int Nflag)
> {
> daddr_t cbase, dmax, dupper;
> struct csum *cs;
> @@ -637,7 +637,7 @@ updjcg(int cylno, time_t utime, int fsi,
> * Read the former last (joining) cylinder group from disk, and make
> * a copy.
> */
> - rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)),
> + rdfs(fsbtodb(&osblock, cgtod(&osblock, cg)),
> (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
>
> memcpy(&cgun1, &cgun2, sizeof(cgun2));
> @@ -649,11 +649,11 @@ updjcg(int cylno, time_t utime, int fsi,
> * to be zero instead of fs_cpg. As this is now no longer the last
> * cylinder group we have to change that value now to fs_cpg.
> */
> - if (cgbase(&osblock, cylno+1) == osblock.fs_size) {
> + if (cgbase(&osblock, cg+1) == osblock.fs_size) {
> if (sblock.fs_magic == FS_UFS1_MAGIC)
> acg.cg_ncyl = sblock.fs_cpg;
>
> - wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
> + wtfs(fsbtodb(&sblock, cgtod(&sblock, cg)),
> (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
>
> return;
> @@ -662,18 +662,18 @@ updjcg(int cylno, time_t utime, int fsi,
> /*
> * Set up some variables needed later.
> */
> - cbase = cgbase(&sblock, cylno);
> + cbase = cgbase(&sblock, cg);
> dmax = cbase + sblock.fs_fpg;
> if (dmax > sblock.fs_size)
> dmax = sblock.fs_size;
> - dupper = cgdmin(&sblock, cylno) - cbase;
> - if (cylno == 0) /* XXX fscs may be relocated */
> + dupper = cgdmin(&sblock, cg) - cbase;
> + if (cg == 0) /* XXX fscs may be relocated */
> dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
>
> /*
> * Set pointer to the cylinder summary for our cylinder group.
> */
> - cs = fscs + cylno;
> + cs = fscs + cg;
>
> /*
> * Touch the cylinder group, update all fields in the cylinder group as
> @@ -681,7 +681,7 @@ updjcg(int cylno, time_t utime, int fsi,
> */
> acg.cg_time = utime;
> if (sblock.fs_magic == FS_UFS1_MAGIC) {
> - if (cylno == sblock.fs_ncg - 1) {
> + if (cg == sblock.fs_ncg - 1) {
> /*
> * This is still the last cylinder group.
> */
> @@ -727,7 +727,7 @@ updjcg(int cylno, time_t utime, int fsi,
> * filesystem.
> */
> if (isblock(&sblock, cg_blksfree(&acg),
> - ((osblock.fs_size - cgbase(&sblock, cylno))/
> + ((osblock.fs_size - cgbase(&sblock, cg))/
> sblock.fs_frag))) {
> /*
> * The block is now completely available.
> @@ -822,7 +822,7 @@ updjcg(int cylno, time_t utime, int fsi,
> /*
> * Write the updated "joining" cylinder group back to disk.
> */
> - wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
> + wtfs(fsbtodb(&sblock, cgtod(&sblock, cg)), (size_t)sblock.fs_cgsize,
> (void *)&acg, fso, Nflag);
> }
>
> @@ -850,7 +850,7 @@ updcsloc(time_t utime, int fsi, int fso,
> int blocks;
> daddr_t cbase, dupper, odupper, d, f, g;
> int ind;
> - int cylno, inc;
> + u_int cg, inc;
> struct gfs_bpp *bp;
> int i, l;
> int lcs = 0;
> @@ -1337,9 +1337,9 @@ updcsloc(time_t utime, int fsi, int fso,
> * cylinder groups, within those over all non zero length
> * inodes.
> */
> - for (cylno = 0; cylno < osblock.fs_ncg; cylno++) {
> + for (cg = 0; cg < osblock.fs_ncg; cg++) {
> for (inc = osblock.fs_ipg - 1; inc > 0; inc--) {
> - updrefs(cylno, (ino_t)inc, bp, fsi, fso, Nflag);
> + updrefs(cg, (ino_t)inc, bp, fsi, fso, Nflag);
> }
> }
>
> @@ -1906,6 +1906,8 @@ main(int argc, char **argv)
> sblock.fs_ncyl++;
> }
> sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);
> + if ((ino_t)sblock.fs_ncg * sblock.fs_ipg > UINT_MAX)
> + errx(1, "more than 2^32 inodes requested");
> maxino = sblock.fs_ncg * sblock.fs_ipg;
>
> if (sblock.fs_size % sblock.fs_fpg != 0 &&
> Index: sbin/newfs/mkfs.c
> ===================================================================
> RCS file: /cvs/src/sbin/newfs/mkfs.c,v
> retrieving revision 1.100
> diff -u -p -r1.100 mkfs.c
> --- sbin/newfs/mkfs.c 28 May 2020 15:48:29 -0000 1.100
> +++ sbin/newfs/mkfs.c 29 May 2020 07:23:27 -0000
> @@ -131,7 +131,7 @@ static long iobufsize;
> daddr_t alloc(int, int);
> static int charsperline(void);
> static int ilog2(int);
> -void initcg(int, time_t);
> +void initcg(u_int, time_t);
> void wtfs(daddr_t, int, void *);
> int fsinit1(time_t, mode_t, uid_t, gid_t);
> int fsinit2(time_t, mode_t, uid_t, gid_t);
> @@ -170,7 +170,8 @@ mkfs(struct partition *pp, char *fsys, i
> int i, j, width, origdensity, fragsperinode, minfpg, optimalfpg;
> int lastminfpg, mincylgrps;
> uint32_t bpg;
> - long cylno, csfrags;
> + long csfrags;
> + u_int cg;
> char tmpbuf[100]; /* XXX this will break in about 2,500 years */
>
> if ((fsun = calloc(1, sizeof (union fs_u))) == NULL ||
> @@ -427,6 +428,10 @@ mkfs(struct partition *pp, char *fsys, i
> " to %d to enlarge last cylinder group", optimalfpg,
> sblock.fs_fpg);
>
> + if ((ino_t)sblock.fs_ipg * sblock.fs_ncg > UINT_MAX)
> + errx(42, "more than 2^32 inodes, increase density, block or "
> + "fragment size");
> +
> /*
> * Back to filling superblock fields.
> */
> @@ -498,7 +503,7 @@ mkfs(struct partition *pp, char *fsys, i
> (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
> (intmax_t)fsbtodb(&sblock, sblock.fs_size) /
> (sectorsize / DEV_BSIZE), sectorsize);
> - printf("%d cylinder groups of %.2fMB, %d blocks, %d"
> + printf("%u cylinder groups of %.2fMB, %d blocks, %u"
> " inodes each\n", sblock.fs_ncg,
> (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
> sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);
> @@ -558,13 +563,13 @@ mkfs(struct partition *pp, char *fsys, i
> * writing out in each cylinder group.
> */
> bcopy((char *)&sblock, iobuf, SBLOCKSIZE);
> - for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
> - cur_cylno = (sig_atomic_t)cylno;
> - initcg(cylno, utime);
> + for (cg = 0; cg < sblock.fs_ncg; cg++) {
> + cur_cylno = (sig_atomic_t)cg;
> + initcg(cg, utime);
> if (quiet)
> continue;
> j = snprintf(tmpbuf, sizeof tmpbuf, " %lld,",
> - (long long)fsbtodb(&sblock, cgsblock(&sblock, cylno)));
> + (long long)fsbtodb(&sblock, cgsblock(&sblock, cg)));
> if (j >= sizeof tmpbuf)
> j = sizeof tmpbuf - 1;
> if (j < 0 || i+j >= width) {
> @@ -619,9 +624,9 @@ mkfs(struct partition *pp, char *fsys, i
> * Initialize a cylinder group.
> */
> void
> -initcg(int cylno, time_t utime)
> +initcg(u_int cg, time_t utime)
> {
> - int i, j, d, dlower, dupper, blkno, start;
> + u_int i, j, d, dlower, dupper, blkno, start;
> daddr_t cbase, dmax;
> struct ufs1_dinode *dp1;
> struct ufs2_dinode *dp2;
> @@ -631,23 +636,23 @@ initcg(int cylno, time_t utime)
> * Determine block bounds for cylinder group. Allow space for
> * super block summary information in first cylinder group.
> */
> - cbase = cgbase(&sblock, cylno);
> + cbase = cgbase(&sblock, cg);
> dmax = cbase + sblock.fs_fpg;
> if (dmax > sblock.fs_size)
> dmax = sblock.fs_size;
> - if (fsbtodb(&sblock, cgsblock(&sblock, cylno)) + iobufsize / DEV_BSIZE
> + if (fsbtodb(&sblock, cgsblock(&sblock, cg)) + iobufsize / DEV_BSIZE
> > fssize)
> errx(40, "inode table does not fit in cylinder group");
>
> - dlower = cgsblock(&sblock, cylno) - cbase;
> - dupper = cgdmin(&sblock, cylno) - cbase;
> - if (cylno == 0)
> + dlower = cgsblock(&sblock, cg) - cbase;
> + dupper = cgdmin(&sblock, cg) - cbase;
> + if (cg == 0)
> dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
> - cs = &fscs[cylno];
> + cs = &fscs[cg];
> memset(&acg, 0, sblock.fs_cgsize);
> acg.cg_ffs2_time = utime;
> acg.cg_magic = CG_MAGIC;
> - acg.cg_cgx = cylno;
> + acg.cg_cgx = cg;
> acg.cg_ffs2_niblk = sblock.fs_ipg;
> acg.cg_initediblk = MINIMUM(sblock.fs_ipg, 2 * INOPB(&sblock));
> acg.cg_ndblk = dmax - cbase;
> @@ -655,7 +660,7 @@ initcg(int cylno, time_t utime)
> start = sizeof(struct cg);
> if (Oflag <= 1) {
> /* Hack to maintain compatibility with old fsck. */
> - if (cylno == sblock.fs_ncg - 1)
> + if (cg == sblock.fs_ncg - 1)
> acg.cg_ncyl = 0;
> else
> acg.cg_ncyl = sblock.fs_cpg;
> @@ -675,18 +680,18 @@ initcg(int cylno, time_t utime)
> acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
> acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
> if (acg.cg_nextfreeoff > sblock.fs_cgsize)
> - errx(37, "panic: cylinder group too big: %d > %d",
> + errx(37, "panic: cylinder group too big: %u > %d",
> acg.cg_nextfreeoff, sblock.fs_cgsize);
> acg.cg_cs.cs_nifree += sblock.fs_ipg;
> - if (cylno == 0) {
> + if (cg == 0) {
> for (i = 0; i < ROOTINO; i++) {
> setbit(cg_inosused(&acg), i);
> acg.cg_cs.cs_nifree--;
> }
> }
> - if (cylno > 0) {
> + if (cg > 0) {
> /*
> - * In cylno 0, space is reserved for boot and super blocks.
> + * In cg 0, space is reserved for boot and super blocks.
> */
> for (d = 0; d < dlower; d += sblock.fs_frag) {
> blkno = d / sblock.fs_frag;
> @@ -732,6 +737,10 @@ initcg(int cylno, time_t utime)
> * and two blocks worth of inodes in a single write.
> */
> start = sblock.fs_bsize > SBLOCKSIZE ? sblock.fs_bsize : SBLOCKSIZE;
> +
> + if (cg == 0 && acg.cg_cs.cs_nbfree == 0)
> + errx(42, "cg 0: summary info is too large to fit");
> +
> bcopy((char *)&acg, &iobuf[start], sblock.fs_cgsize);
> start += sblock.fs_bsize;
> dp1 = (struct ufs1_dinode *)(&iobuf[start]);
> @@ -745,7 +754,7 @@ initcg(int cylno, time_t utime)
> dp2++;
> }
> }
> - wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), iobufsize, iobuf);
> + wtfs(fsbtodb(&sblock, cgsblock(&sblock, cg)), iobufsize, iobuf);
>
> if (Oflag <= 1) {
> /* Initialize inodes for FFS1. */
> @@ -757,7 +766,7 @@ initcg(int cylno, time_t utime)
> dp1->di_gen = arc4random();
> dp1++;
> }
> - wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
> + wtfs(fsbtodb(&sblock, cgimin(&sblock, cg) + i),
> sblock.fs_bsize, &iobuf[start]);
> }
> }
> Index: sys/ufs/ffs/ffs_alloc.c
> ===================================================================
> RCS file: /cvs/src/sys/ufs/ffs/ffs_alloc.c,v
> retrieving revision 1.112
> diff -u -p -r1.112 ffs_alloc.c
> --- sys/ufs/ffs/ffs_alloc.c 29 May 2020 06:46:15 -0000 1.112
> +++ sys/ufs/ffs/ffs_alloc.c 29 May 2020 07:23:29 -0000
> @@ -63,14 +63,14 @@
> (fs)->fs_fsmnt, (cp)); \
> } while (0)
>
> -daddr_t ffs_alloccg(struct inode *, int, daddr_t, int);
> -struct buf * ffs_cgread(struct fs *, struct inode *, int);
> +daddr_t ffs_alloccg(struct inode *, u_int, daddr_t, int);
> +struct buf * ffs_cgread(struct fs *, struct inode *, u_int);
> daddr_t ffs_alloccgblk(struct inode *, struct buf *, daddr_t);
> ufsino_t ffs_dirpref(struct inode *);
> -daddr_t ffs_fragextend(struct inode *, int, daddr_t, int, int);
> -daddr_t ffs_hashalloc(struct inode *, int, daddr_t, int,
> - daddr_t (*)(struct inode *, int, daddr_t, int));
> -daddr_t ffs_nodealloccg(struct inode *, int, daddr_t, int);
> +daddr_t ffs_fragextend(struct inode *, u_int, daddr_t, int,
> int);
> +daddr_t ffs_hashalloc(struct inode *, u_int, daddr_t, int,
> + daddr_t (*)(struct inode *, u_int, daddr_t, int));
> +daddr_t ffs_nodealloccg(struct inode *, u_int, daddr_t, int);
> daddr_t ffs_mapsearch(struct fs *, struct cg *, daddr_t, int);
>
> static const struct timeval fserr_interval = { 2, 0 };
> @@ -102,7 +102,7 @@ ffs_alloc(struct inode *ip, daddr_t lbn,
> static struct timeval fsfull_last;
> struct fs *fs;
> daddr_t bno;
> - int cg;
> + u_int cg;
> int error;
>
> *bnp = 0;
> @@ -174,7 +174,8 @@ ffs_realloccg(struct inode *ip, daddr_t
> struct fs *fs;
> struct buf *bp = NULL;
> daddr_t quota_updated = 0;
> - int cg, request, error;
> + int request, error;
> + u_int cg;
> daddr_t bprev, bno;
>
> if (bpp != NULL)
> @@ -360,7 +361,8 @@ ffs_inode_alloc(struct inode *pip, mode_
> struct fs *fs;
> struct inode *ip;
> ufsino_t ino, ipref;
> - int cg, error;
> + u_int cg;
> + int error;
>
> *vpp = NULL;
> fs = pip->i_fs;
> @@ -449,11 +451,12 @@ ufsino_t
> ffs_dirpref(struct inode *pip)
> {
> struct fs *fs;
> - int cg, prefcg, dirsize, cgsize;
> - int avgifree, avgbfree, avgndir, curdirsize;
> - int minifree, minbfree, maxndir;
> - int mincg, minndir;
> - int maxcontigdirs;
> + u_int cg, prefcg;
> + u_int dirsize, cgsize;
> + u_int avgifree, avgbfree, avgndir, curdirsize;
> + u_int minifree, minbfree, maxndir;
> + u_int mincg, minndir;
> + u_int maxcontigdirs;
>
> fs = pip->i_fs;
>
> @@ -592,7 +595,8 @@ int32_t
> ffs1_blkpref(struct inode *ip, daddr_t lbn, int indx, int32_t *bap)
> {
> struct fs *fs;
> - int cg, inocg, avgbfree, startcg;
> + u_int cg, inocg;
> + u_int avgbfree, startcg;
> uint32_t pref;
>
> KASSERT(indx <= 0 || bap != NULL);
> @@ -692,7 +696,8 @@ int64_t
> ffs2_blkpref(struct inode *ip, daddr_t lbn, int indx, int64_t *bap)
> {
> struct fs *fs;
> - int cg, inocg, avgbfree, startcg;
> + u_int cg, inocg;
> + u_int avgbfree, startcg;
> uint64_t pref;
>
> KASSERT(indx <= 0 || bap != NULL);
> @@ -796,12 +801,12 @@ ffs2_blkpref(struct inode *ip, daddr_t l
> * 3) brute force search for a free block.
> */
> daddr_t
> -ffs_hashalloc(struct inode *ip, int cg, daddr_t pref, int size,
> - daddr_t (*allocator)(struct inode *, int, daddr_t, int))
> +ffs_hashalloc(struct inode *ip, u_int cg, daddr_t pref, int size,
> + daddr_t (*allocator)(struct inode *, u_int, daddr_t, int))
> {
> struct fs *fs;
> daddr_t result;
> - int i, icg = cg;
> + u_int i, icg = cg;
>
> fs = ip->i_fs;
> /*
> @@ -839,7 +844,7 @@ ffs_hashalloc(struct inode *ip, int cg,
> }
>
> struct buf *
> -ffs_cgread(struct fs *fs, struct inode *ip, int cg)
> +ffs_cgread(struct fs *fs, struct inode *ip, u_int cg)
> {
> struct buf *bp;
>
> @@ -864,7 +869,7 @@ ffs_cgread(struct fs *fs, struct inode *
> * if they are, allocate them.
> */
> daddr_t
> -ffs_fragextend(struct inode *ip, int cg, daddr_t bprev, int osize, int nsize)
> +ffs_fragextend(struct inode *ip, u_int cg, daddr_t bprev, int osize, int
> nsize)
> {
> struct fs *fs;
> struct cg *cgp;
> @@ -930,7 +935,7 @@ ffs_fragextend(struct inode *ip, int cg,
> * and if it is, allocate it.
> */
> daddr_t
> -ffs_alloccg(struct inode *ip, int cg, daddr_t bpref, int size)
> +ffs_alloccg(struct inode *ip, u_int cg, daddr_t bpref, int size)
> {
> struct fs *fs;
> struct cg *cgp;
> @@ -1085,7 +1090,7 @@ gotit:
>
> /* inode allocation routine */
> daddr_t
> -ffs_nodealloccg(struct inode *ip, int cg, daddr_t ipref, int mode)
> +ffs_nodealloccg(struct inode *ip, u_int cg, daddr_t ipref, int mode)
> {
> struct fs *fs;
> struct cg *cgp;
> @@ -1379,10 +1384,10 @@ ffs_freefile(struct inode *pip, ufsino_t
> struct cg *cgp;
> struct buf *bp;
> struct timespec now;
> - int cg;
> + u_int cg;
>
> fs = pip->i_fs;
> - if ((u_int)ino >= fs->fs_ipg * fs->fs_ncg)
> + if (ino >= fs->fs_ipg * fs->fs_ncg)
> panic("ffs_freefile: range: dev = 0x%x, ino = %d, fs = %s",
> pip->i_dev, ino, fs->fs_fsmnt);
>
> Index: sys/ufs/ffs/fs.h
> ===================================================================
> RCS file: /cvs/src/sys/ufs/ffs/fs.h,v
> retrieving revision 1.42
> diff -u -p -r1.42 fs.h
> --- sys/ufs/ffs/fs.h 27 Nov 2016 13:27:55 -0000 1.42
> +++ sys/ufs/ffs/fs.h 29 May 2020 07:23:29 -0000
> @@ -202,7 +202,7 @@ struct fs {
> int32_t fs_ffs1_time; /* last time written */
> int32_t fs_ffs1_size; /* # of blocks in fs / frags */
> int32_t fs_ffs1_dsize; /* # of data blocks in fs */
> - int32_t fs_ncg; /* # of cylinder groups */
> + u_int32_t fs_ncg; /* # of cylinder groups */
> int32_t fs_bsize; /* size of basic blocks / bytes */
> int32_t fs_fsize; /* size of frag blocks / bytes */
> int32_t fs_frag; /* # of frags in a block in fs */
> @@ -225,7 +225,7 @@ struct fs {
> int32_t fs_csmask; /* csum block offset (now unused) */
> int32_t fs_csshift; /* csum block number (now unused) */
> int32_t fs_nindir; /* value of NINDIR */
> - int32_t fs_inopb; /* inodes per file system block */
> + u_int32_t fs_inopb; /* inodes per file system block */
> int32_t fs_nspf; /* DEV_BSIZE sectors per frag */
> /* yet another configuration parameter */
> int32_t fs_optim; /* optimization preference, see below */
> @@ -247,7 +247,7 @@ struct fs {
> int32_t fs_ncyl; /* cylinders in file system */
> /* these fields can be computed from the others */
> int32_t fs_cpg; /* cylinders per group */
> - int32_t fs_ipg; /* inodes per group */
> + u_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_ffs1_cstotal; /* cylinder summary information */
> @@ -278,11 +278,11 @@ struct fs {
> int64_t fs_dsize; /* number of data blocks in fs */
> int64_t fs_csaddr; /* blk addr of cyl grp summary area */
> int64_t fs_pendingblocks; /* blocks in process of being freed */
> - int32_t fs_pendinginodes; /* inodes in process of being freed */
> - int32_t fs_snapinum[FSMAXSNAP];/* space reserved for snapshots */
> + u_int32_t fs_pendinginodes; /* inodes in process of being freed */
> + u_int32_t fs_snapinum[FSMAXSNAP];/* space reserved for snapshots */
> /* back to stuff that has been around a while */
> - int32_t fs_avgfilesize; /* expected average file size */
> - int32_t fs_avgfpdir; /* expected # of files per directory */
> + u_int32_t fs_avgfilesize; /* expected average file size */
> + u_int32_t fs_avgfpdir; /* expected # of files per directory */
> int32_t fs_sparecon[26]; /* reserved for future constants */
> u_int32_t fs_flags; /* see FS_ flags below */
> int32_t fs_fscktime; /* last time fsck(8)ed */
> @@ -377,25 +377,25 @@ struct cg {
> int32_t cg_firstfield; /* historic cyl groups linked list */
> int32_t cg_magic; /* magic number */
> int32_t cg_time; /* time last written */
> - int32_t cg_cgx; /* we are the cgx'th cylinder group */
> + u_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 */
> + u_int32_t cg_ndblk; /* number of data blocks this cg */
> struct csum cg_cs; /* cylinder summary information */
> - 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 */
> + u_int32_t cg_rotor; /* position of last used block */
> + u_int32_t cg_frotor; /* position of last used frag */
> + u_int32_t cg_irotor; /* position of last used inode */
> + u_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_ffs2_niblk; /* number of inode blocks this cg */
> - int32_t cg_initediblk; /* last initialized inode */
> + u_int32_t cg_iusedoff; /* (u_int8) used inode map */
> + u_int32_t cg_freeoff; /* (u_int8) free block map */
> + u_int32_t cg_nextfreeoff; /* (u_int8) next available space */
> + u_int32_t cg_clustersumoff; /* (u_int32) counts of avail clusters */
> + u_int32_t cg_clusteroff; /* (u_int8) free cluster map */
> + u_int32_t cg_nclusterblks; /* number of clusters this cg */
> + u_int32_t cg_ffs2_niblk; /* number of inode blocks this cg */
> + u_int32_t cg_initediblk; /* last initialized inode */
> int32_t cg_sparecon32[3]; /* reserved for future use */
> int64_t cg_ffs2_time; /* time last written */
> int64_t cg_sparecon64[3]; /* reserved for future use */
>
