UNIX 6th Ed. - /usr/source/s1/dcheck.c

   1: #
   2: 
   3: char    *dargv[]
   4: {
   5:     "/dev/rrk2",
   6:     "/dev/rrp0",
   7:     0
   8: };
   9: 
  10: #define NINODE  16*16
  11: #define NI  20
  12: 
  13: #include "/usr/sys/ino.h"
  14: #include "/usr/sys/filsys.h"
  15: 
  16: struct  inode   inode[NINODE];
  17: struct  filsys  sblock;
  18: 
  19: int sflg;
  20: int headpr;
  21: 
  22: int ilist[NI] { -1};
  23: int fi;
  24: char    *ecount;
  25: char    *lasts;
  26: int ino;
  27: int nerror;
  28: int nfiles;
  29: struct dir {
  30:     int ino;
  31:     char    name[14];
  32: };
  33: 
  34: main(argc, argv)
  35: char **argv;
  36: {
  37:     register char **p;
  38:     register int n, *lp;
  39: 
  40:     ecount = sbrk(0);
  41:     if (argc == 1) {
  42:         for (p = dargv; *p;)
  43:             check(*p++);
  44:         return(nerror);
  45:     }
  46:     while (--argc) {
  47:         argv++;
  48:         if (**argv=='-') switch ((*argv)[1]) {
  49:         case 's':
  50:             sflg++;
  51:             continue;
  52: 
  53:         case 'i':
  54:             lp = ilist;
  55:             while (lp < &ilist[NI-1] && (n = number(argv[1]))) {
  56:                 *lp++ = n;
  57:                 argv++;
  58:                 argc--;
  59:             }
  60:             *lp++ = -1;
  61:             continue;
  62: 
  63:         default:
  64:             printf("Bad flag\n");
  65:         }
  66:         check(*argv);
  67:     }
  68:     return(nerror);
  69: }
  70: 
  71: check(file)
  72: char *file;
  73: {
  74:     register i, j;
  75:     fi = open(file, 0);
  76:     if(fi < 0) {
  77:         printf("cannot open %s\n", file);
  78:         return;
  79:     }
  80:     headpr = 0;
  81:     printf("%s:\n", file);
  82:     sync();
  83:     bread(1, &sblock, 512);
  84:     nfiles = sblock.s_isize*16;
  85:     if (lasts < nfiles) {
  86:         if ((sbrk(nfiles - lasts)) == -1) {
  87:             printf("Not enough core\n");
  88:             exit(04);
  89:         }
  90:         lasts = nfiles;
  91:     }
  92:     for (i=0; i<nfiles; i++)
  93:         ecount[i] = 0;
  94:     for(i=0; ino<nfiles; i =+ NINODE/16) {
  95:         bread(i+2, inode, sizeof inode);
  96:         for(j=0; j<NINODE && ino<nfiles; j++) {
  97:             ino++;
  98:             pass1(&inode[j]);
  99:         }
 100:     }
 101:     ino = 0;
 102:     for (i=0; ino<nfiles; i =+ NINODE/16) {
 103:         bread(i+2, inode, sizeof inode);
 104:         for (j=0; j<NINODE && ino<nfiles; j++) {
 105:             ino++;
 106:             pass2(&inode[j]);
 107:         }
 108:     }
 109: }
 110: 
 111: pass1(aip)
 112: struct inode *aip;
 113: {
 114:     register doff;
 115:     register struct inode *ip;
 116:     register struct dir *dp;
 117:     int i;
 118: 
 119:     ip = aip;
 120:     if((ip->i_mode&IALLOC) == 0)
 121:         return;
 122:     if((ip->i_mode&IFMT) != IFDIR)
 123:         return;
 124:     doff = 0;
 125:     while (dp = dread(ip, doff)) {
 126:         doff =+ 16;
 127:         if (dp->ino==0)
 128:             continue;
 129:         for (i=0; ilist[i] != -1; i++)
 130:             if (ilist[i]==dp->ino)
 131:                 printf("%5l arg; %l/%.14s\n", dp->ino, ino, dp->name);
 132:         ecount[dp->ino]++;
 133:     }
 134: }
 135: 
 136: pass2(aip)
 137: {
 138:     register struct inode *ip;
 139:     register i;
 140: 
 141:     ip = aip;
 142:     i = ino;
 143:     if ((ip->i_mode&IALLOC)==0 && ecount[i]==0)
 144:         return;
 145:     if (ip->i_nlink==ecount[i] && ip->i_nlink!=0)
 146:         return;
 147:     if (headpr==0) {
 148:         printf("entries	link cnt\n");
 149:         headpr++;
 150:     }
 151:     printf("%l	%d	%d\n", ino,
 152:         ecount[i]&0377, ip->i_nlink&0377);
 153: }
 154: 
 155: dread(aip, aoff)
 156: {
 157:     register b, off;
 158:     register struct inode *ip;
 159:     static ibuf[256];
 160:     static char buf[512];
 161: 
 162:     off = aoff;
 163:     ip = aip;
 164:     if ((off&0777)==0) {
 165:         if (off==0177000) {
 166:             printf("Monstrous directory %l\n", ino);
 167:             return(0);
 168:         }
 169:         if ((ip->i_mode&ILARG)==0) {
 170:             if (off>=010000 || (b = ip->i_addr[off>>9])==0)
 171:                 return(0);
 172:             bread(b, buf, 512);
 173:         } else {
 174:             if (off==0) {
 175:                 if (ip->i_addr[0]==0)
 176:                     return(0);
 177:                 bread(ip->i_addr[0], ibuf, 512);
 178:             }
 179:             if ((b = ibuf[(off>>9)&0177])==0)
 180:                 return(0);
 181:             bread(b, buf, 512);
 182:         }
 183:     }
 184:     return(&buf[off&0777]);
 185: }
 186: 
 187: bread(bno, buf, cnt)
 188: {
 189: 
 190:     seek(fi, bno, 3);
 191:     if(read(fi, buf, cnt) != cnt) {
 192:         printf("read error %d\n", bno);
 193:         exit();
 194:     }
 195: }
 196: 
 197: bwrite(bno, buf)
 198: {
 199: 
 200:     seek(fi, bno, 3);
 201:     if(write(fi, buf, 512) != 512) {
 202:         printf("write error %d\n", bno);
 203:         exit();
 204:     }
 205: }
 206: 
 207: number(as)
 208: char *as;
 209: {
 210:     register n, c;
 211:     register char *s;
 212: 
 213:     s = as;
 214:     n = 0;
 215:     while ((c = *s++) >= '0' && c <= '9') {
 216:         n = n*10+c-'0';
 217:     }
 218:     return(n);
 219: }

Defined functions

Defined variables

Defined struct's

Defined macros