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