![[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 [Research Unix] / researchv10no / cmd|
Return to icheck.c CVS log | Up to [Research Unix] / researchv10no / cmd |
1.1 root 1: #define NI 4
2: #define NB 500
3: #define BITS 8
4: #define MAXFN 500
5:
6: #include <stdio.h>
7: #include <sys/param.h>
8: #include <sys/inode.h>
9: #include <sys/ino.h>
10: #include <sys/fblk.h>
11: #include <sys/filsys.h>
12: #include <sys/stat.h>
13:
14: #define BITFSBIT 64 /* should be in param.h */
15: #define BIGINOPB INOPB(BITFSBIT)
16: #define BIGBSIZE BSIZE(BITFSBIT)
17: #define BIGNINDIR NINDIR(BITFSBIT)
18:
19: struct filsys sblock;
20: struct stat status;
21: #define dev status.st_rdev
22: struct dinode itab[BIGINOPB*NI];
23: daddr_t iaddr[NADDR];
24: daddr_t blist[NB];
25: char *bmap;
26:
27: int sflg;
28: int mflg;
29: int dflg;
30: int eflg;
31: int fi;
32: long ino;
33: int bigflag;
34:
35: ino_t nrfile;
36: ino_t ndfile;
37: ino_t nbfile;
38: ino_t ncfile;
39: ino_t nlfile;
40:
41: daddr_t ndirect;
42: daddr_t nindir;
43: daddr_t niindir;
44: daddr_t niiindir;
45: daddr_t nfree;
46: daddr_t ndup;
47: daddr_t maxblk;
48:
49: int nerror;
50:
51: long atol();
52: daddr_t alloc();
53: char *malloc();
54: char *memset();
55: time_t time();
56: long lseek();
57: void sync();
58:
59: main(argc, argv)
60: char *argv[];
61: {
62: register i;
63: long n;
64:
65: setbuf(stdout, (char *)NULL);
66: blist[0] = -1;
67: while (--argc) {
68: argv++;
69: if (**argv=='-')
70: switch ((*argv)[1]) {
71: case 'd':
72: dflg++;
73: continue;
74:
75: case 'e':
76: eflg++;
77: continue;
78:
79: case 'm':
80: mflg++;
81: continue;
82:
83: case 's':
84: sflg++;
85: continue;
86:
87: case 'b':
88: for(i=0; i<NB; i++) {
89: n = atol(argv[1]);
90: if(n == 0)
91: break;
92: blist[i] = n;
93: argv++;
94: argc--;
95: }
96: blist[i] = -1;
97: continue;
98:
99: case 'B':
100: bigflag = BITFSBIT;
101: continue;
102:
103: default:
104: fprintf(stderr, "Bad flag\n");
105: }
106: check(*argv);
107: }
108: return(nerror);
109: }
110:
111: check(file)
112: char *file;
113: {
114: register i, j;
115: long mino;
116: daddr_t d;
117: long n;
118:
119: fi = open(file, sflg?2:0);
120: if (fi < 0) {
121: fprintf(stderr, "cannot open %s\n", file);
122: nerror |= 04;
123: return;
124: }
125: if (fstat(fi, &status) < 0) {
126: fprintf(stderr, "cannot fstat %s\n", file);
127: nerror |= 04;
128: close(fi);
129: return;
130: }
131: if ((status.st_mode & S_IFMT) == S_IFREG)
132: dev = makedev(0, bigflag);
133: printf("%s:\n", file);
134: nrfile = 0;
135: ndfile = 0;
136: ncfile = 0;
137: nbfile = 0;
138: nlfile = 0;
139:
140: ndirect = 0;
141: nindir = 0;
142: niindir = 0;
143: niiindir = 0;
144:
145: ndup = 0;
146: sync();
147: bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
148: mino = ((int)sblock.s_isize-2) * INOPB(dev);
149: ino = 0;
150: maxblk = sblock.s_fsize;
151: /*
152: * fudge for new bitmapped filesystems
153: * this should be isolated somewhere
154: */
155: if (BITFS(dev) && sblock.U.N.S_flag) {
156: n = (sblock.s_fsize+sblock.U.N.S_bsize-1)/sblock.U.N.S_bsize;
157: maxblk -= n;
158: }
159: n = (maxblk - (int)sblock.s_isize + BITS-1) / BITS;
160: if (n != (unsigned)n) {
161: fprintf(stderr, "Check fsize and isize: %ld, %u\n",
162: maxblk, (int)sblock.s_isize);
163: }
164: bmap = malloc((unsigned)n);
165: if (bmap==NULL) {
166: fprintf(stderr, "Not enough core; duplicates unchecked\n");
167: dflg++;
168: sflg = 0;
169: }
170: if(!dflg)
171: for(i=0; i<(unsigned)n; i++)
172: bmap[i] = 0;
173: for(i=2;; i+=NI) {
174: if(ino >= mino)
175: break;
176: bread((daddr_t)i, (char *)itab, BSIZE(dev)*NI);
177: for(j=0; j<INOPB(dev)*NI; j++) {
178: if(ino >= mino)
179: break;
180: ino++;
181: pass1(&itab[j]);
182: }
183: }
184: ino = 0;
185: sync();
186: bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
187: if (sflg) {
188: makefree();
189: close(fi);
190: if (bmap)
191: free(bmap);
192: return;
193: }
194: nfree = 0;
195: while(n = alloc()) {
196: if (chk(0, n, "free"))
197: break;
198: nfree++;
199: }
200: close(fi);
201:
202: i = nrfile + ndfile + ncfile + nbfile + nlfile;
203: printf("files %6u (r=%u,d=%u,b=%u,c=%u,l=%u)\n",
204: i, nrfile, ndfile, nbfile, ncfile, nlfile);
205: n = ndirect + nindir + niindir + niiindir;
206: printf("used %7ld (i=%ld,ii=%ld,iii=%ld,d=%ld)\n",
207: n, nindir, niindir, niiindir, ndirect);
208: printf("free %7ld\n", nfree);
209: if(!dflg) {
210: n = 0;
211: for(d=(int)sblock.s_isize; d<maxblk; d++)
212: if(!duped(d)) {
213: if(mflg)
214: printf("%ld missing\n", d);
215: n++;
216: }
217: printf("missing%5ld\n", n);
218: }
219: if (bmap)
220: free(bmap);
221: }
222:
223: pass1(ip)
224: register struct dinode *ip;
225: {
226: daddr_t ind1[BIGNINDIR];
227: daddr_t ind2[BIGNINDIR];
228: daddr_t ind3[BIGNINDIR];
229: register i, j;
230: int k, l;
231: int squawked = 0;
232:
233: i = ip->di_mode & IFMT;
234: if(i == 0) {
235: sblock.s_tinode++;
236: return;
237: }
238: if(i == IFCHR) {
239: ncfile++;
240: return;
241: }
242: if(i == IFBLK) {
243: nbfile++;
244: return;
245: }
246: if(i == IFDIR)
247: ndfile++;
248: else if(i == IFREG)
249: nrfile++;
250: else if(i == IFLNK)
251: nlfile++;
252: else {
253: printf("bad mode %u\n", ino);
254: return;
255: }
256: l3tol(iaddr, ip->di_addr, NADDR);
257: for(i=0; i<NADDR; i++) {
258: if(iaddr[i] == 0)
259: continue;
260: if(i < NADDR-3) {
261: ndirect++;
262: chk(squawked++, iaddr[i], "data (small)");
263: continue;
264: }
265: nindir++;
266: if (chk(squawked++, iaddr[i], "1st indirect"))
267: continue;
268: bread(iaddr[i], (char *)ind1, BSIZE(dev));
269: for(j=0; j<NINDIR(dev); j++) {
270: if(ind1[j] == 0)
271: continue;
272: if(i == NADDR-3) {
273: ndirect++;
274: chk(squawked++, ind1[j], "data (large)");
275: continue;
276: }
277: niindir++;
278: if(chk(squawked++, ind1[j], "2nd indirect"))
279: continue;
280: bread(ind1[j], (char *)ind2, BSIZE(dev));
281: for(k=0; k<NINDIR(dev); k++) {
282: if(ind2[k] == 0)
283: continue;
284: if(i == NADDR-2) {
285: ndirect++;
286: chk(squawked++, ind2[k], "data (huge)");
287: continue;
288: }
289: niiindir++;
290: if(chk(squawked++, ind2[k], "3rd indirect"))
291: continue;
292: bread(ind2[k], (char *)ind3, BSIZE(dev));
293: for(l=0; l<NINDIR(dev); l++)
294: if(ind3[l]) {
295: ndirect++;
296: chk(squawked++, ind3[l], "data (garg)");
297: }
298: }
299: }
300: }
301: }
302:
303: chk(loud, bno, s)
304: daddr_t bno;
305: char *s;
306: {
307: register n;
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: if (bno<(int)sblock.s_isize || bno>=maxblk) {
313: if (loud == 0 || eflg == 0)
314: printf("%ld bad; inode=%u, class=%s\n", bno, ino, s);
315: return(1);
316: }
317: if(duped(bno)) {
318: if (loud == 0)
319: printf("%ld dup; inode=%u, class=%s\n", bno, ino, s);
320: ndup++;
321: }
322: return(0);
323: }
324:
325: duped(bno)
326: daddr_t bno;
327: {
328: daddr_t d;
329: register m, n;
330:
331: if(dflg)
332: return(0);
333: d = bno - (int)sblock.s_isize;
334: m = 1 << (d%BITS);
335: n = (d/BITS);
336: if(bmap[n] & m)
337: return(1);
338: bmap[n] |= m;
339: return(0);
340: }
341:
342: daddr_t bitfsalloc(), bigfsalloc();
343:
344: daddr_t
345: alloc()
346: {
347: daddr_t bno;
348: union {
349: char data[BIGBSIZE];
350: struct fblk fb;
351: } buf;
352: register int i;
353:
354: sblock.s_tfree--;
355: if (BITFS(dev)) {
356: if (sblock.U.N.S_flag)
357: return (bigfsalloc());
358: return (bitfsalloc());
359: }
360: if (sblock.s_nfree<=0)
361: return(0);
362: if (sblock.s_nfree>NICFREE) {
363: fprintf(stderr, "Bad free list, s.b. count = %d\n", sblock.s_nfree);
364: return(0);
365: }
366: bno = sblock.s_free[--sblock.s_nfree];
367: sblock.s_free[sblock.s_nfree] = (daddr_t)0;
368: if(bno == 0)
369: return(bno);
370: if(sblock.s_nfree <= 0) {
371: bread(bno, buf.data, BSIZE(dev));
372: sblock.s_nfree = buf.fb.df_nfree;
373: if (sblock.s_nfree<0 || sblock.s_nfree>NICFREE) {
374: fprintf(stderr, "Bad free list, entry count of block %ld = %d\n",
375: bno, sblock.s_nfree);
376: sblock.s_nfree = 0;
377: return(0);
378: }
379: for(i=0; i<NICFREE; i++)
380: sblock.s_free[i] = buf.fb.df_free[i];
381: }
382: return(bno);
383: }
384:
385: daddr_t
386: bitfsalloc()
387: {
388: daddr_t bno;
389: register long *p;
390: register int i, j;
391:
392: p = sblock.s_bfree;
393: for(i = 0; i < BITMAP && *p == 0; i++, p++)
394: ;
395: if(i >= BITMAP)
396: return (0);
397: bno = sblock.s_isize + BITCELL * i;
398: for(j = 0; j < BITCELL; j++)
399: if(*p & (1 << j))
400: break;
401: if(j >= BITCELL)
402: return (0);
403: bno += j;
404: if(bno >= sblock.s_fsize)
405: return (0);
406: *p &= ~(1 << j);
407: return (bno);
408: }
409:
410: daddr_t
411: bigfsalloc()
412: {
413: register long *p;
414: register int i;
415: int nblk;
416: static long *flist, *fend;
417: daddr_t bno;
418:
419: if (flist == NULL) {
420: if (sblock.U.N.S_bsize == 0) /* unlikely */
421: sblock.U.N.S_bsize = BIGBSIZE*NBBY;
422: nblk = (sblock.s_fsize+sblock.U.N.S_bsize-1)/sblock.U.N.S_bsize;
423: if ((flist = (long *)malloc(nblk*BIGBSIZE)) == NULL) {
424: fprintf(stderr, "no mem for free bitmap\n");
425: return (0);
426: }
427: bno = sblock.s_fsize - nblk;
428: fend = flist;
429: for (i = 0; i < nblk; i++, bno++, fend += BIGBSIZE/sizeof(long))
430: bread(bno, (char *)fend, BIGBSIZE);
431: }
432: for (p = flist; p < fend && *p == 0; p++)
433: ;
434: if (p >= fend)
435: return (0);
436: for (i = 0; i < BITCELL; i++)
437: if (*p & (1<<i))
438: break;
439: if (i >= BITCELL)
440: return (0); /* shouldn't happen */
441: bno = i + (p - flist)*BITCELL;
442: if (bno >= maxblk)
443: return (0);
444: *p &=~ (1<<i);
445: return (bno);
446: }
447:
448:
449: bread(bno, buf, cnt)
450: daddr_t bno;
451: char *buf;
452: {
453: register i;
454:
455: lseek(fi, bno*BSIZE(dev), 0);
456: if (read(fi, buf, cnt) != cnt) {
457: fprintf(stderr, "read error %ld\n", bno);
458: if (sflg) {
459: fprintf(stderr, "No update\n");
460: sflg = 0;
461: }
462: for(i=0; i<BSIZE(dev); i++)
463: buf[i] = 0;
464: }
465: }
466:
467: bwrite(bno, buf)
468: daddr_t bno;
469: char *buf;
470: {
471:
472: lseek(fi, bno*BSIZE(dev), 0);
473: if (write(fi, buf, BSIZE(dev)) != BSIZE(dev))
474: fprintf(stderr, "write error %ld\n", bno);
475: }
476:
477: makefree()
478: {
479:
480: if (!BITFS(dev))
481: makeoldfree();
482: else if (sblock.U.N.S_flag == 0)
483: makesbitfree();
484: else
485: makebbitfree();
486: }
487:
488: makeoldfree()
489: {
490: char flg[MAXFN];
491: int adr[MAXFN];
492: register i, j;
493: daddr_t f, d;
494: int m, n;
495:
496: n = sblock.s_n;
497: if(n <= 0 || n > MAXFN)
498: n = MAXFN;
499: sblock.s_n = n;
500: m = sblock.s_m;
501: if(m <= 0 || m > sblock.s_n)
502: m = 3;
503: sblock.s_m = m;
504:
505: for(i=0; i<n; i++)
506: flg[i] = 0;
507: i = 0;
508: for(j=0; j<n; j++) {
509: while(flg[i])
510: i = (i+1)%n;
511: adr[j] = i+1;
512: flg[i]++;
513: i = (i+m)%n;
514: }
515:
516: sblock.s_nfree = 0;
517: sblock.s_ninode = 0;
518: sblock.s_flock = 0;
519: sblock.s_ilock = 0;
520: sblock.s_fmod = 0;
521: sblock.s_ronly = 0;
522: time(&sblock.s_time);
523:
524: bfree((daddr_t)0);
525: sblock.s_tfree = 0;
526: sblock.s_tinode = 0;
527: d = maxblk-1;
528: while(d%sblock.s_n)
529: d++;
530: for(; d > 0; d -= sblock.s_n)
531: for(i=0; i<sblock.s_n; i++) {
532: f = d - adr[i];
533: if(f < maxblk && f >= (int)sblock.s_isize)
534: if(!duped(f))
535: bfree(f);
536: }
537: bwrite((daddr_t)1, (char *)&sblock);
538: sync();
539: }
540:
541: bfree(bno)
542: daddr_t bno;
543: {
544: union {
545: char data[BIGBSIZE];
546: struct fblk fb;
547: } buf;
548: int i;
549:
550: sblock.s_tfree++;
551: if(sblock.s_nfree >= NICFREE) {
552: for(i=0; i<BSIZE(dev); i++)
553: buf.data[i] = 0;
554: buf.fb.df_nfree = sblock.s_nfree;
555: for(i=0; i<NICFREE; i++)
556: buf.fb.df_free[i] = sblock.s_free[i];
557: bwrite(bno, buf.data);
558: sblock.s_nfree = 0;
559: }
560: sblock.s_free[sblock.s_nfree] = bno;
561: sblock.s_nfree++;
562: }
563:
564: makesbitfree()
565: {
566: register daddr_t bno;
567:
568: memset((char *)sblock.s_bfree, 0, BITMAP);
569: sblock.s_tfree = 0;
570: for (bno = sblock.s_isize; bno < maxblk; bno++)
571: if (!duped(bno)) {
572: BITFREE(sblock.s_bfree, bno-sblock.s_isize);
573: sblock.s_tfree++;
574: }
575: sblock.s_valid = 1;
576: bwrite((daddr_t)1, (char *)&sblock);
577: }
578:
579: makebbitfree()
580: {
581: register daddr_t bno;
582: register long *flist;
583: register int nblk, i;
584:
585: nblk = (sblock.s_fsize+sblock.U.N.S_bsize-1)/sblock.U.N.S_bsize;
586: if ((flist = (long *)malloc(nblk*BIGBSIZE)) == NULL) {
587: fprintf(stderr, "no mem for free bitmap\n");
588: exit(1); /* eh? */
589: }
590: memset((char *)flist, 0, nblk*BIGBSIZE);
591: sblock.s_tfree = 0;
592: for (bno = sblock.s_isize; bno < maxblk; bno++)
593: if (!duped(bno)) {
594: BITFREE(flist, bno);
595: sblock.s_tfree++;
596: }
597: for (i = 0; i < nblk; i++)
598: bwrite(sblock.s_fsize - nblk + i, ((char *)flist)+(i*BIGBSIZE));
599: free((char *)flist);
600: sblock.s_valid = 1;
601: bwrite((daddr_t)1, (char *)&sblock);
602: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.