![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to icheck.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / etc|
Return to icheck.c CVS log | Up to [CSRG BSD Unix] / 42BSD / etc |
1.1 ! root 1: static char *sccsid = "@(#)icheck.c 2.4 (Berkeley) 11/18/82"; ! 2: ! 3: /* ! 4: * icheck ! 5: */ ! 6: #define NB 500 ! 7: #define MAXFN 500 ! 8: #define MAXNINDIR (MAXBSIZE / sizeof (daddr_t)) ! 9: ! 10: #ifndef STANDALONE ! 11: #include <stdio.h> ! 12: #endif ! 13: #ifndef SIMFS ! 14: #include <sys/param.h> ! 15: #include <sys/inode.h> ! 16: #include <sys/fs.h> ! 17: #else ! 18: #include "../h/param.h" ! 19: #include "../h/inode.h" ! 20: #include "../h/fs.h" ! 21: #endif ! 22: ! 23: union { ! 24: struct fs sb; ! 25: char pad[MAXBSIZE]; ! 26: } sbun; ! 27: #define sblock sbun.sb ! 28: ! 29: union { ! 30: struct cg cg; ! 31: char pad[MAXBSIZE]; ! 32: } cgun; ! 33: #define cgrp cgun.cg ! 34: ! 35: struct dinode itab[MAXIPG]; ! 36: daddr_t blist[NB]; ! 37: daddr_t fsblist[NB]; ! 38: char *bmap; ! 39: ! 40: int mflg; ! 41: int sflg; ! 42: int dflg; ! 43: int fi; ! 44: ino_t ino; ! 45: int cginit; ! 46: ! 47: ino_t nrfile; ! 48: ino_t ndfile; ! 49: ino_t nbfile; ! 50: ino_t ncfile; ! 51: ino_t nlfile; ! 52: ! 53: daddr_t nblock; ! 54: daddr_t nfrag; ! 55: daddr_t nindir; ! 56: daddr_t niindir; ! 57: ! 58: daddr_t nffree; ! 59: daddr_t nbfree; ! 60: ! 61: daddr_t ndup; ! 62: ! 63: int nerror; ! 64: ! 65: extern int inside[], around[]; ! 66: extern unsigned char *fragtbl[]; ! 67: ! 68: long atol(); ! 69: #ifndef STANDALONE ! 70: char *malloc(); ! 71: char *calloc(); ! 72: #endif ! 73: ! 74: main(argc, argv) ! 75: int argc; ! 76: char *argv[]; ! 77: { ! 78: register i; ! 79: long n; ! 80: ! 81: blist[0] = -1; ! 82: #ifndef STANDALONE ! 83: while (--argc) { ! 84: argv++; ! 85: if (**argv=='-') ! 86: switch ((*argv)[1]) { ! 87: case 'd': ! 88: dflg++; ! 89: continue; ! 90: ! 91: case 'm': ! 92: mflg++; ! 93: continue; ! 94: ! 95: case 's': ! 96: sflg++; ! 97: continue; ! 98: ! 99: case 'b': ! 100: for(i=0; i<NB; i++) { ! 101: n = atol(argv[1]); ! 102: if(n == 0) ! 103: break; ! 104: blist[i] = n; ! 105: argv++; ! 106: argc--; ! 107: } ! 108: blist[i] = -1; ! 109: continue; ! 110: ! 111: default: ! 112: printf("Bad flag\n"); ! 113: } ! 114: check(*argv); ! 115: } ! 116: #else ! 117: { ! 118: static char fname[128]; ! 119: ! 120: printf("File: "); ! 121: gets(fname); ! 122: check(fname); ! 123: } ! 124: #endif ! 125: return(nerror); ! 126: } ! 127: ! 128: check(file) ! 129: char *file; ! 130: { ! 131: register i, j, c; ! 132: daddr_t d, cgd, cbase, b; ! 133: long n; ! 134: char buf[BUFSIZ]; ! 135: ! 136: fi = open(file, sflg ? 2 : 0); ! 137: if (fi < 0) { ! 138: perror(file); ! 139: nerror |= 04; ! 140: return; ! 141: } ! 142: printf("%s:\n", file); ! 143: nrfile = 0; ! 144: ndfile = 0; ! 145: ncfile = 0; ! 146: nbfile = 0; ! 147: nlfile = 0; ! 148: ! 149: nblock = 0; ! 150: nfrag = 0; ! 151: nindir = 0; ! 152: niindir = 0; ! 153: ! 154: ndup = 0; ! 155: #ifndef STANDALONE ! 156: sync(); ! 157: #endif ! 158: getsb(&sblock, file); ! 159: if (nerror) ! 160: return; ! 161: for (n=0; blist[n] != -1; n++) ! 162: fsblist[n] = dbtofsb(&sblock, blist[n]); ! 163: ino = 0; ! 164: n = roundup(howmany(sblock.fs_size, NBBY), sizeof(short)); ! 165: #ifdef STANDALONE ! 166: bmap = NULL; ! 167: #else ! 168: bmap = malloc((unsigned)n); ! 169: #endif ! 170: if (bmap==NULL) { ! 171: printf("Not enough core; duplicates unchecked\n"); ! 172: dflg++; ! 173: if (sflg) { ! 174: printf("No Updates\n"); ! 175: sflg = 0; ! 176: } ! 177: } ! 178: ino = 0; ! 179: cginit = 1; ! 180: if (!dflg) { ! 181: for (i = 0; i < (unsigned)n; i++) ! 182: bmap[i] = 0; ! 183: for (c = 0; c < sblock.fs_ncg; c++) { ! 184: cgd = cgtod(&sblock, c); ! 185: if (c == 0) ! 186: d = cgbase(&sblock, c); ! 187: else ! 188: d = cgsblock(&sblock, c); ! 189: sprintf(buf, "spare super block %d", c); ! 190: for (; d < cgd; d += sblock.fs_frag) ! 191: chk(d, buf, sblock.fs_bsize); ! 192: d = cgimin(&sblock, c); ! 193: sprintf(buf, "cylinder group %d", c); ! 194: while (cgd < d) { ! 195: chk(cgd, buf, sblock.fs_bsize); ! 196: cgd += sblock.fs_frag; ! 197: } ! 198: d = cgdmin(&sblock, c); ! 199: i = INOPB(&sblock); ! 200: for (; cgd < d; cgd += sblock.fs_frag) { ! 201: sprintf(buf, "inodes %d-%d", ino, ino + i); ! 202: chk(cgd, buf, sblock.fs_bsize); ! 203: ino += i; ! 204: } ! 205: if (c == 0) { ! 206: d += howmany(sblock.fs_cssize, sblock.fs_fsize); ! 207: for (; cgd < d; cgd++) ! 208: chk(cgd, "csum", sblock.fs_fsize); ! 209: } ! 210: } ! 211: } ! 212: ino = 0; ! 213: cginit = 0; ! 214: for (c = 0; c < sblock.fs_ncg; c++) { ! 215: bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab, ! 216: sblock.fs_ipg * sizeof (struct dinode)); ! 217: for (j=0; j < sblock.fs_ipg; j++) { ! 218: pass1(&itab[j]); ! 219: ino++; ! 220: } ! 221: } ! 222: ino = 0; ! 223: #ifndef STANDALONE ! 224: sync(); ! 225: #endif ! 226: if (sflg) { ! 227: makecg(); ! 228: close(fi); ! 229: #ifndef STANDALONE ! 230: if (bmap) ! 231: free(bmap); ! 232: #endif ! 233: return; ! 234: } ! 235: nffree = 0; ! 236: nbfree = 0; ! 237: for (c = 0; c < sblock.fs_ncg; c++) { ! 238: cbase = cgbase(&sblock, c); ! 239: bread(fsbtodb(&sblock, cgtod(&sblock, c)), (char *)&cgrp, ! 240: sblock.fs_cgsize); ! 241: if (cgrp.cg_magic != CG_MAGIC) ! 242: printf("cg %d: bad magic number\n", c); ! 243: for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) { ! 244: if (isblock(&sblock, cgrp.cg_free, ! 245: b / sblock.fs_frag)) { ! 246: nbfree++; ! 247: chk(cbase+b, "free block", sblock.fs_bsize); ! 248: } else { ! 249: for (d = 0; d < sblock.fs_frag; d++) ! 250: if (isset(cgrp.cg_free, b+d)) { ! 251: chk(cbase+b+d, "free frag", sblock.fs_fsize); ! 252: nffree++; ! 253: } ! 254: } ! 255: } ! 256: } ! 257: close(fi); ! 258: #ifndef STANDALONE ! 259: if (bmap) ! 260: free(bmap); ! 261: #endif ! 262: ! 263: i = nrfile + ndfile + ncfile + nbfile + nlfile; ! 264: #ifndef STANDALONE ! 265: printf("files %6u (r=%u,d=%u,b=%u,c=%u,sl=%u)\n", ! 266: i, nrfile, ndfile, nbfile, ncfile, nlfile); ! 267: #else ! 268: printf("files %u (r=%u,d=%u,b=%u,c=%u,sl=%u)\n", ! 269: i, nrfile, ndfile, nbfile, ncfile, nlfile); ! 270: #endif ! 271: n = (nblock + nindir + niindir) * sblock.fs_frag + nfrag; ! 272: #ifdef STANDALONE ! 273: printf("used %ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n", ! 274: n, nindir, niindir, nblock, nfrag); ! 275: printf("free %ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree, ! 276: nbfree, nffree); ! 277: #else ! 278: printf("used %7ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n", ! 279: n, nindir, niindir, nblock, nfrag); ! 280: printf("free %7ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree, ! 281: nbfree, nffree); ! 282: #endif ! 283: if(!dflg) { ! 284: n = 0; ! 285: for (d = 0; d < sblock.fs_size; d++) ! 286: if(!duped(d, sblock.fs_fsize)) { ! 287: if(mflg) ! 288: printf("%ld missing\n", d); ! 289: n++; ! 290: } ! 291: printf("missing%5ld\n", n); ! 292: } ! 293: } ! 294: ! 295: pass1(ip) ! 296: register struct dinode *ip; ! 297: { ! 298: daddr_t ind1[MAXNINDIR]; ! 299: daddr_t ind2[MAXNINDIR]; ! 300: daddr_t db, ib; ! 301: register int i, j, k, siz; ! 302: int lbn; ! 303: char buf[BUFSIZ]; ! 304: ! 305: i = ip->di_mode & IFMT; ! 306: if(i == 0) ! 307: return; ! 308: switch (i) { ! 309: case IFCHR: ! 310: ncfile++; ! 311: return; ! 312: case IFBLK: ! 313: nbfile++; ! 314: return; ! 315: case IFDIR: ! 316: ndfile++; ! 317: break; ! 318: case IFREG: ! 319: nrfile++; ! 320: break; ! 321: case IFLNK: ! 322: nlfile++; ! 323: break; ! 324: default: ! 325: printf("bad mode %u\n", ino); ! 326: return; ! 327: } ! 328: for (i = 0; i < NDADDR; i++) { ! 329: db = ip->di_db[i]; ! 330: if (db == 0) ! 331: continue; ! 332: siz = dblksize(&sblock, ip, i); ! 333: sprintf(buf, "logical data block %d", i); ! 334: chk(db, buf, siz); ! 335: if (siz == sblock.fs_bsize) ! 336: nblock++; ! 337: else ! 338: nfrag += howmany(siz, sblock.fs_fsize); ! 339: } ! 340: for(i = 0; i < NIADDR; i++) { ! 341: ib = ip->di_ib[i]; ! 342: if (ib == 0) ! 343: continue; ! 344: if (chk(ib, "1st indirect", sblock.fs_bsize)) ! 345: continue; ! 346: bread(fsbtodb(&sblock, ib), (char *)ind1, sblock.fs_bsize); ! 347: nindir++; ! 348: for (j = 0; j < NINDIR(&sblock); j++) { ! 349: ib = ind1[j]; ! 350: if (ib == 0) ! 351: continue; ! 352: if (i == 0) { ! 353: lbn = NDADDR + j; ! 354: siz = dblksize(&sblock, ip, lbn); ! 355: sprintf(buf, "logical data block %d", lbn); ! 356: chk(ib, buf, siz); ! 357: if (siz == sblock.fs_bsize) ! 358: nblock++; ! 359: else ! 360: nfrag += howmany(siz, sblock.fs_fsize); ! 361: continue; ! 362: } ! 363: if (chk(ib, "2nd indirect", sblock.fs_bsize)) ! 364: continue; ! 365: bread(fsbtodb(&sblock, ib), (char *)ind2, ! 366: sblock.fs_bsize); ! 367: niindir++; ! 368: for (k = 0; k < NINDIR(&sblock); k++) { ! 369: ib = ind2[k]; ! 370: if (ib == 0) ! 371: continue; ! 372: lbn = NDADDR + NINDIR(&sblock) * (i + j) + k; ! 373: siz = dblksize(&sblock, ip, lbn); ! 374: sprintf(buf, "logical data block %d", lbn); ! 375: chk(ib, buf, siz); ! 376: if (siz == sblock.fs_bsize) ! 377: nblock++; ! 378: else ! 379: nfrag += howmany(siz, sblock.fs_fsize); ! 380: } ! 381: } ! 382: } ! 383: } ! 384: ! 385: chk(bno, s, size) ! 386: daddr_t bno; ! 387: char *s; ! 388: int size; ! 389: { ! 390: register n, cg; ! 391: int frags; ! 392: ! 393: cg = dtog(&sblock, bno); ! 394: if (cginit == 0 && bno >= sblock.fs_frag * sblock.fs_size) { ! 395: printf("%ld bad; inode=%u, class=%s\n", bno, ino, s); ! 396: return(1); ! 397: } ! 398: frags = numfrags(&sblock, size); ! 399: if (frags == sblock.fs_frag) { ! 400: if (duped(bno, size)) { ! 401: printf("%ld dup block; inode=%u, class=%s\n", ! 402: bno, ino, s); ! 403: ndup += sblock.fs_frag; ! 404: } ! 405: } else { ! 406: for (n = 0; n < frags; n++) { ! 407: if (duped(bno + n, sblock.fs_fsize)) { ! 408: printf("%ld dup frag; inode=%u, class=%s\n", ! 409: bno, ino, s); ! 410: ndup++; ! 411: } ! 412: } ! 413: } ! 414: for (n=0; blist[n] != -1; n++) ! 415: if (fsblist[n] >= bno && fsblist[n] < bno + frags) ! 416: printf("%ld arg; frag %d of %d, inode=%u, class=%s\n", ! 417: blist[n], fsblist[n] - bno, frags, ino, s); ! 418: return(0); ! 419: } ! 420: ! 421: duped(bno, size) ! 422: daddr_t bno; ! 423: int size; ! 424: { ! 425: if(dflg) ! 426: return(0); ! 427: if (size != sblock.fs_fsize && size != sblock.fs_bsize) ! 428: printf("bad size %d to duped\n", size); ! 429: if (size == sblock.fs_fsize) { ! 430: if (isset(bmap, bno)) ! 431: return(1); ! 432: setbit(bmap, bno); ! 433: return (0); ! 434: } ! 435: if (bno % sblock.fs_frag != 0) ! 436: printf("bad bno %d to duped\n", bno); ! 437: if (isblock(&sblock, bmap, bno/sblock.fs_frag)) ! 438: return (1); ! 439: setblock(&sblock, bmap, bno/sblock.fs_frag); ! 440: return(0); ! 441: } ! 442: ! 443: makecg() ! 444: { ! 445: int c, blk; ! 446: daddr_t dbase, d, dlower, dupper, dmax; ! 447: long i, j, s; ! 448: register struct csum *cs; ! 449: register struct dinode *dp; ! 450: ! 451: sblock.fs_cstotal.cs_nbfree = 0; ! 452: sblock.fs_cstotal.cs_nffree = 0; ! 453: sblock.fs_cstotal.cs_nifree = 0; ! 454: sblock.fs_cstotal.cs_ndir = 0; ! 455: for (c = 0; c < sblock.fs_ncg; c++) { ! 456: dbase = cgbase(&sblock, c); ! 457: dmax = dbase + sblock.fs_fpg; ! 458: if (dmax > sblock.fs_size) { ! 459: for ( ; dmax >= sblock.fs_size; dmax--) ! 460: clrbit(cgrp.cg_free, dmax - dbase); ! 461: dmax++; ! 462: } ! 463: dlower = cgsblock(&sblock, c) - dbase; ! 464: dupper = cgdmin(&sblock, c) - dbase; ! 465: cs = &sblock.fs_cs(&sblock, c); ! 466: cgrp.cg_time = time(0); ! 467: cgrp.cg_magic = CG_MAGIC; ! 468: cgrp.cg_cgx = c; ! 469: if (c == sblock.fs_ncg - 1) ! 470: cgrp.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg; ! 471: else ! 472: cgrp.cg_ncyl = sblock.fs_cpg; ! 473: cgrp.cg_niblk = sblock.fs_ipg; ! 474: cgrp.cg_ndblk = dmax - dbase; ! 475: cgrp.cg_cs.cs_ndir = 0; ! 476: cgrp.cg_cs.cs_nffree = 0; ! 477: cgrp.cg_cs.cs_nbfree = 0; ! 478: cgrp.cg_cs.cs_nifree = 0; ! 479: cgrp.cg_rotor = 0; ! 480: cgrp.cg_frotor = 0; ! 481: cgrp.cg_irotor = 0; ! 482: for (i = 0; i < sblock.fs_frag; i++) ! 483: cgrp.cg_frsum[i] = 0; ! 484: bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab, ! 485: sblock.fs_ipg * sizeof(struct dinode)); ! 486: for (i = 0; i < sblock.fs_ipg; i++) { ! 487: cgrp.cg_cs.cs_nifree++; ! 488: clrbit(cgrp.cg_iused, i); ! 489: dp = &itab[i]; ! 490: if ((dp->di_mode & IFMT) != 0) { ! 491: if ((dp->di_mode & IFMT) == IFDIR) ! 492: cgrp.cg_cs.cs_ndir++; ! 493: cgrp.cg_cs.cs_nifree--; ! 494: setbit(cgrp.cg_iused, i); ! 495: continue; ! 496: } ! 497: } ! 498: while (i < MAXIPG) { ! 499: clrbit(cgrp.cg_iused, i); ! 500: i++; ! 501: } ! 502: if (c == 0) ! 503: for (i = 0; i < ROOTINO; i++) { ! 504: setbit(cgrp.cg_iused, i); ! 505: cgrp.cg_cs.cs_nifree--; ! 506: } ! 507: for (s = 0; s < MAXCPG; s++) { ! 508: cgrp.cg_btot[s] = 0; ! 509: for (i = 0; i < NRPOS; i++) ! 510: cgrp.cg_b[s][i] = 0; ! 511: } ! 512: if (c == 0) { ! 513: dupper += howmany(sblock.fs_cssize, sblock.fs_fsize); ! 514: } ! 515: for (d = dlower; d < dupper; d++) ! 516: clrbit(cgrp.cg_free, d); ! 517: for (d = 0; (d + sblock.fs_frag) <= dmax - dbase; ! 518: d += sblock.fs_frag) { ! 519: j = 0; ! 520: for (i = 0; i < sblock.fs_frag; i++) { ! 521: if (!isset(bmap, dbase + d + i)) { ! 522: setbit(cgrp.cg_free, d + i); ! 523: j++; ! 524: } else ! 525: clrbit(cgrp.cg_free, d+i); ! 526: } ! 527: if (j == sblock.fs_frag) { ! 528: cgrp.cg_cs.cs_nbfree++; ! 529: cgrp.cg_btot[cbtocylno(&sblock, d)]++; ! 530: cgrp.cg_b[cbtocylno(&sblock, d)] ! 531: [cbtorpos(&sblock, d)]++; ! 532: } else if (j > 0) { ! 533: cgrp.cg_cs.cs_nffree += j; ! 534: blk = blkmap(&sblock, cgrp.cg_free, d); ! 535: fragacct(&sblock, blk, cgrp.cg_frsum, 1); ! 536: } ! 537: } ! 538: for (j = d; d < dmax - dbase; d++) { ! 539: if (!isset(bmap, dbase + d)) { ! 540: setbit(cgrp.cg_free, d); ! 541: cgrp.cg_cs.cs_nffree++; ! 542: } else ! 543: clrbit(cgrp.cg_free, d); ! 544: } ! 545: for (; d % sblock.fs_frag != 0; d++) ! 546: clrbit(cgrp.cg_free, d); ! 547: if (j != d) { ! 548: blk = blkmap(&sblock, cgrp.cg_free, j); ! 549: fragacct(&sblock, blk, cgrp.cg_frsum, 1); ! 550: } ! 551: for (d /= sblock.fs_frag; d < MAXBPG(&sblock); d ++) ! 552: clrblock(&sblock, cgrp.cg_free, d); ! 553: sblock.fs_cstotal.cs_nffree += cgrp.cg_cs.cs_nffree; ! 554: sblock.fs_cstotal.cs_nbfree += cgrp.cg_cs.cs_nbfree; ! 555: sblock.fs_cstotal.cs_nifree += cgrp.cg_cs.cs_nifree; ! 556: sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir; ! 557: *cs = cgrp.cg_cs; ! 558: bwrite(fsbtodb(&sblock, cgtod(&sblock, c)), &cgrp, ! 559: sblock.fs_cgsize); ! 560: } ! 561: for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) { ! 562: bwrite(fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag), ! 563: (char *)sblock.fs_csp[j], ! 564: sblock.fs_cssize - i < sblock.fs_bsize ? ! 565: sblock.fs_cssize - i : sblock.fs_bsize); ! 566: } ! 567: sblock.fs_ronly = 0; ! 568: sblock.fs_fmod = 0; ! 569: bwrite(SBLOCK, (char *)&sblock, SBSIZE); ! 570: } ! 571: ! 572: /* ! 573: * update the frsum fields to reflect addition or deletion ! 574: * of some frags ! 575: */ ! 576: fragacct(fs, fragmap, fraglist, cnt) ! 577: struct fs *fs; ! 578: int fragmap; ! 579: long fraglist[]; ! 580: int cnt; ! 581: { ! 582: int inblk; ! 583: register int field, subfield; ! 584: register int siz, pos; ! 585: ! 586: inblk = (int)(fragtbl[fs->fs_frag][fragmap] << 1); ! 587: fragmap <<= 1; ! 588: for (siz = 1; siz < fs->fs_frag; siz++) { ! 589: if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0) ! 590: continue; ! 591: field = around[siz]; ! 592: subfield = inside[siz]; ! 593: for (pos = siz; pos <= fs->fs_frag; pos++) { ! 594: if ((fragmap & field) == subfield) { ! 595: fraglist[siz] += cnt; ! 596: pos += siz; ! 597: field <<= siz; ! 598: subfield <<= siz; ! 599: } ! 600: field <<= 1; ! 601: subfield <<= 1; ! 602: } ! 603: } ! 604: } ! 605: ! 606: getsb(fs, file) ! 607: register struct fs *fs; ! 608: char *file; ! 609: { ! 610: int i, j, size; ! 611: ! 612: if (bread(SBLOCK, fs, SBSIZE)) { ! 613: printf("bad super block"); ! 614: perror(file); ! 615: nerror |= 04; ! 616: return; ! 617: } ! 618: if (fs->fs_magic != FS_MAGIC) { ! 619: printf("%s: bad magic number\n", file); ! 620: nerror |= 04; ! 621: return; ! 622: } ! 623: for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) { ! 624: size = sblock.fs_cssize - i < sblock.fs_bsize ? ! 625: sblock.fs_cssize - i : sblock.fs_bsize; ! 626: sblock.fs_csp[j] = (struct csum *)calloc(1, size); ! 627: bread(fsbtodb(fs, fs->fs_csaddr + (j * fs->fs_frag)), ! 628: (char *)fs->fs_csp[j], size); ! 629: } ! 630: } ! 631: ! 632: bwrite(blk, buf, size) ! 633: char *buf; ! 634: daddr_t blk; ! 635: register size; ! 636: { ! 637: if (lseek(fi, blk * DEV_BSIZE, 0) < 0) { ! 638: perror("FS SEEK"); ! 639: return(1); ! 640: } ! 641: if (write(fi, buf, size) != size) { ! 642: perror("FS WRITE"); ! 643: return(1); ! 644: } ! 645: return (0); ! 646: } ! 647: ! 648: bread(bno, buf, cnt) ! 649: daddr_t bno; ! 650: char *buf; ! 651: { ! 652: register i; ! 653: ! 654: lseek(fi, bno * DEV_BSIZE, 0); ! 655: if ((i = read(fi, buf, cnt)) != cnt) { ! 656: if (sflg) { ! 657: printf("No Update\n"); ! 658: sflg = 0; ! 659: } ! 660: for(i=0; i<sblock.fs_bsize; i++) ! 661: buf[i] = 0; ! 662: return (1); ! 663: } ! 664: return (0); ! 665: } ! 666: ! 667: /* ! 668: * check if a block is available ! 669: */ ! 670: isblock(fs, cp, h) ! 671: struct fs *fs; ! 672: unsigned char *cp; ! 673: int h; ! 674: { ! 675: unsigned char mask; ! 676: ! 677: switch (fs->fs_frag) { ! 678: case 8: ! 679: return (cp[h] == 0xff); ! 680: case 4: ! 681: mask = 0x0f << ((h & 0x1) << 2); ! 682: return ((cp[h >> 1] & mask) == mask); ! 683: case 2: ! 684: mask = 0x03 << ((h & 0x3) << 1); ! 685: return ((cp[h >> 2] & mask) == mask); ! 686: case 1: ! 687: mask = 0x01 << (h & 0x7); ! 688: return ((cp[h >> 3] & mask) == mask); ! 689: default: ! 690: #ifdef STANDALONE ! 691: printf("isblock bad fs_frag %d\n", fs->fs_frag); ! 692: #else ! 693: fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag); ! 694: #endif ! 695: return; ! 696: } ! 697: } ! 698: ! 699: /* ! 700: * take a block out of the map ! 701: */ ! 702: clrblock(fs, cp, h) ! 703: struct fs *fs; ! 704: unsigned char *cp; ! 705: int h; ! 706: { ! 707: switch ((fs)->fs_frag) { ! 708: case 8: ! 709: cp[h] = 0; ! 710: return; ! 711: case 4: ! 712: cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2)); ! 713: return; ! 714: case 2: ! 715: cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1)); ! 716: return; ! 717: case 1: ! 718: cp[h >> 3] &= ~(0x01 << (h & 0x7)); ! 719: return; ! 720: default: ! 721: #ifdef STANDALONE ! 722: printf("clrblock bad fs_frag %d\n", fs->fs_frag); ! 723: #else ! 724: fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag); ! 725: #endif ! 726: return; ! 727: } ! 728: } ! 729: ! 730: /* ! 731: * put a block into the map ! 732: */ ! 733: setblock(fs, cp, h) ! 734: struct fs *fs; ! 735: unsigned char *cp; ! 736: int h; ! 737: { ! 738: switch (fs->fs_frag) { ! 739: case 8: ! 740: cp[h] = 0xff; ! 741: return; ! 742: case 4: ! 743: cp[h >> 1] |= (0x0f << ((h & 0x1) << 2)); ! 744: return; ! 745: case 2: ! 746: cp[h >> 2] |= (0x03 << ((h & 0x3) << 1)); ! 747: return; ! 748: case 1: ! 749: cp[h >> 3] |= (0x01 << (h & 0x7)); ! 750: return; ! 751: default: ! 752: #ifdef STANDALONE ! 753: printf("setblock bad fs_frag %d\n", fs->fs_frag); ! 754: #else ! 755: fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag); ! 756: #endif ! 757: return; ! 758: } ! 759: } ! 760: ! 761: /* tables.c 4.1 82/03/25 */ ! 762: ! 763: /* merged into kernel: tables.c 2.1 3/25/82 */ ! 764: ! 765: /* last monet version: partab.c 4.2 81/03/08 */ ! 766: ! 767: /* ! 768: * bit patterns for identifying fragments in the block map ! 769: * used as ((map & around) == inside) ! 770: */ ! 771: int around[9] = { ! 772: 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff ! 773: }; ! 774: int inside[9] = { ! 775: 0x0, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe ! 776: }; ! 777: ! 778: /* ! 779: * given a block map bit pattern, the frag tables tell whether a ! 780: * particular size fragment is available. ! 781: * ! 782: * used as: ! 783: * if ((1 << (size - 1)) & fragtbl[fs->fs_frag][map] { ! 784: * at least one fragment of the indicated size is available ! 785: * } ! 786: * ! 787: * These tables are used by the scanc instruction on the VAX to ! 788: * quickly find an appropriate fragment. ! 789: */ ! 790: ! 791: unsigned char fragtbl124[256] = { ! 792: 0x00, 0x16, 0x16, 0x2a, 0x16, 0x16, 0x26, 0x4e, ! 793: 0x16, 0x16, 0x16, 0x3e, 0x2a, 0x3e, 0x4e, 0x8a, ! 794: 0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e, ! 795: 0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e, ! 796: 0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e, ! 797: 0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e, ! 798: 0x2a, 0x3e, 0x3e, 0x2a, 0x3e, 0x3e, 0x2e, 0x6e, ! 799: 0x3e, 0x3e, 0x3e, 0x3e, 0x2a, 0x3e, 0x6e, 0xaa, ! 800: 0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e, ! 801: 0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e, ! 802: 0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e, ! 803: 0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e, ! 804: 0x26, 0x36, 0x36, 0x2e, 0x36, 0x36, 0x26, 0x6e, ! 805: 0x36, 0x36, 0x36, 0x3e, 0x2e, 0x3e, 0x6e, 0xae, ! 806: 0x4e, 0x5e, 0x5e, 0x6e, 0x5e, 0x5e, 0x6e, 0x4e, ! 807: 0x5e, 0x5e, 0x5e, 0x7e, 0x6e, 0x7e, 0x4e, 0xce, ! 808: 0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e, ! 809: 0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e, ! 810: 0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e, ! 811: 0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e, ! 812: 0x16, 0x16, 0x16, 0x3e, 0x16, 0x16, 0x36, 0x5e, ! 813: 0x16, 0x16, 0x16, 0x3e, 0x3e, 0x3e, 0x5e, 0x9e, ! 814: 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x7e, ! 815: 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x7e, 0xbe, ! 816: 0x2a, 0x3e, 0x3e, 0x2a, 0x3e, 0x3e, 0x2e, 0x6e, ! 817: 0x3e, 0x3e, 0x3e, 0x3e, 0x2a, 0x3e, 0x6e, 0xaa, ! 818: 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x7e, ! 819: 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x7e, 0xbe, ! 820: 0x4e, 0x5e, 0x5e, 0x6e, 0x5e, 0x5e, 0x6e, 0x4e, ! 821: 0x5e, 0x5e, 0x5e, 0x7e, 0x6e, 0x7e, 0x4e, 0xce, ! 822: 0x8a, 0x9e, 0x9e, 0xaa, 0x9e, 0x9e, 0xae, 0xce, ! 823: 0x9e, 0x9e, 0x9e, 0xbe, 0xaa, 0xbe, 0xce, 0x8a, ! 824: }; ! 825: ! 826: unsigned char fragtbl8[256] = { ! 827: 0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x04, ! 828: 0x01, 0x01, 0x01, 0x03, 0x02, 0x03, 0x04, 0x08, ! 829: 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, ! 830: 0x02, 0x03, 0x03, 0x02, 0x04, 0x05, 0x08, 0x10, ! 831: 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, ! 832: 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, ! 833: 0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, ! 834: 0x04, 0x05, 0x05, 0x06, 0x08, 0x09, 0x10, 0x20, ! 835: 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, ! 836: 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, ! 837: 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, ! 838: 0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11, ! 839: 0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, ! 840: 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0a, ! 841: 0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04, ! 842: 0x08, 0x09, 0x09, 0x0a, 0x10, 0x11, 0x20, 0x40, ! 843: 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, ! 844: 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, ! 845: 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, ! 846: 0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11, ! 847: 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, ! 848: 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, ! 849: 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, ! 850: 0x05, 0x05, 0x05, 0x07, 0x09, 0x09, 0x11, 0x21, ! 851: 0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, ! 852: 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0a, ! 853: 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, ! 854: 0x02, 0x03, 0x03, 0x02, 0x06, 0x07, 0x0a, 0x12, ! 855: 0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04, ! 856: 0x05, 0x05, 0x05, 0x07, 0x06, 0x07, 0x04, 0x0c, ! 857: 0x08, 0x09, 0x09, 0x0a, 0x09, 0x09, 0x0a, 0x0c, ! 858: 0x10, 0x11, 0x11, 0x12, 0x20, 0x21, 0x40, 0x80, ! 859: }; ! 860: ! 861: /* ! 862: * the actual fragtbl array ! 863: */ ! 864: unsigned char *fragtbl[MAXFRAG + 1] = { ! 865: 0, fragtbl124, fragtbl124, 0, fragtbl124, 0, 0, 0, fragtbl8, ! 866: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.