change all macros taking "fs" to have it as their first argument

SCCS-vsn: sys/ufs/ffs/fs.h 1.13
SCCS-vsn: sys/ufs/ffs/ffs_alloc.c 1.15
SCCS-vsn: sys/ufs/lfs/lfs_alloc.c 1.15
SCCS-vsn: sbin/clri/clri.c 1.3
SCCS-vsn: old/dcheck/dcheck.c 1.6
SCCS-vsn: sbin/dumpfs/dumpfs.c 1.10
SCCS-vsn: sbin/fsck/main.c 1.19
SCCS-vsn: sbin/icheck/icheck.c 1.15
SCCS-vsn: sbin/newfs/mkfs.c 1.15
SCCS-vsn: sbin/ncheck/ncheck.c 1.6
SCCS-vsn: sbin/restore/main.c 1.11
SCCS-vsn: sbin/dump/traverse.c 1.5

diff --git a/usr/src/old/dcheck/dcheck.c b/usr/src/old/dcheck/dcheck.c
index 999d0f2..737606a 100644 (file)
--- a/usr/src/old/dcheck/dcheck.c
+++ b/usr/src/old/dcheck/dcheck.c
@@ -1,4 +1,4 @@
-static char *sccsid = "@(#)dcheck.c    1.5 (Berkeley) %G%";
+static char *sccsid = "@(#)dcheck.c    1.6 (Berkeley) %G%";

 /*
  * dcheck - check directory consistency
  */
 /*
  * dcheck - check directory consistency
  */


@@ -101,7 +101,7 @@ char *file;
                ecount[i] = 0;
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {
                ecount[i] = 0;
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               bread(fsbtodb(&sblock, cgimin(c, &sblock)), (char *)itab,
+               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,

                    sblock.fs_ipg * sizeof (struct dinode));
                for (j = 0; j < sblock.fs_ipg; j++) {
                        pass1(&itab[j]);
                    sblock.fs_ipg * sizeof (struct dinode));
                for (j = 0; j < sblock.fs_ipg; j++) {
                        pass1(&itab[j]);


@@ -110,7 +110,7 @@ char *file;
        }
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {
        }
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               bread(fsbtodb(&sblock, cgimin(c, &sblock)), (char *)itab,
+               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,

                    sblock.fs_ipg * sizeof (struct dinode));
                for (j = 0; j < sblock.fs_ipg; j++) {
                        pass2(&itab[j]);
                    sblock.fs_ipg * sizeof (struct dinode));
                for (j = 0; j < sblock.fs_ipg; j++) {
                        pass2(&itab[j]);

diff --git a/usr/src/sbin/clri/clri.c b/usr/src/sbin/clri/clri.c
index 2603b55..a557b9c 100644 (file)
--- a/usr/src/sbin/clri/clri.c
+++ b/usr/src/sbin/clri/clri.c
@@ -1,6 +1,6 @@
 /* Copyright (c) 1981 Regents of the University of California */
 
 /* Copyright (c) 1981 Regents of the University of California */
 

-static char sccsid[] = "@(#)clri.c 1.2 %G%";
+static char sccsid[] = "@(#)clri.c 1.3 %G%";

 
 /* static char *sccsid = "@(#)clri.c   4.1 (Berkeley) 10/1/80"; */
 /*
 
 /* static char *sccsid = "@(#)clri.c   4.1 (Berkeley) 10/1/80"; */
 /*


@@ -61,7 +61,7 @@ main(argc, argv)
                        status = 1;
                        continue;
                }
                        status = 1;
                        continue;
                }

-               off = fsbtodb(&sblock, itod(n, &sblock)) * DEV_BSIZE;
+               off = fsbtodb(&sblock, itod(&sblock, n)) * DEV_BSIZE;

                lseek(f, off, 0);
                if (read(f, (char *)buf, sblock.fs_bsize) != sblock.fs_bsize) {
                        printf("%s: read error\n", argv[i]);
                lseek(f, off, 0);
                if (read(f, (char *)buf, sblock.fs_bsize) != sblock.fs_bsize) {
                        printf("%s: read error\n", argv[i]);


@@ -73,10 +73,10 @@ main(argc, argv)
        for (i = 2; i < argc; i++) {
                n = atoi(argv[i]);
                printf("clearing %u\n", n);
        for (i = 2; i < argc; i++) {
                n = atoi(argv[i]);
                printf("clearing %u\n", n);

-               off = fsbtodb(&sblock, itod(n, &sblock)) * DEV_BSIZE;
+               off = fsbtodb(&sblock, itod(&sblock, n)) * DEV_BSIZE;

                lseek(f, off, 0);
                read(f, (char *)buf, sblock.fs_bsize);
                lseek(f, off, 0);
                read(f, (char *)buf, sblock.fs_bsize);

-               j = itoo(n, &sblock);
+               j = itoo(&sblock, n);

                for (k = 0; k < ISIZE; k++)
                        buf[j].junk[k] = 0;
                lseek(f, off, 0);
                for (k = 0; k < ISIZE; k++)
                        buf[j].junk[k] = 0;
                lseek(f, off, 0);

diff --git a/usr/src/sbin/dump/traverse.c b/usr/src/sbin/dump/traverse.c
index f202a7b..74344bd 100644 (file)
--- a/usr/src/sbin/dump/traverse.c
+++ b/usr/src/sbin/dump/traverse.c
@@ -1,4 +1,4 @@
-static char *sccsid = "@(#)traverse.c  1.4 (Berkeley) %G%";
+static char *sccsid = "@(#)traverse.c  1.5 (Berkeley) %G%";

 
 #include "dump.h"
 
 
 #include "dump.h"
 


@@ -273,7 +273,7 @@ getino(ino)
        if (ino >= minino && ino < maxino) {
                return (&itab[ino - minino]);
        }
        if (ino >= minino && ino < maxino) {
                return (&itab[ino - minino]);
        }

-       bread(fsbtodb(sblock, itod(ino, sblock)), itab, sblock->fs_bsize);
+       bread(fsbtodb(sblock, itod(sblock, ino)), itab, sblock->fs_bsize);

        minino = ino - (ino % INOPB(sblock));
        maxino = minino + INOPB(sblock);
        return (&itab[ino - minino]);
        minino = ino - (ino % INOPB(sblock));
        maxino = minino + INOPB(sblock);
        return (&itab[ino - minino]);

diff --git a/usr/src/sbin/dumpfs/dumpfs.c b/usr/src/sbin/dumpfs/dumpfs.c
index 5df8ffc..d68663e 100644 (file)
--- a/usr/src/sbin/dumpfs/dumpfs.c
+++ b/usr/src/sbin/dumpfs/dumpfs.c
@@ -1,4 +1,4 @@
-static char *sccsid = "@(#)dumpfs.c    1.9 (Berkeley) %G%";
+static char *sccsid = "@(#)dumpfs.c    1.10 (Berkeley) %G%";

 
 #include "../h/param.h"
 #include "../h/fs.h"
 
 #include "../h/param.h"
 #include "../h/fs.h"


@@ -112,7 +112,7 @@ dumpcg(c)
        int i,j;
 
        printf("\ncg %d:\n", c);
        int i,j;
 
        printf("\ncg %d:\n", c);

-       lseek(0, fsbtodb(&afs, cgtod(c,&afs)) * DEV_BSIZE, 0);
+       lseek(0, fsbtodb(&afs, cgtod(&afs, c)) * DEV_BSIZE, 0);

        printf("tell\t%x\n", tell(0));
        if (read(0, (char *)&acg, afs.fs_bsize) != afs.fs_bsize) {
                printf("\terror reading cg\n");
        printf("tell\t%x\n", tell(0));
        if (read(0, (char *)&acg, afs.fs_bsize) != afs.fs_bsize) {
                printf("\terror reading cg\n");

diff --git a/usr/src/sbin/fsck/main.c b/usr/src/sbin/fsck/main.c
index 7a2521a..d271d81 100644 (file)
--- a/usr/src/sbin/fsck/main.c
+++ b/usr/src/sbin/fsck/main.c
@@ -1,4 +1,4 @@
-static char *sccsid = "@(#)main.c      1.18 (Berkeley) %G%";
+static char *sccsid = "@(#)main.c      1.19 (Berkeley) %G%";

 
 #include <stdio.h>
 #include <ctype.h>
 
 #include <stdio.h>
 #include <ctype.h>


@@ -92,6 +92,7 @@ char  rawflg;
 char   nflag;                  /* assume a no response */
 char   yflag;                  /* assume a yes response */
 int    bflag;                  /* location of alternate super block */
 char   nflag;                  /* assume a no response */
 char   yflag;                  /* assume a yes response */
 int    bflag;                  /* location of alternate super block */

+int    debug;                  /* output debugging info */

 char   preen;                  /* just fix normal inconsistencies */
 char   rplyflag;               /* any questions asked? */
 char   hotroot;                /* checking root device */
 char   preen;                  /* just fix normal inconsistencies */
 char   rplyflag;               /* any questions asked? */
 char   hotroot;                /* checking root device */


@@ -199,6 +200,10 @@ main(argc, argv)
                        printf("Alternate super block location: %d\n", bflag);
                        break;
 
                        printf("Alternate super block location: %d\n", bflag);
                        break;
 

+               case 'd':
+                       debug++;
+                       break;
+

                case 'n':       /* default no answer flag */
                case 'N':
                        nflag++;
                case 'n':       /* default no answer flag */
                case 'N':
                        nflag++;


@@ -375,7 +380,7 @@ check(dev)
        inum = 0;
        n_blks += howmany(sblock.fs_cssize, sblock.fs_bsize) * sblock.fs_frag;
        for (c = 0; c < sblock.fs_ncg; c++) {
        inum = 0;
        n_blks += howmany(sblock.fs_cssize, sblock.fs_bsize) * sblock.fs_frag;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               if (getblk(&cgblk, cgtod(c, &sblock), sblock.fs_cgsize) == 0)
+               if (getblk(&cgblk, cgtod(&sblock, c), sblock.fs_cgsize) == 0)

                        continue;
                n = 0;
                for (i = 0; i < sblock.fs_ipg; i++, inum++) {
                        continue;
                n = 0;
                for (i = 0; i < sblock.fs_ipg; i++, inum++) {


@@ -384,9 +389,9 @@ check(dev)
                                continue;
                        if (ALLOC) {
                                if (!isset(cgrp.cg_iused, i)) {
                                continue;
                        if (ALLOC) {
                                if (!isset(cgrp.cg_iused, i)) {

-                                       /*
-                                       printf("%d bad, not used\n", inum);
-                                       */
+                                       if (debug)
+                                               printf("%d bad, not used\n",
+                                                   inum);

                                        inosumbad++;
                                        n++;
                                }
                                        inosumbad++;
                                        n++;
                                }


@@ -422,9 +427,9 @@ check(dev)
                        } else {
                                n++;
                                if (isset(cgrp.cg_iused, i)) {
                        } else {
                                n++;
                                if (isset(cgrp.cg_iused, i)) {

-                                       /*
-                                       printf("%d bad, marked used\n", inum);
-                                       */
+                                       if (debug)
+                                               printf("%d bad, marked used\n",
+                                                   inum);

                                        inosumbad++;
                                        n--;
                                }
                                        inosumbad++;
                                        n--;
                                }


@@ -439,8 +444,9 @@ check(dev)
                        }
                }
                if (n != cgrp.cg_cs.cs_nifree) {
                        }
                }
                if (n != cgrp.cg_cs.cs_nifree) {

-                       printf("cg[%d].cg_cs.cs_nifree is %d not %d\n",
-                           c, cgrp.cg_cs.cs_nifree, n);
+                       if (debug)
+                               printf("cg[%d].cg_cs.cs_nifree is %d not %d\n",
+                                   c, cgrp.cg_cs.cs_nifree, n);

                        inosumbad++;
                }
        }
                        inosumbad++;
                }
        }


@@ -570,9 +576,9 @@ out1b:
                printf("** Phase 5 - Check Cyl groups\n");
        copy(blkmap, freemap, (unsigned)bmapsz);
        dupblk = 0;
                printf("** Phase 5 - Check Cyl groups\n");
        copy(blkmap, freemap, (unsigned)bmapsz);
        dupblk = 0;

-       n_index = sblock.fs_ncg * (cgdmin(0, &sblock) - cgtod(0, &sblock));
+       n_index = sblock.fs_ncg * (cgdmin(&sblock, 0) - cgtod(&sblock, 0));

        for (c = 0; c < sblock.fs_ncg; c++) {
        for (c = 0; c < sblock.fs_ncg; c++) {

-               daddr_t cbase = cgbase(c,&sblock);
+               daddr_t cbase = cgbase(&sblock, c);

                short bo[MAXCPG][NRPOS];
                long botot[MAXCPG];
                long frsum[MAXFRAG];
                short bo[MAXCPG][NRPOS];
                long botot[MAXCPG];
                long frsum[MAXFRAG];


@@ -590,8 +596,8 @@ out1b:
                 * need to account for the spare boot and super blocks
                 * which appear (inaccurately) bad
                 */
                 * need to account for the spare boot and super blocks
                 * which appear (inaccurately) bad
                 */

-               n_bad += cgtod(c, &sblock) - cbase;
-               if (getblk(&cgblk, cgtod(c, &sblock), sblock.fs_cgsize) == 0)
+               n_bad += cgtod(&sblock, c) - cbase;
+               if (getblk(&cgblk, cgtod(&sblock, c), sblock.fs_cgsize) == 0)

                        continue;
                for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) {
                        if (isblock(&sblock, cgrp.cg_free, b/sblock.fs_frag)) {
                        continue;
                for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) {
                        if (isblock(&sblock, cgrp.cg_free, b/sblock.fs_frag)) {


@@ -616,21 +622,25 @@ out1b:
                }
                for (i = 0; i < sblock.fs_frag; i++) {
                        if (cgrp.cg_frsum[i] != frsum[i]) {
                }
                for (i = 0; i < sblock.fs_frag; i++) {
                        if (cgrp.cg_frsum[i] != frsum[i]) {

-                               printf("cg[%d].cg_frsum[%d] have %d calc %d\n",
-                                       c, i, cgrp.cg_frsum[i], frsum[i]);
+                               if (debug)
+                                       printf("cg[%d].cg_frsum[%d] have %d calc %d\n",
+                                           c, i, cgrp.cg_frsum[i], frsum[i]);

                                frsumbad++;
                        }
                }
                for (n = 0; n < sblock.fs_cpg; n++) {
                        if (botot[n] != cgrp.cg_btot[n]) {
                                frsumbad++;
                        }
                }
                for (n = 0; n < sblock.fs_cpg; n++) {
                        if (botot[n] != cgrp.cg_btot[n]) {

-                               printf("cg[%d].cg_btot[%d] have %d calc %d\n",
-                                   c, n, cgrp.cg_btot[n], botot[n]);
+                               if (debug)
+                                       printf("cg[%d].cg_btot[%d] have %d calc %d\n",
+                                           c, n, cgrp.cg_btot[n], botot[n]);

                                offsumbad++;
                        }
                        for (i = 0; i < NRPOS; i++)
                                if (bo[n][i] != cgrp.cg_b[n][i]) {
                                offsumbad++;
                        }
                        for (i = 0; i < NRPOS; i++)
                                if (bo[n][i] != cgrp.cg_b[n][i]) {

-                                       printf("cg[%d].cg_b[%d][%d] have %d calc %d\n",
-                                           c, n, i, cgrp.cg_b[n][i], bo[n][i]);
+                                       if (debug)
+                                               printf("cg[%d].cg_b[%d][%d] have %d calc %d\n",
+                                                   c, n, i, cgrp.cg_b[n][i],
+                                                   bo[n][i]);

                                        offsumbad++;
                                }
                }
                                        offsumbad++;
                                }
                }


@@ -1004,8 +1014,8 @@ outrange(blk)
 {
        register int c;
 
 {
        register int c;
 

-       c = dtog(blk, &sblock);
-       if (blk >= fmax || blk < cgdmin(c, &sblock)) {
+       c = dtog(&sblock, blk);
+       if (blk >= fmax || blk < cgdmin(&sblock, c)) {

                return (1);
        }
        return (0);
                return (1);
        }
        return (0);


@@ -1223,7 +1233,7 @@ setup(dev)
                { badsb("SPC DOES NOT JIVE w/NTRAK*NSECT"); return (0); }
        if (sblock.fs_ipg % INOPB(&sblock))
                { badsb("INODES NOT MULTIPLE OF A BLOCK"); return (0); }
                { badsb("SPC DOES NOT JIVE w/NTRAK*NSECT"); return (0); }
        if (sblock.fs_ipg % INOPB(&sblock))
                { badsb("INODES NOT MULTIPLE OF A BLOCK"); return (0); }

-       if (cgdmin(0, &sblock) >= sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock))
+       if (cgdmin(&sblock, 0) >= sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock))

                { badsb("IMPLIES MORE INODE THAN DATA BLOCKS"); return (0); }
        if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
            (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
                { badsb("IMPLIES MORE INODE THAN DATA BLOCKS"); return (0); }
        if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
            (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)


@@ -1290,7 +1300,7 @@ ginode()
        if (inum < ROOTINO || inum > imax)
                return (NULL);
        if (inum < startinum || inum >= startinum + INOPB(&sblock)) {
        if (inum < ROOTINO || inum > imax)
                return (NULL);
        if (inum < startinum || inum >= startinum + INOPB(&sblock)) {

-               iblk = itod(inum, &sblock);
+               iblk = itod(&sblock, inum);

                if (getblk(&inoblk, iblk, sblock.fs_bsize) == NULL) {
                        return (NULL);
                }
                if (getblk(&inoblk, iblk, sblock.fs_bsize) == NULL) {
                        return (NULL);
                }


@@ -1476,11 +1486,11 @@ makecg()
                    sblock.fs_csaddr + (i * sblock.fs_frag), sblock.fs_bsize);
        }
        for (c = 0; c < sblock.fs_ncg; c++) {
                    sblock.fs_csaddr + (i * sblock.fs_frag), sblock.fs_bsize);
        }
        for (c = 0; c < sblock.fs_ncg; c++) {

-               dbase = cgbase(c, &sblock);
+               dbase = cgbase(&sblock, c);

                dmax = dbase + sblock.fs_fpg;
                if (dmax > sblock.fs_size)
                        dmax = sblock.fs_size;
                dmax = dbase + sblock.fs_fpg;
                if (dmax > sblock.fs_size)
                        dmax = sblock.fs_size;

-               dmin = cgdmin(c, &sblock) - dbase;
+               dmin = cgdmin(&sblock, c) - dbase;

                cs = &sblock.fs_cs(&sblock, c);
                cgrp.cg_time = time(0);
                cgrp.cg_magic = CG_MAGIC;
                cs = &sblock.fs_cs(&sblock, c);
                cgrp.cg_time = time(0);
                cgrp.cg_magic = CG_MAGIC;


@@ -1565,7 +1575,7 @@ makecg()
                sblock.fs_cstotal.cs_nifree += cgrp.cg_cs.cs_nifree;
                sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir;
                *cs = cgrp.cg_cs;
                sblock.fs_cstotal.cs_nifree += cgrp.cg_cs.cs_nifree;
                sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir;
                *cs = cgrp.cg_cs;

-               bwrite(&dfile, &cgrp, fsbtodb(&sblock, cgtod(c, &sblock)),
+               bwrite(&dfile, &cgrp, fsbtodb(&sblock, cgtod(&sblock, c)),

                        roundup(sblock.fs_cgsize, DEV_BSIZE));
        }
        for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) {
                        roundup(sblock.fs_cgsize, DEV_BSIZE));
        }
        for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) {


@@ -1802,7 +1812,7 @@ isblock(fs, cp, h)
                mask = 0x01 << (h & 0x7);
                return ((cp[h >> 3] & mask) == mask);
        default:
                mask = 0x01 << (h & 0x7);
                return ((cp[h >> 3] & mask) == mask);
        default:

-               fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
-               return;
+               error("isblock bad fs_frag %d\n", fs->fs_frag);
+               return (0);

        }
 }
        }
 }

diff --git a/usr/src/sbin/icheck/icheck.c b/usr/src/sbin/icheck/icheck.c
index 368cc2e..5a64dfd 100644 (file)
--- a/usr/src/sbin/icheck/icheck.c
+++ b/usr/src/sbin/icheck/icheck.c
@@ -1,4 +1,4 @@
-static char *sccsid = "@(#)icheck.c    1.14 (Berkeley) %G%";
+static char *sccsid = "@(#)icheck.c    1.15 (Berkeley) %G%";

 
 /*
  * icheck
 
 /*
  * icheck


@@ -171,15 +171,15 @@ check(file)
                for (i=0; i<(unsigned)n; i++)
                        bmap[i] = 0;
                for (c=0; c < sblock.fs_ncg; c++) {
                for (i=0; i<(unsigned)n; i++)
                        bmap[i] = 0;
                for (c=0; c < sblock.fs_ncg; c++) {

-                       cgd = cgtod(c, &sblock);
-                       for (d = cgbase(c, &sblock); d < cgd; d += sblock.fs_frag)
+                       cgd = cgtod(&sblock, c);
+                       for (d = cgbase(&sblock, c); d < cgd; d += sblock.fs_frag)

                                chk(d, "badcg", sblock.fs_bsize);
                                chk(d, "badcg", sblock.fs_bsize);

-                       d = cgimin(c, &sblock);
+                       d = cgimin(&sblock, c);

                        while (cgd < d) {
                                chk(cgd, "cg", sblock.fs_bsize);
                                cgd += sblock.fs_frag;
                        }
                        while (cgd < d) {
                                chk(cgd, "cg", sblock.fs_bsize);
                                cgd += sblock.fs_frag;
                        }

-                       d = cgdmin(c, &sblock);
+                       d = cgdmin(&sblock, c);

                        for (; cgd < d; cgd += sblock.fs_frag)
                                chk(cgd, "inode", sblock.fs_bsize);
                        if (c == 0) {
                        for (; cgd < d; cgd += sblock.fs_frag)
                                chk(cgd, "inode", sblock.fs_bsize);
                        if (c == 0) {


@@ -192,7 +192,7 @@ check(file)
        }
        cginit = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {
        }
        cginit = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               bread(fsbtodb(&sblock, cgimin(c,&sblock)), (char *)itab,
+               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,

                    sblock.fs_ipg * sizeof (struct dinode));
                for (j=0; j < sblock.fs_ipg; j++) {
                        pass1(&itab[j]);
                    sblock.fs_ipg * sizeof (struct dinode));
                for (j=0; j < sblock.fs_ipg; j++) {
                        pass1(&itab[j]);


@@ -215,8 +215,8 @@ check(file)
        nffree = 0;
        nbfree = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {
        nffree = 0;
        nbfree = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               cbase = cgbase(c,&sblock);
-               bread(fsbtodb(&sblock, cgtod(c,&sblock)), (char *)&cgrp,
+               cbase = cgbase(&sblock, c);
+               bread(fsbtodb(&sblock, cgtod(&sblock, c)), (char *)&cgrp,

                        sblock.fs_cgsize);
                for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) {
                        if (isblock(&sblock, cgrp.cg_free,
                        sblock.fs_cgsize);
                for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) {
                        if (isblock(&sblock, cgrp.cg_free,


@@ -358,9 +358,9 @@ chk(bno, s, size)
 {
        register n, cg;
 
 {
        register n, cg;
 

-       cg = dtog(bno, &sblock);
+       cg = dtog(&sblock, bno);

        if (cginit==0 &&
        if (cginit==0 &&

-           bno<cgdmin(cg,&sblock) || bno >= sblock.fs_frag * sblock.fs_size) {
+           bno<cgdmin(&sblock, cg) || bno >= sblock.fs_frag * sblock.fs_size) {

                printf("%ld bad; inode=%u, class=%s\n", bno, ino, s);
                return(1);
        }
                printf("%ld bad; inode=%u, class=%s\n", bno, ino, s);
                return(1);
        }


@@ -420,11 +420,11 @@ makecg()
        sblock.fs_cstotal.cs_nifree = 0;
        sblock.fs_cstotal.cs_ndir = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {
        sblock.fs_cstotal.cs_nifree = 0;
        sblock.fs_cstotal.cs_ndir = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               dbase = cgbase(c, &sblock);
+               dbase = cgbase(&sblock, c);

                dmax = dbase + sblock.fs_fpg;
                if (dmax > sblock.fs_size)
                        dmax = sblock.fs_size;
                dmax = dbase + sblock.fs_fpg;
                if (dmax > sblock.fs_size)
                        dmax = sblock.fs_size;

-               dmin = cgdmin(c, &sblock) - dbase;
+               dmin = cgdmin(&sblock, c) - dbase;

                cs = &sblock.fs_cs(&sblock, c);
                cgrp.cg_time = time(0);
                cgrp.cg_magic = CG_MAGIC;
                cs = &sblock.fs_cs(&sblock, c);
                cgrp.cg_time = time(0);
                cgrp.cg_magic = CG_MAGIC;


@@ -441,7 +441,7 @@ makecg()
                cgrp.cg_irotor = 0;
                for (i = 0; i < sblock.fs_frag; i++)
                        cgrp.cg_frsum[i] = 0;
                cgrp.cg_irotor = 0;
                for (i = 0; i < sblock.fs_frag; i++)
                        cgrp.cg_frsum[i] = 0;

-               bread(fsbtodb(&sblock, cgimin(c, &sblock)), (char *)itab,
+               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,

                      sblock.fs_ipg * sizeof(struct dinode));
                for (i = 0; i < sblock.fs_ipg; i++) {
                        dp = &itab[i];
                      sblock.fs_ipg * sizeof(struct dinode));
                for (i = 0; i < sblock.fs_ipg; i++) {
                        dp = &itab[i];


@@ -516,7 +516,7 @@ makecg()
                sblock.fs_cstotal.cs_nifree += cgrp.cg_cs.cs_nifree;
                sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir;
                *cs = cgrp.cg_cs;
                sblock.fs_cstotal.cs_nifree += cgrp.cg_cs.cs_nifree;
                sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir;
                *cs = cgrp.cg_cs;

-               bwrite(fsbtodb(&sblock, cgtod(c, &sblock)), &cgrp,
+               bwrite(fsbtodb(&sblock, cgtod(&sblock, c)), &cgrp,

                        sblock.fs_cgsize);
        }
        for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) {
                        sblock.fs_cgsize);
        }
        for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) {

diff --git a/usr/src/sbin/ncheck/ncheck.c b/usr/src/sbin/ncheck/ncheck.c
index aa1f19d..570288a 100644 (file)
--- a/usr/src/sbin/ncheck/ncheck.c
+++ b/usr/src/sbin/ncheck/ncheck.c
@@ -1,4 +1,4 @@
-static char *sccsid = "@(#)ncheck.c    1.5 (Berkeley) %G%";
+static char *sccsid = "@(#)ncheck.c    1.6 (Berkeley) %G%";

 /*
  * ncheck -- obtain file names from reading filesystem
  */
 /*
  * ncheck -- obtain file names from reading filesystem
  */


@@ -109,7 +109,7 @@ check(file)
        }
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {
        }
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               bread(fsbtodb(&sblock, cgimin(c, &sblock)), (char *)itab,
+               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,

                    sblock.fs_ipg * sizeof (struct dinode));
                for(j=0; j<sblock.fs_ipg; j++) {
                        pass1(&itab[j]);
                    sblock.fs_ipg * sizeof (struct dinode));
                for(j=0; j<sblock.fs_ipg; j++) {
                        pass1(&itab[j]);


@@ -119,7 +119,7 @@ check(file)
        ilist[nxfile+1] = 0;
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {
        ilist[nxfile+1] = 0;
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               bread(fsbtodb(&sblock, cgimin(c, &sblock)), (char *)itab,
+               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,

                    sblock.fs_ipg * sizeof (struct dinode));
                for(j=0; j<sblock.fs_ipg; j++) {
                        pass2(&itab[j]);
                    sblock.fs_ipg * sizeof (struct dinode));
                for(j=0; j<sblock.fs_ipg; j++) {
                        pass2(&itab[j]);


@@ -128,7 +128,7 @@ check(file)
        }
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {
        }
        ino = 0;
        for (c = 0; c < sblock.fs_ncg; c++) {

-               bread(fsbtodb(&sblock, cgimin(c, &sblock)), (char *)itab,
+               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,

                    sblock.fs_ipg * sizeof (struct dinode));
                for(j=0; j<sblock.fs_ipg; j++) {
                        pass3(&itab[j]);
                    sblock.fs_ipg * sizeof (struct dinode));
                for(j=0; j<sblock.fs_ipg; j++) {
                        pass3(&itab[j]);

diff --git a/usr/src/sbin/newfs/mkfs.c b/usr/src/sbin/newfs/mkfs.c
index b463ccc..0aabc62 100644 (file)
--- a/usr/src/sbin/newfs/mkfs.c
+++ b/usr/src/sbin/newfs/mkfs.c
@@ -1,4 +1,4 @@
-static char *sccsid = "@(#)mkfs.c      1.14 (Berkeley) %G%";
+static char *sccsid = "@(#)mkfs.c      1.15 (Berkeley) %G%";

 
 /*
  * make file system for cylinder-group style file systems
 
 /*
  * make file system for cylinder-group style file systems


@@ -285,9 +285,9 @@ next:
        if (sblock.fs_ipg > MAXIPG)
                sblock.fs_ipg = MAXIPG;
        sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
        if (sblock.fs_ipg > MAXIPG)
                sblock.fs_ipg = MAXIPG;
        sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);

-       if (cgdmin(0,&sblock) >= sblock.fs_fpg) {
+       if (cgdmin(&sblock, 0) >= sblock.fs_fpg) {

                printf("inode blocks/cyl group (%d) >= data blocks (%d)\n",
                printf("inode blocks/cyl group (%d) >= data blocks (%d)\n",

-                   cgdmin(0,&sblock) / sblock.fs_frag,
+                   cgdmin(&sblock, 0) / sblock.fs_frag,

                    sblock.fs_fpg / sblock.fs_frag);
                printf("number of cylinder per cylinder group must be increased\n");
                exit(1);
                    sblock.fs_fpg / sblock.fs_frag);
                printf("number of cylinder per cylinder group must be increased\n");
                exit(1);


@@ -295,7 +295,7 @@ next:
        /*
         * fill in remaining fields of the super block
         */
        /*
         * fill in remaining fields of the super block
         */

-       sblock.fs_csaddr = cgdmin(0, &sblock);
+       sblock.fs_csaddr = cgdmin(&sblock, 0);

        sblock.fs_cssize = sblock.fs_ncg * sizeof(struct csum);
        fscs = (struct csum *)
            calloc(1, roundup(sblock.fs_cssize, sblock.fs_bsize));
        sblock.fs_cssize = sblock.fs_ncg * sizeof(struct csum);
        fscs = (struct csum *)
            calloc(1, roundup(sblock.fs_cssize, sblock.fs_bsize));


@@ -330,8 +330,8 @@ next:
                printf("Warning: no super-block backups with only one cylinder group\n");
        else
                printf("\tsuper-block backups (for fsck -b#) at %d+k*%d (%d .. %d)\n",
                printf("Warning: no super-block backups with only one cylinder group\n");
        else
                printf("\tsuper-block backups (for fsck -b#) at %d+k*%d (%d .. %d)\n",

-                   SBLOCK, cgsblock(1, &sblock) - SBLOCK, cgsblock(1, &sblock),
-                   cgsblock(sblock.fs_ncg - 1, &sblock));
+                   SBLOCK, cgsblock(&sblock, 1) - SBLOCK, cgsblock(&sblock, 1),
+                   cgsblock(&sblock, sblock.fs_ncg - 1));

        /*
         * Now construct the initial file system,
         * then write out the super-block.
        /*
         * Now construct the initial file system,
         * then write out the super-block.


@@ -346,7 +346,7 @@ next:
         * Write out the duplicate super blocks
         */
        for (cylno = 1; cylno < sblock.fs_ncg; cylno++)
         * Write out the duplicate super blocks
         */
        for (cylno = 1; cylno < sblock.fs_ncg; cylno++)

-               wtfs(cgsblock(cylno, &sblock), SBSIZE, (char *)&sblock);
+               wtfs(cgsblock(&sblock, cylno), SBSIZE, (char *)&sblock);

 #ifndef STANDALONE
        exit(0);
 #endif
 #ifndef STANDALONE
        exit(0);
 #endif


@@ -367,7 +367,7 @@ initcg(cylno)
         * Allow space for super block summary information in first
         * cylinder group.
         */
         * Allow space for super block summary information in first
         * cylinder group.
         */

-       cbase = cgbase(cylno,&sblock);
+       cbase = cgbase(&sblock, cylno);

        dmax = cbase + sblock.fs_fpg;
        if (dmax > sblock.fs_size)
                dmax = sblock.fs_size;
        dmax = cbase + sblock.fs_fpg;
        if (dmax > sblock.fs_size)
                dmax = sblock.fs_size;


@@ -406,7 +406,7 @@ initcg(cylno)
                clrbit(acg.cg_iused, i);
                i++;
        }
                clrbit(acg.cg_iused, i);
                i++;
        }

-       lseek(fso, fsbtodb(&sblock, cgimin(cylno,&sblock)) * DEV_BSIZE, 0);
+       lseek(fso, fsbtodb(&sblock, cgimin(&sblock, cylno)) * DEV_BSIZE, 0);

        if (write(fso, (char *)zino, sblock.fs_ipg * sizeof (struct dinode)) !=
            sblock.fs_ipg * sizeof (struct dinode))
                printf("write error %D\n", tell(fso) / sblock.fs_bsize);
        if (write(fso, (char *)zino, sblock.fs_ipg * sizeof (struct dinode)) !=
            sblock.fs_ipg * sizeof (struct dinode))
                printf("write error %D\n", tell(fso) / sblock.fs_bsize);


@@ -442,7 +442,7 @@ initcg(cylno)
        sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
        sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
        *cs = acg.cg_cs;
        sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
        sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
        *cs = acg.cg_cs;

-       wtfs(fsbtodb(&sblock, cgtod(cylno, &sblock)),
+       wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),

                sblock.fs_bsize, (char *)&acg);
 }
 
                sblock.fs_bsize, (char *)&acg);
 }
 


@@ -502,7 +502,7 @@ alloc(size, mode)
        int i, frag;
        daddr_t d;
 
        int i, frag;
        daddr_t d;
 

-       rdfs(fsbtodb(&sblock, cgtod(0,&sblock)),
+       rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)),

                roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
        if (acg.cg_cs.cs_nbfree == 0) {
                printf("first cylinder group ran out of space\n");
                roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
        if (acg.cg_cs.cs_nbfree == 0) {
                printf("first cylinder group ran out of space\n");


@@ -534,7 +534,7 @@ goth:
                for (i = frag; i < sblock.fs_frag; i++)
                        setbit(acg.cg_free, d+i);
        }
                for (i = frag; i < sblock.fs_frag; i++)
                        setbit(acg.cg_free, d+i);
        }

-       wtfs(fsbtodb(&sblock, cgtod(0,&sblock)),
+       wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)),

                roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
        return (d);
 }
                roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
        return (d);
 }


@@ -549,12 +549,12 @@ iput(ip)
        daddr_t d;
        int c;
 
        daddr_t d;
        int c;
 

-       c = itog(ip->i_number, &sblock);
-       rdfs(fsbtodb(&sblock, cgtod(c,&sblock)),
+       c = itog(&sblock, ip->i_number);
+       rdfs(fsbtodb(&sblock, cgtod(&sblock, c)),

                roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
        acg.cg_cs.cs_nifree--;
        setbit(acg.cg_iused, ip->i_number);
                roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
        acg.cg_cs.cs_nifree--;
        setbit(acg.cg_iused, ip->i_number);

-       wtfs(fsbtodb(&sblock, cgtod(c,&sblock)),
+       wtfs(fsbtodb(&sblock, cgtod(&sblock, c)),

                roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
        sblock.fs_cstotal.cs_nifree--;
        fscs[0].cs_nifree--;
                roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
        sblock.fs_cstotal.cs_nifree--;
        fscs[0].cs_nifree--;


@@ -563,9 +563,9 @@ iput(ip)
                    ip->i_number);
                exit(1);
        }
                    ip->i_number);
                exit(1);
        }

-       d = fsbtodb(&sblock, itod(ip->i_number, &sblock));
+       d = fsbtodb(&sblock, itod(&sblock, ip->i_number));

        rdfs(d, sblock.fs_bsize, buf);
        rdfs(d, sblock.fs_bsize, buf);

-       buf[itoo(ip->i_number, &sblock)].di_ic = ip->i_ic;
+       buf[itoo(&sblock, ip->i_number)].di_ic = ip->i_ic;

        wtfs(d, sblock.fs_bsize, buf);
 }
 
        wtfs(d, sblock.fs_bsize, buf);
 }
 

diff --git a/usr/src/sbin/restore/main.c b/usr/src/sbin/restore/main.c
index 91e6126..efa315d 100644 (file)
--- a/usr/src/sbin/restore/main.c
+++ b/usr/src/sbin/restore/main.c
@@ -1,6 +1,6 @@
 /* Copyright (c) 1981 Regents of the University of California */
 
 /* Copyright (c) 1981 Regents of the University of California */
 

-char version[] = "@(#)main.c 1.10 %G%";
+char version[] = "@(#)main.c 1.11 %G%";

 
 /*     Modified to include h option (recursively extract all files within
  *     a subtree) and m option (recreate the heirarchical structure of
 
 /*     Modified to include h option (recursively extract all files within
  *     a subtree) and m option (recreate the heirarchical structure of


@@ -1217,8 +1217,8 @@ iexist(dev, ino)
        fs = getfs(dev);
        if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg)
                return (0);
        fs = getfs(dev);
        if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg)
                return (0);

-       cg = itog(ino, fs);
-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       cg = itog(fs, ino);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return(0);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return(0);
        cgp = bp->b_un.b_cg;

diff --git a/usr/src/sys/ufs/ffs/ffs_alloc.c b/usr/src/sys/ufs/ffs/ffs_alloc.c
index 580d6d2..3e7e79f 100644 (file)
--- a/usr/src/sys/ufs/ffs/ffs_alloc.c
+++ b/usr/src/sys/ufs/ffs/ffs_alloc.c
@@ -1,6 +1,6 @@
 /* Copyright (c) 1981 Regents of the University of California */
 
 /* Copyright (c) 1981 Regents of the University of California */
 

-static char vers[] = "@(#)ffs_alloc.c 1.14 %G%";
+static char vers[] = "@(#)ffs_alloc.c 1.15 %G%";

 
 /*     alloc.c 4.8     81/03/08        */
 
 
 /*     alloc.c 4.8     81/03/08        */
 


@@ -67,9 +67,9 @@ alloc(dev, ip, bpref, size)
        if (bpref >= fs->fs_size)
                bpref = 0;
        if (bpref == 0)
        if (bpref >= fs->fs_size)
                bpref = 0;
        if (bpref == 0)

-               cg = itog(ip->i_number, fs);
+               cg = itog(fs, ip->i_number);

        else
        else

-               cg = dtog(bpref, fs);
+               cg = dtog(fs, bpref);

        bno = (daddr_t)hashalloc(dev, fs, cg, (long)bpref, size, alloccg);
        if (bno == 0)
                goto nospace;
        bno = (daddr_t)hashalloc(dev, fs, cg, (long)bpref, size, alloccg);
        if (bno == 0)
                goto nospace;


@@ -112,7 +112,7 @@ realloccg(dev, bprev, bpref, osize, nsize)
              fs->fs_dsize * fs->fs_minfree / 100)
                goto nospace;
        if (bprev != 0)
              fs->fs_dsize * fs->fs_minfree / 100)
                goto nospace;
        if (bprev != 0)

-               cg = dtog(bprev, fs);
+               cg = dtog(fs, bprev);

        else
                panic("realloccg: bad bprev");
        bno = fragextend(dev, fs, cg, (long)bprev, osize, nsize);
        else
                panic("realloccg: bad bprev");
        bno = fragextend(dev, fs, cg, (long)bprev, osize, nsize);


@@ -185,7 +185,7 @@ ialloc(dev, ipref, mode)
                goto noinodes;
        if (ipref >= fs->fs_ncg * fs->fs_ipg)
                ipref = 0;
                goto noinodes;
        if (ipref >= fs->fs_ncg * fs->fs_ipg)
                ipref = 0;

-       cg = itog(ipref, fs);
+       cg = itog(fs, ipref);

        ino = (ino_t)hashalloc(dev, fs, cg, (long)ipref, mode, ialloccg);
        if (ino == 0)
                goto noinodes;
        ino = (ino_t)hashalloc(dev, fs, cg, (long)ipref, mode, ialloccg);
        if (ino == 0)
                goto noinodes;


@@ -339,11 +339,11 @@ fragextend(dev, fs, cg, bprev, osize, nsize)
                /* cannot extend across a block boundry */
                return (0);
        }
                /* cannot extend across a block boundry */
                return (0);
        }

-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;

-       bno = dtogd(bprev, fs);
+       bno = dtogd(fs, bprev);

        for (i = osize / fs->fs_fsize; i < frags; i++)
                if (isclr(cgp->cg_free, bno + i)) {
                        brelse(bp);
        for (i = osize / fs->fs_fsize; i < frags; i++)
                if (isclr(cgp->cg_free, bno + i)) {
                        brelse(bp);


@@ -394,7 +394,7 @@ alloccg(dev, fs, cg, bpref, size)
 
        if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
                return (0);
 
        if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
                return (0);

-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;


@@ -422,7 +422,7 @@ alloccg(dev, fs, cg, bpref, size)
                        return (0);
                }
                bno = alloccgblk(fs, cgp, bpref);
                        return (0);
                }
                bno = alloccgblk(fs, cgp, bpref);

-               bpref = dtogd(bno, fs);
+               bpref = dtogd(fs, bno);

                for (i = frags; i < fs->fs_frag; i++)
                        setbit(cgp->cg_free, bpref + i);
                i = fs->fs_frag - frags;
                for (i = frags; i < fs->fs_frag; i++)
                        setbit(cgp->cg_free, bpref + i);
                i = fs->fs_frag - frags;


@@ -475,7 +475,7 @@ alloccgblk(fs, cgp, bpref)
                goto norot;
        }
        bpref &= ~(fs->fs_frag - 1);
                goto norot;
        }
        bpref &= ~(fs->fs_frag - 1);

-       bpref = dtogd(bpref, fs);
+       bpref = dtogd(fs, bpref);

        /*
         * if the requested block is available, use it
         */
        /*
         * if the requested block is available, use it
         */


@@ -590,7 +590,7 @@ ialloccg(dev, fs, cg, ipref, mode)
 
        if (fs->fs_cs(fs, cg).cs_nifree == 0)
                return (0);
 
        if (fs->fs_cs(fs, cg).cs_nifree == 0)
                return (0);

-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;


@@ -647,14 +647,14 @@ fre(dev, bno, size)
        fs = getfs(dev);
        if ((unsigned)size > fs->fs_bsize || size % fs->fs_fsize != 0)
                panic("free: bad size");
        fs = getfs(dev);
        if ((unsigned)size > fs->fs_bsize || size % fs->fs_fsize != 0)
                panic("free: bad size");

-       cg = dtog(bno, fs);
+       cg = dtog(fs, bno);

        if (badblock(fs, bno))
                return;
        if (badblock(fs, bno))
                return;

-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return;
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return;
        cgp = bp->b_un.b_cg;

-       bno = dtogd(bno, fs);
+       bno = dtogd(fs, bno);

        if (size == fs->fs_bsize) {
                if (isblock(fs, cgp->cg_free, bno/fs->fs_frag))
                        panic("free: freeing free block");
        if (size == fs->fs_bsize) {
                if (isblock(fs, cgp->cg_free, bno/fs->fs_frag))
                        panic("free: freeing free block");


@@ -728,8 +728,8 @@ ifree(dev, ino, mode)
        fs = getfs(dev);
        if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg)
                panic("ifree: range");
        fs = getfs(dev);
        if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg)
                panic("ifree: range");

-       cg = itog(ino, fs);
-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       cg = itog(fs, ino);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return;
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return;
        cgp = bp->b_un.b_cg;


@@ -771,7 +771,7 @@ mapsearch(fs, cgp, bpref, allocsiz)
         * map for an appropriate bit pattern
         */
        if (bpref)
         * map for an appropriate bit pattern
         */
        if (bpref)

-               start = dtogd(bpref, fs) / NBBY;
+               start = dtogd(fs, bpref) / NBBY;

        else
                start = cgp->cg_frotor / NBBY;
        len = roundup(fs->fs_fpg - 1, NBBY) / NBBY - start;
        else
                start = cgp->cg_frotor / NBBY;
        len = roundup(fs->fs_fpg - 1, NBBY) / NBBY - start;


@@ -853,7 +853,7 @@ badblock(fs, bn)
        daddr_t bn;
 {
 
        daddr_t bn;
 {
 

-       if ((unsigned)bn >= fs->fs_size || bn < cgdmin(dtog(bn, fs), fs)) {
+       if ((unsigned)bn >= fs->fs_size || bn < cgdmin(fs, dtog(fs, bn))) {

                fserr(fs, "bad block");
                return (1);
        }
                fserr(fs, "bad block");
                return (1);
        }

diff --git a/usr/src/sys/ufs/ffs/fs.h b/usr/src/sys/ufs/ffs/fs.h
index 62aa5bc..d1b69de 100644 (file)
--- a/usr/src/sys/ufs/ffs/fs.h
+++ b/usr/src/sys/ufs/ffs/fs.h
@@ -1,6 +1,6 @@
 /* Copyright (c) 1981 Regents of the University of California */
 
 /* Copyright (c) 1981 Regents of the University of California */
 

-/*     fs.h    1.12    %G%     */
+/*     fs.h    1.13    %G%     */

 
 /*
  * Each disk drive contains some number of file systems.
 
 /*
  * Each disk drive contains some number of file systems.


@@ -22,7 +22,7 @@
  *     [fs->fs_iblkno]         Inode blocks
  *     [fs->fs_dblkno]         Data blocks
  * The beginning of cylinder group cg in fs, is given by
  *     [fs->fs_iblkno]         Inode blocks
  *     [fs->fs_dblkno]         Data blocks
  * The beginning of cylinder group cg in fs, is given by

- * the ``cgbase(cg, fs)'' macro.
+ * the ``cgbase(fs, cg)'' macro.

  *
  * The first boot and super blocks are given in absolute disk addresses.
  */
  *
  * The first boot and super blocks are given in absolute disk addresses.
  */


@@ -267,16 +267,16 @@ struct    cg {
  * Note that these are in absolute addresses, and can NOT
  * in general be expressable in terms of file system addresses.
  */
  * Note that these are in absolute addresses, and can NOT
  * in general be expressable in terms of file system addresses.
  */

-#define        cgbblock(c,fs)  (fsbtodb(fs, cgbase(c,fs)) + (fs)->fs_bblkno)
-#define        cgsblock(c,fs)  (fsbtodb(fs, cgbase(c,fs)) + (fs)->fs_sblkno)
+#define        cgbblock(fs, c) (fsbtodb(fs, cgbase(fs, c)) + (fs)->fs_bblkno)
+#define        cgsblock(fs, c) (fsbtodb(fs, cgbase(fs, c)) + (fs)->fs_sblkno)

 
 /*
  * file system addresses of cylinder group data structures
  */
 
 /*
  * file system addresses of cylinder group data structures
  */

-#define        cgbase(c,fs)    ((daddr_t)((fs)->fs_fpg * (c)))         /* base addr */
-#define        cgtod(c,fs)     (cgbase(c,fs) + (fs)->fs_cblkno)        /* cg block */
-#define        cgimin(c,fs)    (cgbase(c,fs) + (fs)->fs_iblkno)        /* inode blk */
-#define        cgdmin(c,fs)    (cgbase(c,fs) + (fs)->fs_dblkno)        /* 1st data */
+#define        cgbase(fs, c)   ((daddr_t)((fs)->fs_fpg * (c)))         /* base addr */
+#define        cgtod(fs, c)    (cgbase(fs, c) + (fs)->fs_cblkno)       /* cg block */
+#define        cgimin(fs, c)   (cgbase(fs, c) + (fs)->fs_iblkno)       /* inode blk */
+#define        cgdmin(fs, c)   (cgbase(fs, c) + (fs)->fs_dblkno)       /* 1st data */

 
 /*
  * macros for handling inode numbers
 
 /*
  * macros for handling inode numbers


@@ -284,18 +284,18 @@ struct    cg {
  *     inode number to cylinder group number
  *     inode number to file system block address
  */
  *     inode number to cylinder group number
  *     inode number to file system block address
  */

-#define        itoo(x,fs)      ((x) % INOPB(fs))
-#define        itog(x,fs)      ((x) / (fs)->fs_ipg)
-#define        itod(x,fs) \
-       ((daddr_t)(cgimin(itog(x,fs),fs) + \
+#define        itoo(fs, x)     ((x) % INOPB(fs))
+#define        itog(fs, x)     ((x) / (fs)->fs_ipg)
+#define        itod(fs, x) \
+       ((daddr_t)(cgimin(fs, itog(fs, x)) + \

        (x) % (fs)->fs_ipg / INOPB(fs) * (fs)->fs_frag))
 
 /*
  * give cylinder group number for a file system block
  * give cylinder group block number for a file system block
  */
        (x) % (fs)->fs_ipg / INOPB(fs) * (fs)->fs_frag))
 
 /*
  * give cylinder group number for a file system block
  * give cylinder group block number for a file system block
  */

-#define        dtog(d,fs)      ((d) / (fs)->fs_fpg)
-#define        dtogd(d,fs)     ((d) % (fs)->fs_fpg)
+#define        dtog(fs, d)     ((d) / (fs)->fs_fpg)
+#define        dtogd(fs, d)    ((d) % (fs)->fs_fpg)

 
 /*
  * compute the cylinder and rotational position of a cyl block addr
 
 /*
  * compute the cylinder and rotational position of a cyl block addr

diff --git a/usr/src/sys/ufs/lfs/lfs_alloc.c b/usr/src/sys/ufs/lfs/lfs_alloc.c
index c70860f..a334aa2 100644 (file)
--- a/usr/src/sys/ufs/lfs/lfs_alloc.c
+++ b/usr/src/sys/ufs/lfs/lfs_alloc.c
@@ -1,6 +1,6 @@
 /* Copyright (c) 1981 Regents of the University of California */
 
 /* Copyright (c) 1981 Regents of the University of California */
 

-static char vers[] = "@(#)lfs_alloc.c 1.14 %G%";
+static char vers[] = "@(#)lfs_alloc.c 1.15 %G%";

 
 /*     alloc.c 4.8     81/03/08        */
 
 
 /*     alloc.c 4.8     81/03/08        */
 


@@ -67,9 +67,9 @@ alloc(dev, ip, bpref, size)
        if (bpref >= fs->fs_size)
                bpref = 0;
        if (bpref == 0)
        if (bpref >= fs->fs_size)
                bpref = 0;
        if (bpref == 0)

-               cg = itog(ip->i_number, fs);
+               cg = itog(fs, ip->i_number);

        else
        else

-               cg = dtog(bpref, fs);
+               cg = dtog(fs, bpref);

        bno = (daddr_t)hashalloc(dev, fs, cg, (long)bpref, size, alloccg);
        if (bno == 0)
                goto nospace;
        bno = (daddr_t)hashalloc(dev, fs, cg, (long)bpref, size, alloccg);
        if (bno == 0)
                goto nospace;


@@ -112,7 +112,7 @@ realloccg(dev, bprev, bpref, osize, nsize)
              fs->fs_dsize * fs->fs_minfree / 100)
                goto nospace;
        if (bprev != 0)
              fs->fs_dsize * fs->fs_minfree / 100)
                goto nospace;
        if (bprev != 0)

-               cg = dtog(bprev, fs);
+               cg = dtog(fs, bprev);

        else
                panic("realloccg: bad bprev");
        bno = fragextend(dev, fs, cg, (long)bprev, osize, nsize);
        else
                panic("realloccg: bad bprev");
        bno = fragextend(dev, fs, cg, (long)bprev, osize, nsize);


@@ -185,7 +185,7 @@ ialloc(dev, ipref, mode)
                goto noinodes;
        if (ipref >= fs->fs_ncg * fs->fs_ipg)
                ipref = 0;
                goto noinodes;
        if (ipref >= fs->fs_ncg * fs->fs_ipg)
                ipref = 0;

-       cg = itog(ipref, fs);
+       cg = itog(fs, ipref);

        ino = (ino_t)hashalloc(dev, fs, cg, (long)ipref, mode, ialloccg);
        if (ino == 0)
                goto noinodes;
        ino = (ino_t)hashalloc(dev, fs, cg, (long)ipref, mode, ialloccg);
        if (ino == 0)
                goto noinodes;


@@ -339,11 +339,11 @@ fragextend(dev, fs, cg, bprev, osize, nsize)
                /* cannot extend across a block boundry */
                return (0);
        }
                /* cannot extend across a block boundry */
                return (0);
        }

-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;

-       bno = dtogd(bprev, fs);
+       bno = dtogd(fs, bprev);

        for (i = osize / fs->fs_fsize; i < frags; i++)
                if (isclr(cgp->cg_free, bno + i)) {
                        brelse(bp);
        for (i = osize / fs->fs_fsize; i < frags; i++)
                if (isclr(cgp->cg_free, bno + i)) {
                        brelse(bp);


@@ -394,7 +394,7 @@ alloccg(dev, fs, cg, bpref, size)
 
        if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
                return (0);
 
        if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
                return (0);

-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;


@@ -422,7 +422,7 @@ alloccg(dev, fs, cg, bpref, size)
                        return (0);
                }
                bno = alloccgblk(fs, cgp, bpref);
                        return (0);
                }
                bno = alloccgblk(fs, cgp, bpref);

-               bpref = dtogd(bno, fs);
+               bpref = dtogd(fs, bno);

                for (i = frags; i < fs->fs_frag; i++)
                        setbit(cgp->cg_free, bpref + i);
                i = fs->fs_frag - frags;
                for (i = frags; i < fs->fs_frag; i++)
                        setbit(cgp->cg_free, bpref + i);
                i = fs->fs_frag - frags;


@@ -475,7 +475,7 @@ alloccgblk(fs, cgp, bpref)
                goto norot;
        }
        bpref &= ~(fs->fs_frag - 1);
                goto norot;
        }
        bpref &= ~(fs->fs_frag - 1);

-       bpref = dtogd(bpref, fs);
+       bpref = dtogd(fs, bpref);

        /*
         * if the requested block is available, use it
         */
        /*
         * if the requested block is available, use it
         */


@@ -590,7 +590,7 @@ ialloccg(dev, fs, cg, ipref, mode)
 
        if (fs->fs_cs(fs, cg).cs_nifree == 0)
                return (0);
 
        if (fs->fs_cs(fs, cg).cs_nifree == 0)
                return (0);

-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return (0);
        cgp = bp->b_un.b_cg;


@@ -647,14 +647,14 @@ fre(dev, bno, size)
        fs = getfs(dev);
        if ((unsigned)size > fs->fs_bsize || size % fs->fs_fsize != 0)
                panic("free: bad size");
        fs = getfs(dev);
        if ((unsigned)size > fs->fs_bsize || size % fs->fs_fsize != 0)
                panic("free: bad size");

-       cg = dtog(bno, fs);
+       cg = dtog(fs, bno);

        if (badblock(fs, bno))
                return;
        if (badblock(fs, bno))
                return;

-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return;
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return;
        cgp = bp->b_un.b_cg;

-       bno = dtogd(bno, fs);
+       bno = dtogd(fs, bno);

        if (size == fs->fs_bsize) {
                if (isblock(fs, cgp->cg_free, bno/fs->fs_frag))
                        panic("free: freeing free block");
        if (size == fs->fs_bsize) {
                if (isblock(fs, cgp->cg_free, bno/fs->fs_frag))
                        panic("free: freeing free block");


@@ -728,8 +728,8 @@ ifree(dev, ino, mode)
        fs = getfs(dev);
        if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg)
                panic("ifree: range");
        fs = getfs(dev);
        if ((unsigned)ino >= fs->fs_ipg*fs->fs_ncg)
                panic("ifree: range");

-       cg = itog(ino, fs);
-       bp = bread(dev, fsbtodb(fs, cgtod(cg, fs)), fs->fs_bsize);
+       cg = itog(fs, ino);
+       bp = bread(dev, fsbtodb(fs, cgtod(fs, cg)), fs->fs_bsize);

        if (bp->b_flags & B_ERROR)
                return;
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR)
                return;
        cgp = bp->b_un.b_cg;


@@ -771,7 +771,7 @@ mapsearch(fs, cgp, bpref, allocsiz)
         * map for an appropriate bit pattern
         */
        if (bpref)
         * map for an appropriate bit pattern
         */
        if (bpref)

-               start = dtogd(bpref, fs) / NBBY;
+               start = dtogd(fs, bpref) / NBBY;

        else
                start = cgp->cg_frotor / NBBY;
        len = roundup(fs->fs_fpg - 1, NBBY) / NBBY - start;
        else
                start = cgp->cg_frotor / NBBY;
        len = roundup(fs->fs_fpg - 1, NBBY) / NBBY - start;


@@ -853,7 +853,7 @@ badblock(fs, bn)
        daddr_t bn;
 {
 
        daddr_t bn;
 {
 

-       if ((unsigned)bn >= fs->fs_size || bn < cgdmin(dtog(bn, fs), fs)) {
+       if ((unsigned)bn >= fs->fs_size || bn < cgdmin(fs, dtog(fs, bn))) {

                fserr(fs, "bad block");
                return (1);
        }
                fserr(fs, "bad block");
                return (1);
        }