checkpoint

[unix-history] / usr / src / sbin / icheck / icheck.c

diff --git a/usr/src/sbin/icheck/icheck.c b/usr/src/sbin/icheck/icheck.c
index f2ae437..203fcca 100644 (file)
--- a/usr/src/sbin/icheck/icheck.c
+++ b/usr/src/sbin/icheck/icheck.c
@@ -1,36 +1,53 @@
-static char *sccsid = "@(#)icheck.c    1.6 (Berkeley) %G%";
+/*-
+ * Copyright (c) 1988 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * %sccs.include.proprietary.c%
+ */
+
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1988 The Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)icheck.c   5.10 (Berkeley) %G%";
+#endif /* not lint */

 
 /*
  * icheck
  */
 #define        NB      500
 
 /*
  * icheck
  */
 #define        NB      500

-#define        BITS    8

 #define        MAXFN   500
 #define        MAXFN   500

+#define        MAXNINDIR       (MAXBSIZE / sizeof (daddr_t))

 
 

+#include <sys/param.h>
+#include <sys/time.h>
+#include <ufs/ufs/dinode.h>
+#include <ufs/ffs/fs.h>

 #ifndef STANDALONE
 #include <stdio.h>
 #endif
 #ifndef STANDALONE
 #include <stdio.h>
 #endif

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

 
 union {
        struct  fs sb;
 
 union {
        struct  fs sb;

-       char pad[BSIZE];
+       char pad[SBSIZE];

 } sbun;
 #define        sblock sbun.sb
 
 union {
        struct  cg cg;
 } sbun;
 #define        sblock sbun.sb
 
 union {
        struct  cg cg;

-       char pad[BSIZE];
+       char pad[MAXBSIZE];

 } cgun;
 #define        cgrp cgun.cg
 
 } cgun;
 #define        cgrp cgun.cg
 

-struct dinode  itab[MAXIPG];
+struct dinode itab[MAXBSIZE / sizeof(struct dinode)];
+

 daddr_t        blist[NB];
 daddr_t        blist[NB];

+daddr_t        fsblist[NB];

 char   *bmap;
 
 char   *bmap;
 

-int    sflg;

 int    mflg;
 int    dflg;
 int    fi;
 int    mflg;
 int    dflg;
 int    fi;


@@ -41,7 +58,8 @@ ino_t nrfile;
 ino_t  ndfile;
 ino_t  nbfile;
 ino_t  ncfile;
 ino_t  ndfile;
 ino_t  nbfile;
 ino_t  ncfile;

-ino_t  nmcfile;
+ino_t  nlfile;
+ino_t  nsfile;

 
 daddr_t        nblock;
 daddr_t        nfrag;
 
 daddr_t        nblock;
 daddr_t        nfrag;


@@ -54,15 +72,17 @@ daddr_t     nbfree;
 daddr_t        ndup;
 
 int    nerror;
 daddr_t        ndup;
 
 int    nerror;

+long   dev_bsize = 1;

 
 long   atol();
 
 long   atol();

-daddr_t        alloc();

 #ifndef STANDALONE
 char   *malloc();
 #ifndef STANDALONE
 char   *malloc();

+char   *calloc();

 #endif
 
 main(argc, argv)
 #endif
 
 main(argc, argv)

-char *argv[];
+       int argc;
+       char *argv[];

 {
        register i;
        long n;
 {
        register i;
        long n;


@@ -81,12 +101,8 @@ char *argv[];
                        mflg++;
                        continue;
 
                        mflg++;
                        continue;
 

-               case 's':
-                       sflg++;
-                       continue;
-

                case 'b':
                case 'b':

-                       for(i=0; i<NB; i++) {
+                       for(i=0; i<NB && argc >= 2; i++) {

                                n = atol(argv[1]);
                                if(n == 0)
                                        break;
                                n = atol(argv[1]);
                                if(n == 0)
                                        break;


@@ -115,15 +131,16 @@ char *argv[];
 }
 
 check(file)
 }
 
 check(file)

-char *file;
+       char *file;

 {
        register i, j, c;
        daddr_t d, cgd, cbase, b;
        long n;
 {
        register i, j, c;
        daddr_t d, cgd, cbase, b;
        long n;

+       char buf[BUFSIZ];

 
 

-       fi = open(file, sflg?2:0);
+       fi = open(file, 0);

        if (fi < 0) {
        if (fi < 0) {

-               printf("cannot open %s\n", file);
+               perror(file);

                nerror |= 04;
                return;
        }
                nerror |= 04;
                return;
        }


@@ -132,7 +149,8 @@ char *file;
        ndfile = 0;
        ncfile = 0;
        nbfile = 0;
        ndfile = 0;
        ncfile = 0;
        nbfile = 0;

-       nmcfile = 0;
+       nlfile = 0;
+       nsfile = 0;

 
        nblock = 0;
        nfrag = 0;
 
        nblock = 0;
        nfrag = 0;


@@ -143,19 +161,13 @@ char *file;
 #ifndef STANDALONE
        sync();
 #endif
 #ifndef STANDALONE
        sync();
 #endif

-       bread(SBLOCK, (char *)&sblock, BSIZE);
-       if (sblock.fs_magic != FS_MAGIC) {
-               printf("%s: bad magic number\n", file);
-               nerror |= 04;
+       getsb(&sblock, file);
+       if (nerror)

                return;
                return;

-       }
-       for (n = 0; n < howmany(cssize(&sblock), BSIZE); n++) {
-               sblock.fs_csp[n] = (struct csum *)calloc(1, BSIZE);
-               bread(csaddr(&sblock) + (n * FRAG),
-                     (char *)sblock.fs_csp[n], BSIZE);
-       }
+       for (n=0; blist[n] != -1; n++)
+               fsblist[n] = dbtofsb(&sblock, blist[n]);

        ino = 0;
        ino = 0;

-       n = (sblock.fs_size*FRAG + BITS-1) / BITS;
+       n = roundup(howmany(sblock.fs_size, NBBY), sizeof(short));

 #ifdef STANDALONE
        bmap = NULL;
 #else
 #ifdef STANDALONE
        bmap = NULL;
 #else


@@ -164,68 +176,76 @@ char *file;
        if (bmap==NULL) {
                printf("Not enough core; duplicates unchecked\n");
                dflg++;
        if (bmap==NULL) {
                printf("Not enough core; duplicates unchecked\n");
                dflg++;

-               sflg = 0;

        }
        ino = 0;
        cginit = 1;
        }
        ino = 0;
        cginit = 1;

-       if(!dflg) {
-               for (i=0; i<(unsigned)n; i++)
+       if (!dflg) {
+               for (i = 0; i < (unsigned)n; i++)

                        bmap[i] = 0;
                        bmap[i] = 0;

-               for (c=0; c < sblock.fs_ncg; c++) {
-                       cgd = cgtod(c, &sblock);
-                       for (d = cgbase(c, &sblock); d < cgd; d += FRAG)
-                               chk(d, "badcg", BSIZE);
-                       d = cgimin(c, &sblock);
+               for (c = 0; c < sblock.fs_ncg; c++) {
+                       cgd = cgtod(&sblock, c);
+                       if (c == 0)
+                               d = cgbase(&sblock, c);
+                       else
+                               d = cgsblock(&sblock, c);
+                       (void)sprintf(buf, "spare super block %d", c);
+                       for (; d < cgd; d += sblock.fs_frag)
+                               chk(d, buf, sblock.fs_bsize);
+                       d = cgimin(&sblock, c);
+                       (void)sprintf(buf, "cylinder group %d", c);

                        while (cgd < d) {
                        while (cgd < d) {

-                               chk(cgd, "cg", BSIZE);
-                               cgd += FRAG;
+                               chk(cgd, buf, sblock.fs_bsize);
+                               cgd += sblock.fs_frag;
+                       }
+                       d = cgdmin(&sblock, c);
+                       i = INOPB(&sblock);
+                       for (; cgd < d; cgd += sblock.fs_frag) {
+                               (void)sprintf(buf, "inodes %d-%d", ino, ino + i);
+                               chk(cgd, buf, sblock.fs_bsize);
+                               ino += i;

                        }
                        }

-                       d = cgdmin(c, &sblock);
-                       for (; cgd < d; cgd += FRAG)
-                               chk(cgd, "inode", BSIZE);

                        if (c == 0) {
                        if (c == 0) {

-                               d += howmany(cssize(&sblock), FSIZE);
-                               for (; cgd < d; cgd += FRAG)
-                                       chk(cgd, "csum", BSIZE);
+                               d += howmany(sblock.fs_cssize, sblock.fs_fsize);
+                               for (; cgd < d; cgd++)
+                                       chk(cgd, "csum", sblock.fs_fsize);

                        }
                }
        }
                        }
                }
        }

+       ino = 0;

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

-               bread(cgimin(c,&sblock), (char *)itab,
-                   sblock.fs_ipg * sizeof (struct dinode));
-               for (j=0; j < sblock.fs_ipg; j++) {
-                       pass1(&itab[j]);
-                       ino++;
+               for (i = 0;
+                    i < sblock.fs_ipg / INOPF(&sblock);
+                    i += sblock.fs_frag) {
+                       bread(fsbtodb(&sblock, cgimin(&sblock, c) + i),
+                           (char *)itab, sblock.fs_bsize);
+                       for (j = 0; j < INOPB(&sblock); j++) {
+                               pass1(&itab[j]);
+                               ino++;
+                       }

                }
        }
        ino = 0;
 #ifndef STANDALONE
        sync();
 #endif
                }
        }
        ino = 0;
 #ifndef STANDALONE
        sync();
 #endif

-       bread(SBLOCK, (char *)&sblock, sizeof(sblock));
-       if (sflg) {
-               makecg();
-               close(fi);
-#ifndef STANDALONE
-               if (bmap)
-                       free(bmap);
-#endif
-               return;
-       }

        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(cgtod(c,&sblock), (char *)&cgrp, sblock.fs_cgsize);
-               for (b = 0; b < sblock.fs_fpg; b += FRAG) {
-                       if (isblock(cgrp.cg_free, b / FRAG)) {
+               cbase = cgbase(&sblock, c);
+               bread(fsbtodb(&sblock, cgtod(&sblock, c)), (char *)&cgrp,
+                       sblock.fs_cgsize);
+               if (!cg_chkmagic(&cgrp))
+                       printf("cg %d: bad magic number\n", c);
+               for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) {
+                       if (isblock(&sblock, cg_blksfree(&cgrp),
+                           b / sblock.fs_frag)) {

                                nbfree++;
                                nbfree++;

-                               chk(cbase+b, "block", BSIZE);
+                               chk(cbase+b, "free block", sblock.fs_bsize);

                        } else {
                        } else {

-                               for (d = 0; d < FRAG; d++)
-                                       if (isset(cgrp.cg_free, b+d)) {
-                                               chk(cbase+b+d, "frag", FSIZE);
+                               for (d = 0; d < sblock.fs_frag; d++)
+                                       if (isset(cg_blksfree(&cgrp), b+d)) {
+                                               chk(cbase+b+d, "free frag", sblock.fs_fsize);

                                                nffree++;
                                        }
                        }
                                                nffree++;
                                        }
                        }


@@ -237,30 +257,30 @@ char *file;
                free(bmap);
 #endif
 
                free(bmap);
 #endif
 

-       i = nrfile + ndfile + ncfile + nbfile + nmcfile;
+       i = nrfile + ndfile + ncfile + nbfile + nlfile + nsfile;

 #ifndef STANDALONE
 #ifndef STANDALONE

-       printf("files %6u (r=%u,d=%u,b=%u,c=%u,mc=%u)\n",
-               i, nrfile, ndfile, nbfile, ncfile, nmcfile);
+       printf("files %6u (r=%u,d=%u,b=%u,c=%u,sl=%u,sock=%u)\n",
+               i, nrfile, ndfile, nbfile, ncfile, nlfile, nsfile);

 #else
 #else

-       printf("files %u (r=%u,d=%u,b=%u,c=%u,mc=%u)\n",
-               i, nrfile, ndfile, nbfile, ncfile, nmcfile);
+       printf("files %u (r=%u,d=%u,b=%u,c=%u,sl=%u,sock=%u)\n",
+               i, nrfile, ndfile, nbfile, ncfile, nlfile, nsfile);

 #endif
 #endif

-       n = (nblock + nindir + niindir) * FRAG + nfrag;
+       n = (nblock + nindir + niindir) * sblock.fs_frag + nfrag;

 #ifdef STANDALONE
        printf("used %ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
                n, nindir, niindir, nblock, nfrag);
 #ifdef STANDALONE
        printf("used %ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
                n, nindir, niindir, nblock, nfrag);

-       printf("free %ld (b=%ld,f=%ld)\n", nffree + FRAG * nbfree,
+       printf("free %ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree,

            nbfree, nffree);
 #else
        printf("used %7ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
                n, nindir, niindir, nblock, nfrag);
            nbfree, nffree);
 #else
        printf("used %7ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
                n, nindir, niindir, nblock, nfrag);

-       printf("free %7ld (b=%ld,f=%ld)\n", nffree + FRAG * nbfree,
+       printf("free %7ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree,

            nbfree, nffree);
 #endif
        if(!dflg) {
                n = 0;
                for (d = 0; d < sblock.fs_size; d++)
            nbfree, nffree);
 #endif
        if(!dflg) {
                n = 0;
                for (d = 0; d < sblock.fs_size; d++)

-                       if(!duped(d, FSIZE)) {
+                       if(!duped(d, sblock.fs_fsize)) {

                                if(mflg)
                                        printf("%ld missing\n", d);
                                n++;
                                if(mflg)
                                        printf("%ld missing\n", d);
                                n++;


@@ -272,16 +292,16 @@ char *file;
 pass1(ip)
        register struct dinode *ip;
 {
 pass1(ip)
        register struct dinode *ip;
 {

-       daddr_t ind1[NINDIR];
-       daddr_t ind2[NINDIR];
+       daddr_t ind1[MAXNINDIR];
+       daddr_t ind2[MAXNINDIR];

        daddr_t db, ib;
        register int i, j, k, siz;
        daddr_t db, ib;
        register int i, j, k, siz;

+       int lbn;
+       char buf[BUFSIZ];

 
        i = ip->di_mode & IFMT;
 
        i = ip->di_mode & IFMT;

-       if(i == 0) {
-               sblock.fs_nifree++;
+       if(i == 0)

                return;
                return;

-       }

        switch (i) {
        case IFCHR:
                ncfile++;
        switch (i) {
        case IFCHR:
                ncfile++;


@@ -295,6 +315,12 @@ pass1(ip)
        case IFREG:
                nrfile++;
                break;
        case IFREG:
                nrfile++;
                break;

+       case IFSOCK:
+               nsfile++;
+               break;
+       case IFLNK:
+               nlfile++;
+               break;

        default:
                printf("bad mode %u\n", ino);
                return;
        default:
                printf("bad mode %u\n", ino);
                return;


@@ -303,49 +329,54 @@ pass1(ip)
                db = ip->di_db[i];
                if (db == 0)
                        continue;
                db = ip->di_db[i];
                if (db == 0)
                        continue;

-               siz = dblksize(ip, i);
-               chk(db, "data (block)", siz);
-               if (siz == BSIZE)
+               siz = dblksize(&sblock, ip, i);
+               (void)sprintf(buf, "logical data block %d", i);
+               chk(db, buf, siz);
+               if (siz == sblock.fs_bsize)

                        nblock++;
                else
                        nblock++;
                else

-                       nfrag += howmany(siz, FSIZE);
+                       nfrag += howmany(siz, sblock.fs_fsize);

        }
        for(i = 0; i < NIADDR; i++) {
                ib = ip->di_ib[i];
        }
        for(i = 0; i < NIADDR; i++) {
                ib = ip->di_ib[i];

-               if(ib == 0)
+               if (ib == 0)

                        continue;
                        continue;

-               if (chk(ib, "1st indirect", BSIZE))
+               if (chk(ib, "1st indirect", sblock.fs_bsize))

                        continue;
                        continue;

-               bread(ib, (char *)ind1, BSIZE);
+               bread(fsbtodb(&sblock, ib), (char *)ind1, sblock.fs_bsize);

                nindir++;
                nindir++;

-               for (j = 0; j < NINDIR; j++) {
+               for (j = 0; j < NINDIR(&sblock); j++) {

                        ib = ind1[j];
                        if (ib == 0)
                                continue;
                        if (i == 0) {
                        ib = ind1[j];
                        if (ib == 0)
                                continue;
                        if (i == 0) {

-                               siz = dblksize(ip, NDADDR + j);
-                               chk(ib, "data (large)", siz);
-                               if (siz == BSIZE)
+                               lbn = NDADDR + j;
+                               siz = dblksize(&sblock, ip, lbn);
+                               (void)sprintf(buf, "logical data block %d", lbn);
+                               chk(ib, buf, siz);
+                               if (siz == sblock.fs_bsize)

                                        nblock++;
                                else
                                        nblock++;
                                else

-                                       nfrag += howmany(siz, FSIZE);
+                                       nfrag += howmany(siz, sblock.fs_fsize);

                                continue;
                        }
                                continue;
                        }

-                       if (chk(ib, "2nd indirect", BSIZE))
+                       if (chk(ib, "2nd indirect", sblock.fs_bsize))

                                continue;
                                continue;

-                       bread(ib, (char *)ind2, BSIZE);
+                       bread(fsbtodb(&sblock, ib), (char *)ind2,
+                               sblock.fs_bsize);

                        niindir++;
                        niindir++;

-                       for (k = 0; k < NINDIR; k++) {
+                       for (k = 0; k < NINDIR(&sblock); k++) {

                                ib = ind2[k];
                                if (ib == 0)
                                        continue;
                                ib = ind2[k];
                                if (ib == 0)
                                        continue;

-                               siz = dblksize(ip,
-                                   NDADDR + NINDIR * (i + j) + k);
-                               chk(ib, "data (huge)", siz);
-                               if (siz == BSIZE)
+                               lbn = NDADDR + NINDIR(&sblock) * (i + j) + k;
+                               siz = dblksize(&sblock, ip, lbn);
+                               (void)sprintf(buf, "logical data block %d", lbn);
+                               chk(ib, buf, siz);
+                               if (siz == sblock.fs_bsize)

                                        nblock++;
                                else
                                        nblock++;
                                else

-                                       nfrag += howmany(siz, FSIZE);
+                                       nfrag += howmany(siz, sblock.fs_fsize);

                        }
                }
        }
                        }
                }
        }


@@ -357,22 +388,23 @@ chk(bno, s, size)
        int size;
 {
        register n, cg;
        int size;
 {
        register n, cg;

+       int frags;

 
 

-       cg = dtog(bno, &sblock);
-       if (cginit==0 &&
-           bno<cgdmin(cg,&sblock) || bno >= FRAG * sblock.fs_size) {
+       cg = dtog(&sblock, bno);
+       if (cginit == 0 && 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);
        }

-       if (size == BSIZE) {
+       frags = numfrags(&sblock, size);
+       if (frags == sblock.fs_frag) {

                if (duped(bno, size)) {
                        printf("%ld dup block; inode=%u, class=%s\n",
                            bno, ino, s);
                if (duped(bno, size)) {
                        printf("%ld dup block; inode=%u, class=%s\n",
                            bno, ino, s);

-                       ndup += FRAG;
+                       ndup += sblock.fs_frag;

                }
        } else {
                }
        } else {

-               for (n = 0; n < size / FSIZE; n++) {
-                       if (duped(bno + n, FSIZE)) {
+               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);
                                ndup++;
                                printf("%ld dup frag; inode=%u, class=%s\n",
                                    bno, ino, s);
                                ndup++;


@@ -380,8 +412,9 @@ chk(bno, s, size)
                }
        }
        for (n=0; blist[n] != -1; n++)
                }
        }
        for (n=0; blist[n] != -1; n++)

-               if (bno == blist[n])
-                       printf("%ld arg; inode=%u, class=%s\n", bno, ino, s);
+               if (fsblist[n] >= bno && fsblist[n] < bno + frags)
+                       printf("%ld arg; frag %d of %d, inode=%u, class=%s\n",
+                               blist[n], fsblist[n] - bno, frags, ino, s);

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


@@ -391,142 +424,123 @@ duped(bno, size)
 {
        if(dflg)
                return(0);
 {
        if(dflg)
                return(0);

-       if (size != FSIZE && size != BSIZE)
+       if (size != sblock.fs_fsize && size != sblock.fs_bsize)

                printf("bad size %d to duped\n", size);
                printf("bad size %d to duped\n", size);

-       if (size == FSIZE) {
+       if (size == sblock.fs_fsize) {

                if (isset(bmap, bno))
                        return(1);
                setbit(bmap, bno);
                return (0);
        }
                if (isset(bmap, bno))
                        return(1);
                setbit(bmap, bno);
                return (0);
        }

-       if (bno % FRAG != 0)
+       if (bno % sblock.fs_frag != 0)

                printf("bad bno %d to duped\n", bno);
                printf("bad bno %d to duped\n", bno);

-       if (isblock(bmap, bno/FRAG))
+       if (isblock(&sblock, bmap, bno/sblock.fs_frag))

                return (1);
                return (1);

-       setblock(bmap, bno/FRAG);
+       setblock(&sblock, bmap, bno/sblock.fs_frag);

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

+getsb(fs, file)
+       register struct fs *fs;
+       char *file;
+{
+       int i, j, size;
+
+       if (bread(SBOFF, fs, SBSIZE)) {
+               printf("bad super block");
+               perror(file);
+               nerror |= 04;
+               return;
+       }
+       if (fs->fs_magic != FS_MAGIC) {
+               printf("%s: bad magic number\n", file);
+               nerror |= 04;
+               return;
+       }
+       dev_bsize = fs->fs_fsize / fsbtodb(fs, 1);
+       for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
+               size = sblock.fs_cssize - i < sblock.fs_bsize ?
+                   sblock.fs_cssize - i : sblock.fs_bsize;
+               sblock.fs_csp[j] = (struct csum *)calloc(1, size);
+               bread(fsbtodb(fs, fs->fs_csaddr + (j * fs->fs_frag)),
+                     (char *)fs->fs_csp[j], size);
+       }
+}
+

 bread(bno, buf, cnt)
        daddr_t bno;
        char *buf;
 {
        register i;
 
 bread(bno, buf, cnt)
        daddr_t bno;
        char *buf;
 {
        register i;
 

-       lseek(fi, bno*FSIZE, 0);
+       lseek(fi, bno * dev_bsize, 0);

        if ((i = read(fi, buf, cnt)) != cnt) {
        if ((i = read(fi, buf, cnt)) != cnt) {

-               if (sflg) {
-                       printf("No update\n");
-                       sflg = 0;
-               }
-               for(i=0; i<BSIZE; i++)
+               for(i=0; i<sblock.fs_bsize; i++)

                        buf[i] = 0;
                        buf[i] = 0;

+               return (1);

        }
        }

+       return (0);

 }
 
 }
 

-bwrite(bno, buf, cnt)
-       daddr_t bno;
-       char *buf;
+/*
+ * check if a block is available
+ */
+isblock(fs, cp, h)
+       struct fs *fs;
+       unsigned char *cp;
+       int h;

 {
 {

-       lseek(fi, bno*FSIZE, 0);
-       if (write(fi, buf, cnt) != cnt)
-               printf("write error %d\n", tell(fi)/BSIZE);
+       unsigned char mask;
+
+       switch (fs->fs_frag) {
+       case 8:
+               return (cp[h] == 0xff);
+       case 4:
+               mask = 0x0f << ((h & 0x1) << 2);
+               return ((cp[h >> 1] & mask) == mask);
+       case 2:
+               mask = 0x03 << ((h & 0x3) << 1);
+               return ((cp[h >> 2] & mask) == mask);
+       case 1:
+               mask = 0x01 << (h & 0x7);
+               return ((cp[h >> 3] & mask) == mask);
+       default:
+#ifdef STANDALONE
+               printf("isblock bad fs_frag %d\n", fs->fs_frag);
+#else
+               fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
+#endif
+               return;
+       }

 }
 
 }
 

-makecg()
+/*
+ * put a block into the map
+ */
+setblock(fs, cp, h)
+       struct fs *fs;
+       unsigned char *cp;
+       int h;

 {
 {

-       int c;
-       daddr_t dbase, d, dmin, dmax;
-       long i, j, s;
-       register struct csum *cs;
-
-       sblock.fs_nbfree = 0;
-       sblock.fs_nffree = 0;
-       for (c = 0; c < sblock.fs_ncg; c++) {
-               bread(cgimin(c,&sblock), (char *)itab,
-                   sblock.fs_ipg * sizeof (struct dinode));
-               dbase = cgbase(c, &sblock);
-               dmax = dbase + sblock.fs_fpg;
-               if (dmax > sblock.fs_size)
-                       dmax = sblock.fs_size;
-               cs = &sblock.fs_cs(c);
-               cgrp.cg_time = time((long)0);
-               cgrp.cg_magic = CG_MAGIC;
-               cgrp.cg_cgx = c;
-               cgrp.cg_ncyl = sblock.fs_cpg;
-               cgrp.cg_niblk = sblock.fs_ipg;
-               cgrp.cg_ndblk = dmax - dbase;
-               cgrp.cg_ndir = 0;
-               cgrp.cg_nffree = 0;
-               cgrp.cg_nbfree = 0;
-               cgrp.cg_nifree = 0;
-               for (i = 0; i < sblock.fs_ipg; i++)
-               switch (itab[i].di_mode&IFMT) {
-
-               case 0:
-                       cgrp.cg_nifree++;
-                       clrbit(cgrp.cg_iused, i);
-                       continue;
-
-               case IFDIR:
-                       cgrp.cg_ndir++;
-                       /* fall into ... */
-
-               default:
-                       setbit(cgrp.cg_iused, i);
-                       continue;
-               }
-               while (i < MAXIPG) {
-                       clrbit(cgrp.cg_iused, i);
-                       i++;
-               }
-               for (s = 0; s < MAXCPG; s++)
-                       for (i = 0; i < NRPOS; i++)
-                               cgrp.cg_b[s][i] = 0;
-               dmin = cgdmin(c, &sblock) - dbase;
-               if (c == 0)
-                       dmin += howmany(cssize(&sblock), BSIZE) * FRAG;
-               for (d = 0; d < dmin; d++)
-                       clrbit(cgrp.cg_free, d);
-#define        getbmap(i) isset(bmap, i)
-               for (; (d + FRAG) <= dmax - dbase; d += FRAG) {
-                       j = 0;
-                       for (i = 0; i < FRAG; i++) {
-                               if (!getbmap(dbase+d+i)) {
-                                       setbit(cgrp.cg_free, d+i);
-                                       j++;
-                               } else
-                                       clrbit(cgrp.cg_free, d+i);
-                       }
-                       if (j == FRAG) {
-                               cgrp.cg_nbfree++;
-                               s = d * NSPF;
-                               cgrp.cg_b[s/sblock.fs_spc]
-                                 [s%sblock.fs_nsect*NRPOS/sblock.fs_nsect]++;
-                       } else
-                               cgrp.cg_nffree += j;
-               }
-               for (; d < dmax - dbase; d++) {
-                       if (!getbmap(dbase+d)) {
-                               setbit(cgrp.cg_free, d);
-                               cgrp.cg_nffree++;
-                       } else
-                               clrbit(cgrp.cg_free, d);
-               }
-               for (; d < MAXBPG; d++)
-                       clrbit(cgrp.cg_free, d);
-               sblock.fs_nffree += cgrp.cg_nffree;
-               sblock.fs_nbfree += cgrp.cg_nbfree;
-               cs->cs_ndir = cgrp.cg_ndir;
-               cs->cs_nifree = cgrp.cg_nifree;
-               cs->cs_nbfree = cgrp.cg_nbfree;
-               bwrite(cgtod(c, &sblock), (char *)&cgrp, sblock.fs_cgsize);
-       }
-       sblock.fs_ronly = 0;
-       sblock.fs_fmod = 0;
-       bwrite(SBLOCK, (char *)&sblock, sizeof (sblock));
-       for (i = 0; i < howmany(cssize(&sblock), BSIZE); i++) {
-               bwrite(csaddr(&sblock) + (i * FRAG),
-                     (char *)sblock.fs_csp[i], BSIZE);
+       switch (fs->fs_frag) {
+       case 8:
+               cp[h] = 0xff;
+               return;
+       case 4:
+               cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
+               return;
+       case 2:
+               cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
+               return;
+       case 1:
+               cp[h >> 3] |= (0x01 << (h & 0x7));
+               return;
+       default:
+#ifdef STANDALONE
+               printf("setblock bad fs_frag %d\n", fs->fs_frag);
+#else
+               fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
+#endif
+               return;

        }
 }
        }
 }