home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / src / cmd / dcheck.c < prev    next >
Encoding:
C/C++ Source or Header  |  1979-05-16  |  3.4 KB  |  217 lines
  1. /*
  2.  * dcheck - check directory consistency
  3.  */
  4. #define    NI    16
  5. #define    NB    10
  6. #define    NDIR    (BSIZE/sizeof(struct direct))
  7.  
  8. #include <stdio.h>
  9. #include <sys/param.h>
  10. #include <sys/inode.h>
  11. #include <sys/ino.h>
  12. #include <sys/dir.h>
  13. #include <sys/filsys.h>
  14. #include <sys/fblk.h>
  15.  
  16.  
  17. struct    filsys    sblock;
  18. struct    dinode    itab[INOPB*NI];
  19. daddr_t    iaddr[NADDR];
  20. ino_t    ilist[NB];
  21.  
  22. int    fi;
  23. ino_t    ino;
  24. char    *ecount;
  25. int    headpr;
  26. unsigned    nfiles;
  27.  
  28. int    nerror;
  29. daddr_t    bmap();
  30. long    atol();
  31. char    *malloc();
  32.  
  33. main(argc, argv)
  34. char *argv[];
  35. {
  36.     register i;
  37.     long n;
  38.  
  39.     while (--argc) {
  40.         argv++;
  41.         if (**argv=='-')
  42.         switch ((*argv)[1]) {
  43.  
  44.         case 'i':
  45.             for(i=0; i<NB; i++) {
  46.                 n = atol(argv[1]);
  47.                 if(n == 0)
  48.                     break;
  49.                 ilist[i] = n;
  50.                 argv++;
  51.                 argc--;
  52.             }
  53.             ilist[i] = 0;
  54.             continue;
  55.  
  56.         default:
  57.             printf("Bad flag %c\n", (*argv)[1]);
  58.             nerror++;
  59.         }
  60.         check(*argv);
  61.     }
  62.     return(nerror);
  63. }
  64.  
  65. check(file)
  66. char *file;
  67. {
  68.     register i;
  69.     register j;
  70.  
  71.     fi = open(file, 0);
  72.     if(fi < 0) {
  73.         printf("cannot open %s\n", file);
  74.         nerror++;
  75.         return;
  76.     }
  77.     headpr = 0;
  78.     printf("%s:\n", file);
  79.     sync();
  80.     bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
  81.     nfiles = (sblock.s_isize-2)*INOPB;
  82.     if (nfiles > 40000) {
  83.         printf("Only doing 40000 files\n");
  84.         nfiles = 40000;
  85.     }
  86.     ecount = malloc(nfiles+1);
  87.     if (ecount==NULL) {
  88.         printf("Not enough core\n");
  89.         exit(04);
  90.     }
  91.     for (i=0; i<=nfiles; i++)
  92.         ecount[i] = 0;
  93.     ino = 0;
  94.     for(i=2;; i+=NI) {
  95.         if(ino >= nfiles)
  96.             break;
  97.         bread((daddr_t)i, (char *)itab, sizeof(itab));
  98.         for(j=0; j<INOPB*NI; j++) {
  99.             if(ino >= nfiles)
  100.                 break;
  101.             ino++;
  102.             pass1(&itab[j]);
  103.         }
  104.     }
  105.     ino = 0;
  106.     for(i=2;; i+=NI) {
  107.         if(ino >= nfiles)
  108.             break;
  109.         bread((daddr_t)i, (char *)itab, sizeof(itab));
  110.         for(j=0; j<INOPB*NI; j++) {
  111.             if(ino >= nfiles)
  112.                 break;
  113.             ino++;
  114.             pass2(&itab[j]);
  115.         }
  116.     }
  117.     free(ecount);
  118. }
  119.  
  120. pass1(ip)
  121. register struct dinode *ip;
  122. {
  123.     struct direct dbuf[NDIR];
  124.     long doff;
  125.     struct direct *dp;
  126.     register i, j;
  127.     int k;
  128.     daddr_t d;
  129.     ino_t kno;
  130.  
  131.     if((ip->di_mode&IFMT) != IFDIR)
  132.         return;
  133.     l3tol(iaddr, ip->di_addr, NADDR);
  134.     doff = 0;
  135.     for(i=0;; i++) {
  136.         if(doff >= ip->di_size)
  137.             break;
  138.         d = bmap(i);
  139.         if(d == 0)
  140.             break;
  141.         bread(d, (char *)dbuf, BSIZE);
  142.         for(j=0; j<NDIR; j++) {
  143.             if(doff >= ip->di_size)
  144.                 break;
  145.             doff += sizeof(struct direct);
  146.             dp = &dbuf[j];
  147.             kno = dp->d_ino;
  148.             if(kno == 0)
  149.                 continue;
  150.             if(kno > nfiles || kno <= 1) {
  151.                 printf("%5u bad; %u/%.14s\n", kno, ino, dp->d_name);
  152.                 nerror++;
  153.                 continue;
  154.             }
  155.             for (k=0; ilist[k] != 0; k++)
  156.                 if (ilist[k]==kno) {
  157.                     printf("%5u arg; %u/%.14s\n", kno, ino, dp->d_name);
  158.                     nerror++;
  159.                 }
  160.             ecount[kno]++;
  161.             if (ecount[kno] == 0)
  162.                 ecount[kno] = 0377;
  163.         }
  164.     }
  165. }
  166.  
  167. pass2(ip)
  168. register struct dinode *ip;
  169. {
  170.     register i;
  171.  
  172.     i = ino;
  173.     if ((ip->di_mode&IFMT)==0 && ecount[i]==0)
  174.         return;
  175.     if (ip->di_nlink==((ecount[i])&0377) && ip->di_nlink!=0)
  176.         return;
  177.     if (ino < ROOTINO && ip->di_nlink==0 && ecount[i]==0)
  178.         return;
  179.     if (headpr==0) {
  180.         printf("     entries  link cnt\n");
  181.         headpr++;
  182.     }
  183.     printf("%u    %d    %d\n", ino,
  184.         ecount[i]&0377, ip->di_nlink);
  185. }
  186.  
  187. bread(bno, buf, cnt)
  188. daddr_t bno;
  189. char *buf;
  190. {
  191.     register i;
  192.  
  193.     lseek(fi, bno*BSIZE, 0);
  194.     if (read(fi, buf, cnt) != cnt) {
  195.         printf("read error %D\n", bno);
  196.         for(i=0; i<BSIZE; i++)
  197.             buf[i] = 0;
  198.     }
  199. }
  200.  
  201.  
  202. daddr_t
  203. bmap(i)
  204. {
  205.     daddr_t ibuf[NINDIR];
  206.  
  207.     if(i < NADDR-3)
  208.         return(iaddr[i]);
  209.     i -= NADDR-3;
  210.     if(i > NINDIR) {
  211.         printf("%u - huge directory\n", ino);
  212.         return((daddr_t)0);
  213.     }
  214.     bread(iaddr[NADDR-3], (char *)ibuf, sizeof(ibuf));
  215.     return(ibuf[i]);
  216. }
  217.