![[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 [MW Coherent from dump] / coherent / d / bin / check|
Return to icheck.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / check |
1.1 root 1: /*
2: * Icheck - check i-list consistency of
3: * filesystems and (optionally) repair
4: * filesystems.
5: */
6: #include <stdio.h>
7: extern char *calloc();
8: #include <sys/filsys.h>
9: #include <sys/fblk.h>
10: #include <sys/dir.h>
11: #include <sys/ino.h>
12: #include "check.h"
13: #include <canon.h>
14: #undef DIR
15:
16: #define ROOTINO 2 /* I-number of root */
17: #define NBLOCK 20 /* Maximum number of blocks to check */
18: #define NBPC 8 /* Bits per character */
19: #define BOOTB 0 /* Boot block # */
20: #define SUPERB 1 /* Super block */
21: #define INOORG 2 /* Inodes begin here */
22: #define IBLK 12 /* I-node read blocking factor */
23: #define BSIZE 512
24: #define ND 10 /* Number of direct block */
25: #undef NI
26: #define NI 1
27: #define NII 1
28: #define NIII 1
29: #undef NADDR
30: #define NADDR (ND+NI+NII+NIII)
31:
32: /*
33: * Flags for crawldown.
34: */
35: #define PLAIN 0
36: #define DIR 1
37: #define BAD 2
38:
39: /*
40: * A chain of these structures
41: * holds all of the defective blocks found
42: * in the bad block file. The list is sorted for
43: * easy access by those parts of the program
44: * that scan blocks.
45: */
46: struct defect
47: {
48: struct defect *d_next; /* Link to next */
49: daddr_t d_start; /* First bad block in cluster */
50: int d_length; /* Size of cluster */
51: };
52:
53: #define test(bn) (bitmap[((unsigned)bn)/NBPC] & 1<<(((unsigned)bn)%NBPC))
54: #define mark(bn) (bitmap[((unsigned)bn)/NBPC] |= 1<<(((unsigned)bn)%NBPC))
55:
56: char tmb[] = "Too many block numbers specified\n";
57:
58: int nblock;
59: daddr_t blocks[NBLOCK];
60: ino_t freei[NICFREE]; /* Free i-nodes to put into superblock */
61: ino_t *freeip;
62: struct defect *deflist;
63: char superb[BSIZE];
64: char ibuf[IBLK*BSIZE];
65: char fbuf[BSIZE];
66: char idbuf[3][BSIZE]; /* One for each indirect level */
67:
68: /*
69: * Offsets of levels of indirection
70: * into the i-node addresses.
71: */
72: char offsets[] = {
73: 0, ND, ND+NI, ND+NI+NII, ND+NI+NII+NIII,
74: };
75:
76: /*
77: * Types of indirect and direct blocks
78: * by name.
79: */
80: char *btypes[] = {
81: "direct",
82: "indirect",
83: "double indirect",
84: "triple indirect",
85: };
86:
87: int sflag; /* Repair filesystem */
88: int vflag; /* More verbose information */
89: int exstat; /* Final exit status -- bits from <check.h> */
90: FILE *fs; /* File system i/o stream pointer */
91: char *bitmap; /* Bit map for blocks */
92: daddr_t fsize = SUPERB+1; /* Allow read of super-block */
93: unsigned isize;
94:
95: /* Various counters */
96: unsigned nfiles;
97: unsigned nreg;
98: unsigned ndir;
99: unsigned nbad; /* # of bad blocks */
100: unsigned nibad; /* # of bad blocks that were in ilist */
101: unsigned nbsp;
102: unsigned ncsp;
103: unsigned nmpx;
104: unsigned npipe;
105: long nblk;
106: long nfblk[4]; /* # of direct, single, double, and triple indirects */
107: long ndirb;
108: long nfreeb;
109: long nmissing;
110: long nfdup;
111: ino_t nifree;
112:
113: long atol();
114:
115: main(argc, argv)
116: char *argv[];
117: {
118:
119: while (argc>1 && *argv[1]=='-') {
120: switch (argv[1][1]) {
121: case 'b':
122: nblock = 0;
123: while (blocks[nblock] = atol(argv[2])) {
124: if (nblock++ >= NBLOCK) {
125: fprintf(stderr, tmb);
126: exstat |= IC_MISC;
127: break;
128: }
129: argv++;
130: argc--;
131: }
132: break;
133:
134: case 's':
135: sflag = 1;
136: break;
137:
138: case 'v':
139: vflag = 1;
140: break;
141:
142:
143: default:
144: usage();
145: }
146: argc--;
147: argv++;
148: }
149: if (argc > 1)
150: allcheck(argv+1);
151: else
152: usage();
153: exit(exstat);
154: }
155:
156: /*
157: * Check the given list of filesystems
158: */
159: allcheck(fsl)
160: register char **fsl;
161: {
162: while (*fsl != NULL)
163: if (icheck(*fsl++))
164: return;
165: }
166:
167: /*
168: * Check one filesystem
169: */
170: icheck(fsname)
171: char *fsname;
172: {
173: struct filsys *sbp;
174: register struct dinode *ip;
175: register int i;
176: register ino_t inum;
177: register char *mode;
178: int thischunk;
179: daddr_t seek, limit;
180: struct defect *cdsp;
181:
182: nfiles = 0;
183: nreg = 0;
184: ndir = 0;
185: ndirb = 0;
186: npipe = 0;
187: nbsp = 0;
188: ncsp = 0;
189: nmpx = 0;
190: nblk = 0;
191: nbad = 0;
192: nibad = 0;
193: for (i=0; i<4; i++)
194: nfblk[i] = 0;
195: nmissing = 0;
196: nfdup = 0;
197: nfreeb = 0;
198: nifree = 0;
199: freeip = freei;
200: mode = sflag ? "r+w" : "r";
201: if ((fs = fopen(fsname, mode)) == NULL) {
202: fprintf(stderr, "%s: cannot open\n", fsname);
203: exstat |= IC_MISC;
204: return;
205: }
206: printf("%s:\n", fsname);
207: if (!sflag)
208: sync();
209: bread((daddr_t)SUPERB, superb);
210: sbp = superb;
211: canint(sbp->s_isize);
212: candaddr(sbp->s_fsize);
213: canshort(sbp->s_nfree);
214: for (i=0; i<NICFREE; ++i)
215: candaddr(sbp->s_free[i]);
216: canshort(sbp->s_ninode);
217: for (i=0; i<NICINOD; ++i)
218: canino(sbp->s_inode[i]);
219: cantime(sbp->s_time);
220: candaddr(sbp->s_tfree);
221: canino(sbp->s_tinode);
222: canshort(sbp->s_m);
223: canshort(sbp->s_n);
224: canlong(sbp->s_unique);
225: fsize = sbp->s_fsize;
226: isize = sbp->s_isize;
227: if (isize<INOORG+1 || isize>=fsize || fsize<INOORG+1)
228: cerr("Ridiculous fsize/isize");
229: if ((bitmap=calloc((int)((fsize+NBPC-1)/NBPC), sizeof(char))) == NULL)
230: cerr("No space for bitmap");
231: bmark((daddr_t)BOOTB, "bootstrap", 0);
232: bmark((daddr_t)SUPERB, "super block", 0);
233: finddefective();
234: nblk = isize;
235: inum = 1;
236: seek = INOORG;
237: cdsp = deflist;
238: while (seek < isize) {
239: if (cdsp!=NULL && cdsp->d_start==seek) {
240: nibad += cdsp->d_length;
241: seek += cdsp->d_length;
242: inum += cdsp->d_length*INOPB;
243: cdsp = cdsp->d_next;
244: continue;
245: }
246: limit = seek+IBLK;
247: if (cdsp!=NULL && limit>cdsp->d_start)
248: limit = cdsp->d_start;
249: if (limit > isize)
250: limit = isize;
251: thischunk = limit-seek;
252: lseek(fileno(fs), seek*BSIZE, 0);
253: for (i=0; i<thischunk; ++i)
254: bmark((daddr_t)seek++, "inodes", 0);
255: thischunk *= BSIZE;
256: if (read(fileno(fs), ibuf, thischunk) != thischunk) {
257: fprintf(stderr, "I-node read error\n");
258: exstat |= IC_HARD;
259: break;
260: }
261: ip = (struct dinode *) &ibuf[0];
262: while (ip < (struct dinode *) &ibuf[thischunk]) {
263: if (inum != BADFIN) {
264: canshort(ip->di_mode);
265: canshort(ip->di_nlink);
266: canshort(ip->di_uid);
267: canshort(ip->di_gid);
268: cansize(ip->di_size);
269: cantime(ip->di_atime);
270: cantime(ip->di_mtime);
271: cantime(ip->di_ctime);
272: ilook(ip, inum);
273: }
274: ++inum;
275: ++ip;
276: }
277: }
278: freecount();
279: free(bitmap);
280: freedefective();
281: if (nmissing != 0)
282: exstat |= IC_MISS;
283: if (nfdup != 0)
284: exstat |= IC_DUPF;
285: if (!sflag && vflag) {
286: printf("f=%u,r=%u,d=%u,b=%u,c=%u,m=%u,p=%u\n", nfiles, nreg,
287: ndir, nbsp, ncsp, nmpx, npipe);
288: printf("blks=%ld, dirb=%ld, d=%ld, i=%ld, ii=%ld, iii=%ld\n",
289: nblk, ndirb, nfblk[0], nfblk[1], nfblk[2], nfblk[3]);
290: printf("free = %ld\n", nfreeb);
291: printf("bad=%u (%u in I-list)\n", nbad, nibad);
292: }
293: if (!sflag) {
294: if (nmissing != 0)
295: printf("missing = %ld\n", nmissing);
296: if (nfdup != 0)
297: printf("%ld dups in free\n", nfdup);
298: if (sbp->s_tinode != nifree) {
299: printf("Bad ifree list\n");
300: exstat |= IC_BFB;
301: }
302: }
303: if (sflag)
304: makesuper();
305: fclose(fs);
306: return (0);
307: }
308:
309: /*
310: * Look at each inode marking used blocks
311: * and checking consistency.
312: */
313: ilook(ip, inum)
314: register struct dinode *ip;
315: ino_t inum;
316: {
317: daddr_t addrs[NADDR];
318: register i, l;
319: int flag;
320:
321: if (ip->di_mode == 0) {
322: if (freeip < &freei[NICFREE])
323: *freeip++ = inum;
324: nifree++;
325: return;
326: }
327: nfiles++;
328: flag = PLAIN;
329: switch (ip->di_mode & IFMT) {
330: case IFREG:
331: nreg++;
332: break;
333:
334: case IFDIR:
335: ndir++;
336: flag = DIR;
337: break;
338:
339: case IFBLK:
340: nbsp++;
341: return;
342:
343: case IFCHR:
344: ncsp++;
345: return;
346:
347: case IFPIPE:
348: npipe++;
349: return;
350:
351: case IFMPB:
352: case IFMPC:
353: nmpx++;
354: return;
355:
356: default:
357: printf("%u: Bad filetype %o\n", inum, ip->di_mode&IFMT);
358: return;
359: }
360: l3tol(addrs, ip->di_addr, NADDR);
361: for (i = NADDR-1; i >= 0; i--)
362: for (l=1; l<=4; l++)
363: if (i < offsets[l]) {
364: crawldown(addrs[i], l-1, flag, inum);
365: break;
366: }
367: }
368:
369: /*
370: * Crawl down through `lev' levels
371: * of indirect blocks, starting at block
372: * `bn'. The `ino' argument is the inumber that
373: * started this all off; is just gets passed
374: * to `bmark'. The `flag' tells you what kind
375: * of blocks you have at level 0 (in can be BAD,
376: * DIR or PLAIN).
377: */
378: crawldown(bn, lev, flag, ino)
379: daddr_t bn;
380: int lev;
381: ino_t ino;
382: {
383: register char *bp;
384: register char *type;
385: register int i;
386:
387: if (bn == 0)
388: return;
389: nblk++;
390: if (lev==0 && flag==DIR) {
391: type = "dir";
392: ndirb++;
393: } else if (lev==0 && flag==BAD) {
394: type = "bad";
395: nbad++;
396: } else {
397: type = btypes[lev];
398: nfblk[lev]++;
399: }
400: if (bmark(bn, type, ino))
401: return;
402: if (lev==0 && flag==BAD)
403: savedefective(bn);
404: if (lev-- > 0) {
405: bread(bn, bp = idbuf[lev]);
406: for (i=0; i<NBN; i++) {
407: bn = ((long *)bp)[i];
408: candaddr(bn);
409: crawldown(bn, lev, flag, ino);
410: }
411: }
412: }
413:
414: /*
415: * This routine finds all of the
416: * defective space on the filsystem by reading
417: * the bad block file and marking all the blocks.
418: * The defective space list, used by the I-list
419: * scanner and other guys, is constructued.
420: */
421: finddefective()
422: {
423: register struct dinode *ip;
424: register i, level;
425: daddr_t addrs[NADDR];
426:
427: ++nfiles;
428: lseek(fileno(fs), (long)iblockn(BADFIN)*BSIZE, 0);
429: if (read(fileno(fs), ibuf, BSIZE) != BSIZE) {
430: printf("I/O error reading bad block inode\n");
431: exstat |= IC_HARD;
432: return;
433: }
434: ip = (struct dinode *) &ibuf[0] + iblocko(BADFIN);
435: canshort(ip->di_mode);
436: if (ip->di_mode == 0)
437: return;
438: if ((ip->di_mode&IFMT) != IFREG) {
439: printf("Bad block file has bad mode\n");
440: exstat |= IC_HARD;
441: return;
442: }
443: l3tol(addrs, ip->di_addr, NADDR);
444: for (i=NADDR-1; i>=0; --i) {
445: for (level=1; level<=4; ++level) {
446: if (i < offsets[level]) {
447: crawldown(addrs[i], level-1, BAD, BADFIN);
448: break;
449: }
450: }
451: }
452: }
453:
454: /*
455: * Free all of the nodes
456: * in the defective space list.
457: */
458: freedefective()
459: {
460: register struct defect *cdsp1, *cdsp2;
461:
462: cdsp1 = deflist;
463: deflist = NULL;
464: while (cdsp1 != NULL) {
465: cdsp2 = cdsp1->d_next;
466: free((char *) cdsp1);
467: cdsp1 = cdsp2;
468: }
469: }
470:
471: /*
472: * Add a new, defective block
473: * into the sorted defective block chain.
474: * Merge this block with the ends of
475: * any existing entries. No check is made
476: * for entries fusing; bad blocks get scooped
477: * (in general) up in order, and the bad blocks
478: * are generally sparsely placed on the disc.
479: */
480: savedefective(bn)
481: daddr_t bn;
482: {
483: register struct defect *cdsp1, *cdsp2, *cdsp3;
484:
485: cdsp1 = NULL;
486: cdsp2 = deflist;
487: while (cdsp2!=NULL && bn>cdsp2->d_start) {
488: cdsp1 = cdsp2;
489: cdsp2 = cdsp2->d_next;
490: }
491: if (cdsp1!=NULL && bn==cdsp1->d_start+cdsp1->d_length) {
492: ++cdsp1->d_length;
493: return;
494: }
495: if (cdsp2!=NULL && bn==cdsp2->d_start-1) {
496: --cdsp2->d_start;
497: ++cdsp2->d_length;
498: return;
499: }
500: if ((cdsp3=(struct defect *)malloc(sizeof(struct defect))) == NULL)
501: cerr("Out of space for bad blocks");
502: if (cdsp1 == NULL)
503: deflist = cdsp3; else
504: cdsp1->d_next = cdsp3;
505: cdsp3->d_next = cdsp2;
506: cdsp3->d_start = bn;
507: cdsp3->d_length = 1;
508: }
509:
510: /*
511: * Look at the free count for a filesystem
512: * by chasing down the free-list.
513: */
514: freecount()
515: {
516: register char *bmp;
517: register struct fblk *fbp;
518: struct filsys *sbp;
519: register unsigned i;
520: daddr_t bn;
521: long ntfree;
522:
523: sbp = superb;
524: fbp = &sbp->s_nfree;
525: ntfree = sbp->s_tfree;
526: while ((i = fbp->df_nfree) != 0) {
527: if ((unsigned)(fbp->df_nfree) > NICFREE) {
528: badfreelist();
529: return;
530: }
531: for (i=0; i<fbp->df_nfree; i++) {
532: bn = fbp->df_free[i];
533: bmark(bn, "free", 0);
534: nfreeb++;
535: }
536: bread(fbp->df_free[0], fbuf);
537: fbp = fbuf;
538: canint(fbp->df_nfree);
539: for (i=0; i<NICFREE; ++i)
540: candaddr(fbp->df_free[i]);
541: }
542: /*
543: * Count number of blocks not in bitmap
544: */
545: i = 1;
546: for (bn=0, bmp=bitmap; bn < fsize; bn++) {
547: if (i == 1<<NBPC) {
548: i = 1;
549: bmp++;
550: }
551: if ((*bmp & i) == 0)
552: nmissing++;
553: i <<= 1;
554: }
555: if (sflag)
556: nmissing -= isize + nfreeb;
557: if (nfreeb != ntfree) {
558: if (!sflag)
559: printf("Free list/tfree counts differ\n");
560: exstat |= IC_MISS;
561: }
562: }
563:
564: /*
565: * Remake the superblock - reconstructing
566: * the free-list if sflag is set.
567: */
568: makesuper()
569: {
570: register struct filsys *sbp;
571: register ino_t *fip;
572: register i;
573: daddr_t bn;
574:
575: sbp = superb;
576: /*
577: * Remake list of free i-numbers.
578: */
579: fip = sbp->s_inode;
580: sbp->s_ninode = freeip-freei;
581: while (freeip > freei)
582: *fip++ = *--freeip;
583: while (fip < &sbp->s_inode[NICFREE])
584: *fip++ = 0;
585: sbp->s_tinode = nifree;
586: /*
587: * Free all remaining blocks
588: * and write last one as tail of free-list
589: */
590: sbp->s_nfree = 0;
591: sbp->s_tfree = 0;
592: bn = fsize;
593: for (bn=fsize-1; bn>=isize; --bn)
594: if (!test(bn))
595: bfree(bn);
596: canint(sbp->s_isize);
597: candaddr(sbp->s_fsize);
598: canshort(sbp->s_nfree);
599: for (i=0; i<NICFREE; ++i)
600: candaddr(sbp->s_free[i]);
601: canshort(sbp->s_ninode);
602: for (i=0; i<NICINOD; ++i)
603: canino(sbp->s_inode[i]);
604: cantime(sbp->s_time);
605: candaddr(sbp->s_tfree);
606: canino(sbp->s_tinode);
607: canshort(sbp->s_m);
608: canshort(sbp->s_n);
609: canlong(sbp->s_unique);
610: bwrite((daddr_t)SUPERB, sbp);
611: }
612:
613: /*
614: * Free a block and, in so doing, construct
615: * the free list chain.
616: */
617: bfree(bn)
618: daddr_t bn;
619: {
620: register struct filsys *sbp;
621: register struct fblk *fbp;
622: register i;
623:
624: sbp = superb;
625: if (sbp->s_tfree == 0) {
626: bclear(fbuf, BSIZE);
627: bwrite(bn, fbuf);
628: }
629: if (sbp->s_nfree == NICFREE) {
630: bclear(fbp = fbuf, BSIZE);
631: fbp->df_nfree = sbp->s_nfree;
632: canint(fbp->df_nfree);
633: for (i=0; i<sbp->s_nfree; ++i) {
634: fbp->df_free[i] = sbp->s_free[i];
635: candaddr(fbp->df_free[i]);
636: }
637: bwrite(bn, fbuf);
638: sbp->s_nfree = 0;
639: }
640: sbp->s_free[sbp->s_nfree++] = bn;
641: sbp->s_tfree++;
642: }
643:
644: /*
645: * Read the specified block number
646: * into `buf'.
647: */
648: bread(bn, buf)
649: daddr_t bn;
650: char *buf;
651: {
652: if (bn<0 || bn>=fsize) {
653: badblock(bn, "any", 0);
654: bclear(buf, BSIZE);
655: return;
656: }
657: lseek(fileno(fs), (fsize_t)BSIZE * bn, 0);
658: if (read(fileno(fs), buf, BSIZE) != BSIZE) {
659: fprintf(stderr, "Read error %ld\n", (long)bn);
660: exstat |= IC_HARD;
661: bclear(buf, BSIZE);
662: }
663: }
664:
665: /*
666: * Write block `bn' from `buf'.
667: */
668: bwrite(bn, buf)
669: daddr_t bn;
670: char *buf;
671: {
672: if (bn<0 || bn>=fsize) {
673: badblock(bn, "any", 0);
674: return;
675: }
676: lseek(fileno(fs), (fsize_t)BSIZE * bn, 0);
677: if (write(fileno(fs), buf, BSIZE) != BSIZE) {
678: fprintf(stderr, "Write error %ld\n", (long)bn);
679: exstat |= IC_HARD;
680: }
681: }
682:
683: /*
684: * Mark block # `bn' as
685: * seen before an check for
686: * duplicates.
687: * Bmark only marks file blocks if `sflag' is
688: * set so that the free list can be constructed
689: * again.
690: * Return 1 when something is wrong.
691: */
692: bmark(bn, type, inum)
693: daddr_t bn;
694: char *type;
695: ino_t inum;
696: {
697: register nb;
698:
699: if (bn<0 || bn>=fsize) {
700: badblock(bn, type, inum);
701: return (1);
702: }
703: if (nb = nblock) {
704: register i;
705:
706: for (i=0; i<nb; i++)
707: if (blocks[i] == bn)
708: printf("%ld arg, class=%s, inode=%u\n",
709: (long)bn, type, inum);
710: }
711: {
712: register char *bp;
713: register int mask;
714:
715: mask = 1 << ((unsigned)bn)%NBPC;
716: bp = bitmap + ((unsigned)bn)/NBPC;
717: if (*bp & mask) /* if (test(bn)) */
718: dupblock(bn, type, inum);
719: else if (!sflag || inum!=0)
720: *bp |= mask; /* mark(bn) */
721: }
722: return (0);
723: }
724:
725: /*
726: * Clear a block of memory
727: * pointed to by `bp' for size
728: * `nb' bytes.
729: */
730: bclear(bp, nb)
731: register char *bp;
732: register unsigned nb;
733: {
734: if (nb)
735: do {
736: *bp++ = 0;
737: } while (--nb);
738: }
739:
740: /*
741: * Error routines
742: */
743: badblock(bn, type, inum)
744: daddr_t bn;
745: char *type;
746: ino_t inum;
747: {
748: register int perr = 0;
749:
750: if (strcmp(type, "free") != 0) {
751: perr++;
752: exstat |= IC_HARD;
753: } else {
754: exstat |= IC_BADF;
755: if (!sflag)
756: perr++;
757: }
758: if (perr)
759: printf("%ld bad, class=%s, inode=%u\n", (long)bn, type, inum);
760: }
761:
762: dupblock(bn, type, inum)
763: daddr_t bn;
764: char *type;
765: ino_t inum;
766: {
767: if (inum != 0)
768: exstat |= IC_HARD;
769: else
770: nfdup++;
771: if (vflag || inum!=0)
772: printf("%ld dup, class=%s, inode=%u\n", (long)bn, type, inum);
773: }
774:
775: badfreelist()
776: {
777: if (!sflag) {
778: printf("Bad freelist\n");
779: exstat |= IC_BFB;
780: }
781: }
782:
783: /*
784: * Unrecoverable errors
785: */
786: cerr(x)
787: {
788: printf("%r", &x);
789: putchar('\n');
790: exit(IC_MISC);
791: }
792:
793: usage()
794: {
795: cerr("Usage: icheck [-sv] [-b bn ...] filesystem ...");
796: }
797:
798: /*
799: * Block copy routine
800: */
801: bcopy(in, out, nb)
802: register char *in, *out;
803: register unsigned nb;
804: {
805: if (nb)
806: do {
807: *out++ = *in++;
808: } while (--nb);
809: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.