use speed-up macros in fs.h

SCCS-vsn: sbin/newfs/mkfs.c 1.19
SCCS-vsn: sbin/fsck/main.c 1.25
SCCS-vsn: old/dcheck/dcheck.c 1.8
SCCS-vsn: sbin/icheck/icheck.c 1.19
SCCS-vsn: sbin/ncheck/ncheck.c 1.8
SCCS-vsn: sbin/dumpfs/dumpfs.c 1.11

diff --git a/usr/src/old/dcheck/dcheck.c b/usr/src/old/dcheck/dcheck.c
index c8ae09d..c909cb3 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.7 (Berkeley) %G%";
+static char *sccsid = "@(#)dcheck.c    1.8 (Berkeley) %G%";

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


@@ -186,7 +186,7 @@ readdir(dirp)
        for(;;) {
                if (dirp->loc >= dirp->ip->di_size)
                        return NULL;
        for(;;) {
                if (dirp->loc >= dirp->ip->di_size)
                        return NULL;

-               if ((lbn = dirp->loc / sblock.fs_bsize) == 0) {
+               if ((lbn = lblkno(&sblock, dirp->loc)) == 0) {

                        d = bmap(lbn);
                        if(d == 0)
                                return NULL;
                        d = bmap(lbn);
                        if(d == 0)
                                return NULL;


@@ -194,7 +194,7 @@ readdir(dirp)
                            dblksize(&sblock, dirp->ip, lbn));
                }
                dp = (struct direct *)
                            dblksize(&sblock, dirp->ip, lbn));
                }
                dp = (struct direct *)

-                   (dirp->dbuf + dirp->loc % sblock.fs_bsize);
+                   (dirp->dbuf + blkoff(&sblock, dirp->loc));

                dirp->loc += dp->d_reclen;
                if (dp->d_ino == 0)
                        continue;
                dirp->loc += dp->d_reclen;
                if (dp->d_ino == 0)
                        continue;

diff --git a/usr/src/sbin/dumpfs/dumpfs.c b/usr/src/sbin/dumpfs/dumpfs.c
index d68663e..237a4f1 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.10 (Berkeley) %G%";
+static char *sccsid = "@(#)dumpfs.c    1.11 (Berkeley) %G%";

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


@@ -31,33 +31,27 @@ main(argc, argv)
        lseek(0, SBLOCK * DEV_BSIZE, 0);
        if (read(0, &afs, SBSIZE) != SBSIZE)
                perror(argv[1]), exit(1);
        lseek(0, SBLOCK * DEV_BSIZE, 0);
        if (read(0, &afs, SBSIZE) != SBSIZE)
                perror(argv[1]), exit(1);

-       printf("magic\t%x\n", afs.fs_magic);
-       printf("bblkno\t%d\n", afs.fs_bblkno);
-       printf("sblkno\t%d\n", afs.fs_sblkno);
-       printf("cblkno\t%d\n", afs.fs_cblkno);
-       printf("iblkno\t%d\n", afs.fs_iblkno);
-       printf("dblkno\t%d\n", afs.fs_dblkno);
-       printf("time\t%s", ctime(&afs.fs_time));
-       printf("size\t%d\n", afs.fs_size);
-       printf("blocks\t%d\n", afs.fs_dsize);
-       printf("ncg\t%d\n", afs.fs_ncg);
-       printf("bsize\t%d\n", afs.fs_bsize);
-       printf("fsize\t%d\n", afs.fs_fsize);
-       printf("frag\t%d\n", afs.fs_frag);
-       printf("minfree\t%d%%\n", afs.fs_minfree);
-       printf("rotdelay %dms\n", afs.fs_rotdelay);
-       printf("rps\t%d\n", afs.fs_rps);
-       printf("csaddr\t%d\n", afs.fs_csaddr);
-       printf("cssize\t%d\n", afs.fs_cssize);
-       printf("cgsize\t%d\n", afs.fs_cgsize);
-       printf("ntrak\t%d\nnsect\t%d\nspc\t%d\nncyl\t%d\n",
+       printf("magic\t%x\ttime\t%s", afs.fs_magic, ctime(&afs.fs_time));
+       printf("bblkno\t%d\tsblkno\t%d\n", afs.fs_bblkno, afs.fs_sblkno);
+       printf("cblkno\t%d\tiblkno\t%d\tdblkno\t%d\n",
+           afs.fs_cblkno, afs.fs_iblkno, afs.fs_dblkno);
+       printf("ncg\t%d\tsize\t%d\tblocks\t%d\tcgsize\t%d\n",
+           afs.fs_ncg, afs.fs_size, afs.fs_dsize, afs.fs_cgsize);
+       printf("bsize\t%d\tshift\t%d\tmask\t0x%08x\n",
+           afs.fs_bsize, afs.fs_bshift, afs.fs_bmask);
+       printf("fsize\t%d\tshift\t%d\tmask\t0x%08x\n",
+           afs.fs_fsize, afs.fs_fshift, afs.fs_fmask);
+       printf("frag\t%d\tminfree\t%d%%\n", afs.fs_frag, afs.fs_minfree);
+       printf("rotdelay %dms\trps\t%d\n", afs.fs_rotdelay, afs.fs_rps);
+       printf("csaddr\t%d\tcssize\t%d\n", afs.fs_csaddr, afs.fs_cssize);
+       printf("ntrak\t%d\tnsect\t%d\tspc\t%d\tncyl\t%d\n",

            afs.fs_ntrak, afs.fs_nsect, afs.fs_spc, afs.fs_ncyl);
            afs.fs_ntrak, afs.fs_nsect, afs.fs_spc, afs.fs_ncyl);

-       printf("cpg\t%d\nbpg\t%d\nfpg\t%d\nipg\t%d\n",
+       printf("cpg\t%d\tbpg\t%d\tfpg\t%d\tipg\t%d\n",

            afs.fs_cpg, afs.fs_fpg / afs.fs_frag, afs.fs_fpg, afs.fs_ipg);
            afs.fs_cpg, afs.fs_fpg / afs.fs_frag, afs.fs_fpg, afs.fs_ipg);

-       printf("ndir\t%d\nnffree\t%d\nnbfree\t%d\nnifree\t%d\n",
-           afs.fs_cstotal.cs_ndir, afs.fs_cstotal.cs_nffree,
-           afs.fs_cstotal.cs_nbfree, afs.fs_cstotal.cs_nifree);
-       printf("cgrotor\t%d\nfmod\t%d\nronly\t%d\n",
+       printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n",
+           afs.fs_cstotal.cs_nbfree, afs.fs_cstotal.cs_ndir,
+           afs.fs_cstotal.cs_nifree, afs.fs_cstotal.cs_nffree);
+       printf("cgrotor\t%d\tfmod\t%d\tronly\t%d\n",

            afs.fs_cgrotor, afs.fs_fmod, afs.fs_ronly);
        if (afs.fs_cpc != 0)
                printf("blocks available in each rotational position");
            afs.fs_cgrotor, afs.fs_fmod, afs.fs_ronly);
        if (afs.fs_cpc != 0)
                printf("blocks available in each rotational position");


@@ -113,18 +107,19 @@ dumpcg(c)
 
        printf("\ncg %d:\n", c);
        lseek(0, fsbtodb(&afs, cgtod(&afs, c)) * DEV_BSIZE, 0);
 
        printf("\ncg %d:\n", c);
        lseek(0, fsbtodb(&afs, cgtod(&afs, c)) * DEV_BSIZE, 0);

-       printf("tell\t%x\n", tell(0));
+       i = tell(0);

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

-       printf("magic\t%x\ntime\t%s", acg.cg_magic, ctime(&acg.cg_time));
-       printf("cgx\t%d\nncyl\t%d\nniblk\t%d\nndblk\t%d\n",
+       printf("magic\t%x\ttell\t%x\ttime\t%s",
+           acg.cg_magic, i, ctime(&acg.cg_time));
+       printf("cgx\t%d\tncyl\t%d\tniblk\t%d\tndblk\t%d\n",

            acg.cg_cgx, acg.cg_ncyl, acg.cg_niblk, acg.cg_ndblk);
            acg.cg_cgx, acg.cg_ncyl, acg.cg_niblk, acg.cg_ndblk);

-       printf("nifree\t%d\nndir\t%d\nnffree\t%d\nnbfree\t%d\n",
-           acg.cg_cs.cs_nifree, acg.cg_cs.cs_ndir,
-           acg.cg_cs.cs_nffree, acg.cg_cs.cs_nbfree);
-       printf("rotor\t%d\nirotor\t%d\nfrotor\t%d\nfrsum",
+       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",

            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]);
            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]);


@@ -153,7 +148,7 @@ pbits(cp, max)
        for (i = 0; i < max; i++)
                if (isset(cp, i)) {
                        if (count)
        for (i = 0; i < max; i++)
                if (isset(cp, i)) {
                        if (count)

-                               printf(",%s", count %10 == 9 ? "\n\t" : " ");
+                               printf(",%s", count %9 == 8 ? "\n\t" : " ");

                        count++;
                        printf("%d", i);
                        j = i;
                        count++;
                        printf("%d", i);
                        j = i;

diff --git a/usr/src/sbin/fsck/main.c b/usr/src/sbin/fsck/main.c
index 5adbdc0..de12dfa 100644 (file)
--- a/usr/src/sbin/fsck/main.c
+++ b/usr/src/sbin/fsck/main.c
@@ -1,13 +1,13 @@
-static char *sccsid = "@(#)main.c      1.24 (Berkeley) %G%";
+static char *sccsid = "@(#)main.c      1.25 (Berkeley) %G%";

 
 #include <stdio.h>
 #include <ctype.h>
 #include "../h/param.h"
 #include "../h/fs.h"
 
 #include <stdio.h>
 #include <ctype.h>
 #include "../h/param.h"
 #include "../h/fs.h"

-#include "../h/ndir.h"

 #include "../h/inode.h"
 #include "../h/stat.h"
 #include "../h/ostat.h"
 #include "../h/inode.h"
 #include "../h/stat.h"
 #include "../h/ostat.h"

+#include <ndir.h>

 #include <fstab.h>
 
 typedef        int     (*SIG_TYP)();
 #include <fstab.h>
 
 typedef        int     (*SIG_TYP)();


@@ -759,15 +759,15 @@ ckinode(dp, flg)
 {
        register daddr_t *ap;
        register ret;
 {
        register daddr_t *ap;
        register ret;

-       int (*func)(), n, ndb, size;
+       int (*func)(), n, ndb, size, offset;

 
        if (SPECIAL)
                return (KEEPON);
        func = (flg == ADDR) ? pfunc : dirscan;
        ndb = howmany(dp->di_size, sblock.fs_bsize);
        for (ap = &dp->di_db[0]; ap < &dp->di_db[NDADDR]; ap++) {
 
        if (SPECIAL)
                return (KEEPON);
        func = (flg == ADDR) ? pfunc : dirscan;
        ndb = howmany(dp->di_size, sblock.fs_bsize);
        for (ap = &dp->di_db[0]; ap < &dp->di_db[NDADDR]; ap++) {

-               if (--ndb == 0 && (dp->di_size % sblock.fs_bsize))
-                       size = howmany(dp->di_size % sblock.fs_bsize, sblock.fs_fsize);
+               if (--ndb == 0 && (offset = blkoff(&sblock, dp->di_size)) != 0)
+                       size = numfrags(&sblock, fragroundup(&sblock, offset));

                else
                        size = sblock.fs_frag;
                if (*ap && (ret = (*func)(*ap, size)) & STOP)
                else
                        size = sblock.fs_frag;
                if (*ap && (ret = (*func)(*ap, size)) & STOP)


@@ -804,7 +804,7 @@ iblock(blk, ilevel, flg, isize)
                return (SKIP);
        ilevel--;
        if (ilevel == 0) {
                return (SKIP);
        ilevel--;
        if (ilevel == 0) {

-               nif = isize / sblock.fs_bsize + 1;
+               nif = lblkno(&sblock, isize) + 1;

        } else /* ilevel == 1 */ {
                nif = isize / (sblock.fs_bsize * NINDIR(&sblock)) + 1;
        }
        } else /* ilevel == 1 */ {
                nif = isize / (sblock.fs_bsize * NINDIR(&sblock)) + 1;
        }


@@ -1269,9 +1269,8 @@ setup(dev)
        if (sblock.fs_dblkno != 
            sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock))
                { badsb("DBLKNO CORRUPTED"); return (0); }
        if (sblock.fs_dblkno != 
            sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock))
                { badsb("DBLKNO CORRUPTED"); return (0); }

-       if (sblock.fs_cgsize !=
-           roundup(sizeof(struct cg) + howmany(sblock.fs_fpg, NBBY),
-           sblock.fs_fsize))
+       if (sblock.fs_cgsize != fragroundup(&sblock,
+           sizeof(struct cg) + howmany(sblock.fs_fpg, NBBY)))

                { badsb("CGSIZE INCORRECT"); return (0); }
        if (sblock.fs_cssize != sblock.fs_ncg * sizeof(struct csum))
                { badsb("CSSIZE INCORRECT"); return (0); }
                { badsb("CGSIZE INCORRECT"); return (0); }
        if (sblock.fs_cssize != sblock.fs_ncg * sizeof(struct csum))
                { badsb("CSSIZE INCORRECT"); return (0); }


@@ -1599,7 +1598,7 @@ makecg()
                sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir;
                *cs = cgrp.cg_cs;
                bwrite(&dfile, &cgrp, fsbtodb(&sblock, cgtod(&sblock, c)),
                sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir;
                *cs = cgrp.cg_cs;
                bwrite(&dfile, &cgrp, fsbtodb(&sblock, cgtod(&sblock, c)),

-                       roundup(sblock.fs_cgsize, DEV_BSIZE));
+                   sblock.fs_cgsize);

        }
        for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) {
                bwrite(&dfile, (char *)sblock.fs_csp[i],
        }
        for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) {
                bwrite(&dfile, (char *)sblock.fs_csp[i],


@@ -1734,8 +1733,8 @@ linkup()
                printf("\n\n");
                return (0);
        }
                printf("\n\n");
                return (0);
        }

-       if (dp->di_size % sblock.fs_bsize) {
-               dp->di_size = roundup(dp->di_size, sblock.fs_bsize);
+       if (fragoff(&sblock, dp->di_size)) {
+               dp->di_size = fragroundup(&sblock, dp->di_size);

                inodirty();
        }
        filsize = dp->di_size;
                inodirty();
        }
        filsize = dp->di_size;

diff --git a/usr/src/sbin/icheck/icheck.c b/usr/src/sbin/icheck/icheck.c
index 34a1720..212e088 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.18 (Berkeley) %G%";
+static char *sccsid = "@(#)icheck.c    1.19 (Berkeley) %G%";

 
 /*
  * icheck
 
 /*
  * icheck


@@ -357,6 +357,7 @@ chk(bno, s, size)
        int size;
 {
        register n, cg;
        int size;
 {
        register n, cg;

+       int frags;

 
        cg = dtog(&sblock, bno);
        if (cginit==0 &&
 
        cg = dtog(&sblock, bno);
        if (cginit==0 &&


@@ -371,7 +372,8 @@ chk(bno, s, size)
                        ndup += sblock.fs_frag;
                }
        } else {
                        ndup += sblock.fs_frag;
                }
        } else {

-               for (n = 0; n < size / sblock.fs_fsize; n++) {
+               frags = numfrags(&sblock, size);
+               for (n = 0; n < frags; n++) {

                        if (duped(bno + n, sblock.fs_fsize)) {
                                printf("%ld dup frag; inode=%u, class=%s\n",
                                    bno, ino, s);
                        if (duped(bno + n, sblock.fs_fsize)) {
                                printf("%ld dup frag; inode=%u, class=%s\n",
                                    bno, ino, s);

diff --git a/usr/src/sbin/ncheck/ncheck.c b/usr/src/sbin/ncheck/ncheck.c
index 67eb239..f7b97a4 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.7 (Berkeley) %G%";
+static char *sccsid = "@(#)ncheck.c    1.8 (Berkeley) %G%";

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


@@ -230,7 +230,7 @@ readdir(dirp)
        for(;;) {
                if (dirp->loc >= dirp->ip->di_size)
                        return NULL;
        for(;;) {
                if (dirp->loc >= dirp->ip->di_size)
                        return NULL;

-               if ((lbn = dirp->loc / sblock.fs_bsize) == 0) {
+               if ((lbn = lblkno(&sblock, dirp->loc)) == 0) {

                        d = bmap(lbn);
                        if(d == 0)
                                return NULL;
                        d = bmap(lbn);
                        if(d == 0)
                                return NULL;


@@ -238,7 +238,7 @@ readdir(dirp)
                            dblksize(&sblock, dirp->ip, lbn));
                }
                dp = (struct direct *)
                            dblksize(&sblock, dirp->ip, lbn));
                }
                dp = (struct direct *)

-                   (dirp->dbuf + dirp->loc % sblock.fs_bsize);
+                   (dirp->dbuf + blkoff(&sblock, dirp->loc));

                dirp->loc += dp->d_reclen;
                if (dp->d_ino == 0)
                        continue;
                dirp->loc += dp->d_reclen;
                if (dp->d_ino == 0)
                        continue;

diff --git a/usr/src/sbin/newfs/mkfs.c b/usr/src/sbin/newfs/mkfs.c
index 1a32af1..a948927 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.18 (Berkeley) %G%";
+static char *sccsid = "@(#)mkfs.c      1.19 (Berkeley) %G%";

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


@@ -137,7 +137,13 @@ main(argc, argv)
                    sblock.fs_bsize, sblock.fs_fsize);
                exit(1);
        }
                    sblock.fs_bsize, sblock.fs_fsize);
                exit(1);
        }

-       sblock.fs_frag = sblock.fs_bsize / sblock.fs_fsize;
+       sblock.fs_bmask = ~(sblock.fs_bsize - 1);
+       sblock.fs_fmask = ~(sblock.fs_fsize - 1);
+       for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)
+               sblock.fs_bshift++;
+       for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
+               sblock.fs_fshift++;
+       sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);

        if (sblock.fs_frag > MAXFRAG) {
                printf("fragment size %d is too small, minimum with block size %d is %d\n",
                    sblock.fs_fsize, sblock.fs_bsize,
        if (sblock.fs_frag > MAXFRAG) {
                printf("fragment size %d is too small, minimum with block size %d is %d\n",
                    sblock.fs_fsize, sblock.fs_bsize,


@@ -268,8 +274,8 @@ next:
                    (sblock.fs_fpg / sblock.fs_cpg));
                exit(1);
        }
                    (sblock.fs_fpg / sblock.fs_cpg));
                exit(1);
        }

-       sblock.fs_cgsize = roundup(sizeof(struct cg) +
-           howmany(sblock.fs_fpg, NBBY), sblock.fs_fsize);
+       sblock.fs_cgsize = fragroundup(&sblock,
+           sizeof(struct cg) + howmany(sblock.fs_fpg, NBBY));

        /*
         * Compute/validate number of cylinder groups.
         */
        /*
         * Compute/validate number of cylinder groups.
         */


@@ -309,7 +315,7 @@ next:
        sblock.fs_csaddr = cgdmin(&sblock, 0);
        sblock.fs_cssize = sblock.fs_ncg * sizeof(struct csum);
        fscs = (struct csum *)
        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));
+           calloc(1, blkroundup(&sblock, sblock.fs_cssize));

        sblock.fs_magic = FS_MAGIC;
        sblock.fs_rotdelay = ROTDELAY;
        sblock.fs_minfree = MINFREE;
        sblock.fs_magic = FS_MAGIC;
        sblock.fs_rotdelay = ROTDELAY;
        sblock.fs_minfree = MINFREE;


@@ -351,7 +357,7 @@ next:
        sblock.fs_time = utime;
        wtfs(SBLOCK, SBSIZE, (char *)&sblock);
        for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)
        sblock.fs_time = utime;
        wtfs(SBLOCK, SBSIZE, (char *)&sblock);
        for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)

-               wtfs(fsbtodb(&sblock, sblock.fs_csaddr + i / sblock.fs_fsize),
+               wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),

                        sblock.fs_bsize, ((char *)fscs) + i);
        /* 
         * Write out the duplicate super blocks
                        sblock.fs_bsize, ((char *)fscs) + i);
        /* 
         * Write out the duplicate super blocks


@@ -420,7 +426,7 @@ initcg(cylno)
        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))
        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);
+               printf("write error %D\n", numfrags(&sblock, tell(fso)));

        for (i = 0; i < MAXCPG; i++) {
                acg.cg_btot[i] = 0;
                for (j = 0; j < NRPOS; j++)
        for (i = 0; i < MAXCPG; i++) {
                acg.cg_btot[i] = 0;
                for (j = 0; j < NRPOS; j++)


@@ -544,8 +550,8 @@ alloc(size, mode)
        int i, frag;
        daddr_t d;
 
        int i, frag;
        daddr_t d;
 

-       rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)),
-               roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
+       rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+           (char *)&acg);

        if (acg.cg_cs.cs_nbfree == 0) {
                printf("first cylinder group ran out of space\n");
                return (0);
        if (acg.cg_cs.cs_nbfree == 0) {
                printf("first cylinder group ran out of space\n");
                return (0);


@@ -576,8 +582,8 @@ 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(&sblock, 0)),
-               roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
+       wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+           (char *)&acg);

        return (d);
 }
 
        return (d);
 }
 


@@ -592,12 +598,12 @@ iput(ip)
        int c;
 
        c = itog(&sblock, ip->i_number);
        int c;
 
        c = itog(&sblock, ip->i_number);

-       rdfs(fsbtodb(&sblock, cgtod(&sblock, c)),
-               roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
+       rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+           (char *)&acg);

        acg.cg_cs.cs_nifree--;
        setbit(acg.cg_iused, ip->i_number);
        acg.cg_cs.cs_nifree--;
        setbit(acg.cg_iused, ip->i_number);

-       wtfs(fsbtodb(&sblock, cgtod(&sblock, c)),
-               roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
+       wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+           (char *)&acg);

        sblock.fs_cstotal.cs_nifree--;
        fscs[0].cs_nifree--;
        if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
        sblock.fs_cstotal.cs_nifree--;
        fscs[0].cs_nifree--;
        if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {