1: #define NI  16
   2: #define NB  10
   3: #define BITS    8
   4: #define MAXFN   500
   5: 
   6: #ifndef STANDALONE
   7: #include <stdio.h>
   8: #endif
   9: #include <sys/param.h>
  10: #include <sys/inode.h>
  11: #include <sys/ino.h>
  12: #include <sys/fblk.h>
  13: #include <sys/filsys.h>
  14: 
  15: struct  filsys  sblock;
  16: struct  dinode  itab[INOPB*NI];
  17: daddr_t iaddr[NADDR];
  18: daddr_t blist[NB];
  19: char    *bmap;
  20: 
  21: int sflg;
  22: int mflg;
  23: int dflg;
  24: int fi;
  25: ino_t   ino;
  26: 
  27: ino_t   nrfile;
  28: ino_t   ndfile;
  29: ino_t   nbfile;
  30: ino_t   ncfile;
  31: 
  32: daddr_t ndirect;
  33: daddr_t nindir;
  34: daddr_t niindir;
  35: daddr_t niiindir;
  36: daddr_t nfree;
  37: daddr_t ndup;
  38: 
  39: int nerror;
  40: 
  41: long    atol();
  42: daddr_t alloc();
  43: #ifndef STANDALONE
  44: char    *malloc();
  45: #endif
  46: 
  47: main(argc, argv)
  48: char *argv[];
  49: {
  50:     register i;
  51:     long n;
  52: 
  53:     blist[0] = -1;
  54: #ifndef STANDALONE
  55:     while (--argc) {
  56:         argv++;
  57:         if (**argv=='-')
  58:         switch ((*argv)[1]) {
  59:         case 'd':
  60:             dflg++;
  61:             continue;
  62: 
  63: 
  64:         case 'm':
  65:             mflg++;
  66:             continue;
  67: 
  68:         case 's':
  69:             sflg++;
  70:             continue;
  71: 
  72:         case 'b':
  73:             for(i=0; i<NB; i++) {
  74:                 n = atol(argv[1]);
  75:                 if(n == 0)
  76:                     break;
  77:                 blist[i] = n;
  78:                 argv++;
  79:                 argc--;
  80:             }
  81:             blist[i] = -1;
  82:             continue;
  83: 
  84:         default:
  85:             printf("Bad flag\n");
  86:         }
  87:         check(*argv);
  88:     }
  89: #else
  90:     {
  91:         static char fname[0];
  92: 
  93:         printf("File: ");
  94:         gets(fname);
  95:         check(fname);
  96:     }
  97: #endif
  98:     return(nerror);
  99: }
 100: 
 101: check(file)
 102: char *file;
 103: {
 104:     register i, j;
 105:     ino_t mino;
 106:     daddr_t d;
 107:     long n;
 108: 
 109:     fi = open(file, sflg?2:0);
 110:     if (fi < 0) {
 111:         printf("cannot open %s\n", file);
 112:         nerror |= 04;
 113:         return;
 114:     }
 115:     printf("%s:\n", file);
 116:     nrfile = 0;
 117:     ndfile = 0;
 118:     ncfile = 0;
 119:     nbfile = 0;
 120: 
 121:     ndirect = 0;
 122:     nindir = 0;
 123:     niindir = 0;
 124:     niiindir = 0;
 125: 
 126:     ndup = 0;
 127: #ifndef STANDALONE
 128:     sync();
 129: #endif
 130:     bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
 131:     mino = (sblock.s_isize-2) * INOPB;
 132:     ino = 0;
 133:     n = (sblock.s_fsize - sblock.s_isize + BITS-1) / BITS;
 134:     if (n != (unsigned)n) {
 135:         printf("Check fsize and isize: %ld, %u\n",
 136:            sblock.s_fsize, sblock.s_isize);
 137:     }
 138: #ifdef STANDALONE
 139:     bmap = NULL;
 140: #else
 141:     bmap = malloc((unsigned)n);
 142: #endif
 143:     if (bmap==NULL) {
 144:         printf("Not enough core; duplicates unchecked\n");
 145:         dflg++;
 146:         sflg = 0;
 147:     }
 148:     if(!dflg)
 149:     for(i=0; i<(unsigned)n; i++)
 150:         bmap[i] = 0;
 151:     for(i=2;; i+=NI) {
 152:         if(ino >= mino)
 153:             break;
 154:         bread((daddr_t)i, (char *)itab, sizeof(itab));
 155:         for(j=0; j<INOPB*NI; j++) {
 156:             if(ino >= mino)
 157:                 break;
 158:             ino++;
 159:             pass1(&itab[j]);
 160:         }
 161:     }
 162:     ino = 0;
 163: #ifndef STANDALONE
 164:     sync();
 165: #endif
 166:     bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
 167:     if (sflg) {
 168:         makefree();
 169:         close(fi);
 170: #ifndef STANDALONE
 171:         if (bmap)
 172:             free(bmap);
 173: #endif
 174:         return;
 175:     }
 176:     nfree = 0;
 177:     while(n = alloc()) {
 178:         if (chk(n, "free"))
 179:             break;
 180:         nfree++;
 181:     }
 182:     close(fi);
 183: #ifndef STANDALONE
 184:     if (bmap)
 185:         free(bmap);
 186: #endif
 187: 
 188:     i = nrfile + ndfile + ncfile + nbfile;
 189: #ifndef STANDALONE
 190:     printf("files %6u (r=%u,d=%u,b=%u,c=%u)\n",
 191:         i, nrfile, ndfile, nbfile, ncfile);
 192: #else
 193:     printf("files %u (r=%u,d=%u,b=%u,c=%u)\n",
 194:         i, nrfile, ndfile, nbfile, ncfile);
 195: #endif
 196:     n = ndirect + nindir + niindir + niindir;
 197: #ifdef STANDALONE
 198:     printf("used %ld (i=%ld,ii=%ld,iii=%ld,d=%ld)\n",
 199:         n, nindir, niindir, niiindir, ndirect);
 200:     printf("free %ld\n", nfree);
 201: #else
 202:     printf("used %7ld (i=%ld,ii=%ld,iii=%ld,d=%ld)\n",
 203:         n, nindir, niindir, niiindir, ndirect);
 204:     printf("free %7ld\n", nfree);
 205: #endif
 206:     if(!dflg) {
 207:         n = 0;
 208:         for(d=sblock.s_isize; d<sblock.s_fsize; d++)
 209:             if(!duped(d)) {
 210:                 if(mflg)
 211:                     printf("%ld missing\n", d);
 212:                 n++;
 213:             }
 214:         printf("missing%5ld\n", n);
 215:     }
 216: }
 217: 
 218: pass1(ip)
 219: register struct dinode *ip;
 220: {
 221:     daddr_t ind1[NINDIR];
 222:     daddr_t ind2[NINDIR];
 223:     daddr_t ind3[NINDIR];
 224:     register i, j;
 225:     int k, l;
 226: 
 227:     i = ip->di_mode & IFMT;
 228:     if(i == 0) {
 229:         sblock.s_tinode++;
 230:         return;
 231:     }
 232:     if(i == IFCHR) {
 233:         ncfile++;
 234:         return;
 235:     }
 236:     if(i == IFBLK) {
 237:         nbfile++;
 238:         return;
 239:     }
 240:     if(i == IFDIR)
 241:         ndfile++; else
 242:     if(i == IFREG)
 243:         nrfile++;
 244:     else {
 245:         printf("bad mode %u\n", ino);
 246:         return;
 247:     }
 248:     l3tol(iaddr, ip->di_addr, NADDR);
 249:     for(i=0; i<NADDR; i++) {
 250:         if(iaddr[i] == 0)
 251:             continue;
 252:         if(i < NADDR-3) {
 253:             ndirect++;
 254:             chk(iaddr[i], "data (small)");
 255:             continue;
 256:         }
 257:         nindir++;
 258:         if (chk(iaddr[i], "1st indirect"))
 259:                 continue;
 260:         bread(iaddr[i], (char *)ind1, BSIZE);
 261:         for(j=0; j<NINDIR; j++) {
 262:             if(ind1[j] == 0)
 263:                 continue;
 264:             if(i == NADDR-3) {
 265:                 ndirect++;
 266:                 chk(ind1[j], "data (large)");
 267:                 continue;
 268:             }
 269:             niindir++;
 270:             if(chk(ind1[j], "2nd indirect"))
 271:                 continue;
 272:             bread(ind1[j], (char *)ind2, BSIZE);
 273:             for(k=0; k<NINDIR; k++) {
 274:                 if(ind2[k] == 0)
 275:                     continue;
 276:                 if(i == NADDR-2) {
 277:                     ndirect++;
 278:                     chk(ind2[k], "data (huge)");
 279:                     continue;
 280:                 }
 281:                 niiindir++;
 282:                 if(chk(ind2[k], "3rd indirect"))
 283:                     continue;
 284:                 bread(ind2[k], (char *)ind3, BSIZE);
 285:                 for(l=0; l<NINDIR; l++)
 286:                     if(ind3[l]) {
 287:                         ndirect++;
 288:                         chk(ind3[l], "data (garg)");
 289:                     }
 290:             }
 291:         }
 292:     }
 293: }
 294: 
 295: chk(bno, s)
 296: daddr_t bno;
 297: char *s;
 298: {
 299:     register n;
 300: 
 301:     if (bno<sblock.s_isize || bno>=sblock.s_fsize) {
 302:         printf("%ld bad; inode=%u, class=%s\n", bno, ino, s);
 303:         return(1);
 304:     }
 305:     if(duped(bno)) {
 306:         printf("%ld dup; inode=%u, class=%s\n", bno, ino, s);
 307:         ndup++;
 308:     }
 309:     for (n=0; blist[n] != -1; n++)
 310:         if (bno == blist[n])
 311:             printf("%ld arg; inode=%u, class=%s\n", bno, ino, s);
 312:     return(0);
 313: }
 314: 
 315: duped(bno)
 316: daddr_t bno;
 317: {
 318:     daddr_t d;
 319:     register m, n;
 320: 
 321:     if(dflg)
 322:         return(0);
 323:     d = bno - sblock.s_isize;
 324:     m = 1 << (d%BITS);
 325:     n = (d/BITS);
 326:     if(bmap[n] & m)
 327:         return(1);
 328:     bmap[n] |= m;
 329:     return(0);
 330: }
 331: 
 332: daddr_t
 333: alloc()
 334: {
 335:     int i;
 336:     daddr_t bno;
 337:     union {
 338:         char    data[BSIZE];
 339:         struct  fblk fb;
 340:     } buf;
 341: 
 342:     sblock.s_tfree--;
 343:     if (sblock.s_nfree<=0)
 344:         return(0);
 345:     if (sblock.s_nfree>NICFREE) {
 346:         printf("Bad free list, s.b. count = %d\n", sblock.s_nfree);
 347:         return(0);
 348:     }
 349:     bno = sblock.s_free[--sblock.s_nfree];
 350:     sblock.s_free[sblock.s_nfree] = (daddr_t)0;
 351:     if(bno == 0)
 352:         return(bno);
 353:     if(sblock.s_nfree <= 0) {
 354:         bread(bno, buf.data, BSIZE);
 355:         sblock.s_nfree = buf.df_nfree;
 356:         if (sblock.s_nfree<0 || sblock.s_nfree>NICFREE) {
 357:             printf("Bad free list, entry count of block %ld = %d\n",
 358:                 bno, sblock.s_nfree);
 359:             sblock.s_nfree = 0;
 360:             return(0);
 361:         }
 362:         for(i=0; i<NICFREE; i++)
 363:             sblock.s_free[i] = buf.df_free[i];
 364:     }
 365:     return(bno);
 366: }
 367: 
 368: bfree(bno)
 369: daddr_t bno;
 370: {
 371:     union {
 372:         char    data[BSIZE];
 373:         struct  fblk fb;
 374:     } buf;
 375:     int i;
 376: 
 377:     sblock.s_tfree++;
 378:     if(sblock.s_nfree >= NICFREE) {
 379:         for(i=0; i<BSIZE; i++)
 380:             buf.data[i] = 0;
 381:         buf.df_nfree = sblock.s_nfree;
 382:         for(i=0; i<NICFREE; i++)
 383:             buf.df_free[i] = sblock.s_free[i];
 384:         bwrite(bno, buf.data);
 385:         sblock.s_nfree = 0;
 386:     }
 387:     sblock.s_free[sblock.s_nfree] = bno;
 388:     sblock.s_nfree++;
 389: }
 390: 
 391: bread(bno, buf, cnt)
 392: daddr_t bno;
 393: char *buf;
 394: {
 395:     register i;
 396: 
 397:     lseek(fi, bno*BSIZE, 0);
 398:     if (read(fi, buf, cnt) != cnt) {
 399:         printf("read error %ld\n", bno);
 400:         if (sflg) {
 401:             printf("No update\n");
 402:             sflg = 0;
 403:         }
 404:         for(i=0; i<BSIZE; i++)
 405:             buf[i] = 0;
 406:     }
 407: }
 408: 
 409: bwrite(bno, buf)
 410: daddr_t bno;
 411: char    *buf;
 412: {
 413: 
 414:     lseek(fi, bno*BSIZE, 0);
 415:     if (write(fi, buf, BSIZE) != BSIZE)
 416:         printf("write error %ld\n", bno);
 417: }
 418: 
 419: makefree()
 420: {
 421:     char flg[MAXFN];
 422:     int adr[MAXFN];
 423:     register i, j;
 424:     daddr_t f, d;
 425:     int m, n;
 426: 
 427:     n = sblock.s_n;
 428:     if(n <= 0 || n > MAXFN)
 429:         n = MAXFN;
 430:     sblock.s_n = n;
 431:     m = sblock.s_m;
 432:     if(m <= 0 || m > sblock.s_n)
 433:         m = 3;
 434:     sblock.s_m = m;
 435: 
 436:     for(i=0; i<n; i++)
 437:         flg[i] = 0;
 438:     i = 0;
 439:     for(j=0; j<n; j++) {
 440:         while(flg[i])
 441:             i = (i+1)%n;
 442:         adr[j] = i+1;
 443:         flg[i]++;
 444:         i = (i+m)%n;
 445:     }
 446: 
 447:     sblock.s_nfree = 0;
 448:     sblock.s_ninode = 0;
 449:     sblock.s_flock = 0;
 450:     sblock.s_ilock = 0;
 451:     sblock.s_fmod = 0;
 452:     sblock.s_ronly = 0;
 453: #ifndef STANDALONE
 454:     time(&sblock.s_time);
 455: #endif
 456:     sblock.s_tfree = 0;
 457:     sblock.s_tinode = 0;
 458: 
 459:     bfree((daddr_t)0);
 460:     d = sblock.s_fsize-1;
 461:     while(d%sblock.s_n)
 462:         d++;
 463:     for(; d > 0; d -= sblock.s_n)
 464:     for(i=0; i<sblock.s_n; i++) {
 465:         f = d - adr[i];
 466:         if(f < sblock.s_fsize && f >= sblock.s_isize)
 467:             if(!duped(f))
 468:                 bfree(f);
 469:     }
 470:     bwrite((daddr_t)1, (char *)&sblock);
 471: #ifndef STANDALONE
 472:     sync();
 473: #endif
 474:     return;
 475: }

Defined functions

alloc defined in line 332; used 2 times
bfree defined in line 368; used 2 times
bread defined in line 391; used 7 times
bwrite defined in line 409; used 2 times
check defined in line 101; used 2 times
chk defined in line 295; used 8 times
duped defined in line 315; used 3 times
main defined in line 47; never used
makefree defined in line 419; used 1 times
pass1 defined in line 218; used 1 times

Defined variables

blist defined in line 18; used 5 times
bmap defined in line 19; used 10 times
dflg defined in line 23; used 5 times
fi defined in line 24; used 8 times
iaddr defined in line 17; used 5 times
ino defined in line 25; used 9 times
itab defined in line 16; used 3 times
mflg defined in line 22; used 2 times
nbfile defined in line 29; used 5 times
ncfile defined in line 30; used 5 times
ndfile defined in line 28; used 5 times
ndirect defined in line 32; used 8 times
ndup defined in line 37; used 2 times
nerror defined in line 39; used 2 times
nfree defined in line 36; used 4 times
niiindir defined in line 35; used 4 times
niindir defined in line 34; used 6 times
nindir defined in line 33; used 5 times
nrfile defined in line 27; used 5 times
sblock defined in line 15; used 59 times
sflg defined in line 21; used 6 times

Defined macros

BITS defined in line 3; used 4 times
MAXFN defined in line 4; used 4 times
NB defined in line 2; used 2 times
NI defined in line 1; used 3 times
Last modified: 1979-01-10
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1662
Valid CSS Valid XHTML 1.0 Strict