home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V6 / usr / source / s1 / icheck.c < prev    next >
Encoding:
C/C++ Source or Header  |  1975-07-18  |  4.9 KB  |  322 lines
  1. #
  2.  
  3. char    *dargv[]
  4. {
  5.     "/dev/rrk2",
  6.     "/dev/rrp0",
  7.     0
  8. };
  9. #define    NINODE    16*16
  10. #define    NB    10
  11. #include "/usr/sys/ino.h"
  12. #include "/usr/sys/filsys.h"
  13.  
  14. struct    inode    inode[NINODE];
  15. struct    filsys    sblock;
  16.  
  17. int    sflg;
  18.  
  19. int    fi;
  20. int    nifiles;
  21. int    nfile;
  22. int    nspcl;
  23. int    nlarg;
  24. int    nvlarg;
  25. int    nindir;
  26. int    nvindir;
  27. int    ndir;
  28. int    nused;
  29. int    nfree;
  30. int    ino;
  31. int    ndup;
  32. int    blist[10] { -1};
  33. int    nerror;
  34. int    bmap[4096];
  35.  
  36. main(argc, argv)
  37. char **argv;
  38. {
  39.     register char **p;
  40.     register int n, *lp;
  41.  
  42.     if (argc == 1) {
  43.         for (p = dargv; *p;)
  44.             check(*p++);
  45.         return(nerror);
  46.     }
  47.     while (--argc) {
  48.         argv++;
  49.         if (**argv=='-') switch ((*argv)[1]) {
  50.         case 's':
  51.             sflg++;
  52.             continue;
  53.  
  54.         case 'b':
  55.             lp = blist;
  56.             while (lp < &blist[NB-1] && (n = number(argv[1]))) {
  57.                 *lp++ = n;
  58.                 argv++;
  59.                 argc--;
  60.             }
  61.             *lp++ = -1;
  62.             continue;
  63.  
  64.         default:
  65.             printf("Bad flag\n");
  66.         }
  67.         check(*argv);
  68.     }
  69.     return(nerror);
  70. }
  71.  
  72. check(file)
  73. char *file;
  74. {
  75.     register *ip, i, j;
  76.  
  77.     fi = open(file, sflg?2:0);
  78.     if (fi < 0) {
  79.         printf("cannot open %s\n", file);
  80.         nerror =| 04;
  81.         return;
  82.     }
  83.     printf("%s:\n", file);
  84.     nfile = 0;
  85.     nspcl = 0;
  86.     nlarg = 0;
  87.     nvlarg = 0;
  88.     nindir = 0;
  89.     nvindir = 0;
  90.     ndir = 0;
  91.     nused = 0;
  92.     nfree = 0;
  93.     ndup = 0;
  94.     for (ip = bmap; ip < &bmap[4096];)
  95.         *ip++ = 0;
  96.     sync();
  97.     bread(1, &sblock, 512);
  98.     nifiles = sblock.s_isize*16;
  99.     for(i=0; ino < nifiles; i =+ NINODE/16) {
  100.         bread(i+2, inode, sizeof inode);
  101.         for(j=0; j<NINODE && ino<nifiles; j++) {
  102.             ino++;
  103.             pass1(&inode[j]);
  104.         }
  105.     }
  106.     ino = 0;
  107.     sync();
  108.     bread(1, &sblock, 512);
  109.     if (sflg) {
  110.         makefree();
  111.         return;
  112.     }
  113.     while(i = alloc()) {
  114.         if (chk(i, "free"))
  115.             break;
  116.         nfree++;
  117.     }
  118.     if (ndup) {
  119.         printf("%l dups in free\n", ndup);
  120.         nerror =| 02;
  121.     }
  122.     j = 0;
  123.     for (ip = bmap; ip < &bmap[4096];) {
  124.         i = *ip++;
  125.         while (i) {
  126.             if (i<0)
  127.                 j--;
  128.             i =<< 1;
  129.         }
  130.     }
  131.     j =+ sblock.s_fsize - sblock.s_isize - 2;
  132.     if (j)
  133.         printf("missing%5l\n", j);
  134.     printf("spcl  %6l\n", nspcl);
  135.     printf("files %6l\n", nfile);
  136.     printf("large %6l\n", nlarg);
  137.     if (nvlarg)
  138.         printf("huge  %6l\n", nvlarg);
  139.     printf("direc %6l\n", ndir);
  140.     printf("indir %6l\n", nindir);
  141.     if (nvindir)
  142.         printf("indir2%6l\n", nvindir);
  143.     printf("used  %6l\n", nused);
  144.     printf("free  %6l\n", nfree);
  145.     close(fi);
  146. }
  147.  
  148. pass1(aip)
  149. struct inode *aip;
  150. {
  151.     int buf[256], vbuf[256];
  152.     register i, j, *ip;
  153.  
  154.     ip = aip;
  155.     if ((ip->i_mode&IALLOC) == 0)
  156.         return;
  157.     if ((ip->i_mode&IFCHR&IFBLK) != 0) {
  158.         nspcl++;
  159.         return;
  160.     }
  161.     if ((ip->i_mode&IFMT) == IFDIR)
  162.         ndir++;
  163.     else
  164.         nfile++;
  165.     if ((ip->i_mode&ILARG) != 0) {
  166.         nlarg++;
  167.         for(i=0; i<7; i++)
  168.         if (ip->i_addr[i] != 0) {
  169.             nindir++;
  170.             if (chk(ip->i_addr[i], "indirect"))
  171.                 continue;
  172.             bread(ip->i_addr[i], buf, 512);
  173.             for(j=0; j<256; j++)
  174.             if (buf[j] != 0)
  175.                 chk(buf[j], "data (large)");
  176.         }
  177.         if (ip->i_addr[7]) {
  178.             nvlarg++;
  179.             if (chk(ip->i_addr[7], "indirect"))
  180.                 return;
  181.             bread(ip->i_addr[7], buf, 512);
  182.             for(i=0; i<256; i++)
  183.             if (buf[i] != 0) {
  184.                 nvindir++;
  185.                 if (chk(buf[i], "2nd indirect"))
  186.                     continue;
  187.                 bread(buf[i], vbuf, 512);
  188.                 for(j=0; j<256; j++)
  189.                 if (vbuf[j])
  190.                     chk(vbuf[j], "data (very large)");
  191.             }
  192.         }
  193.         return;
  194.     }
  195.     for(i=0; i<8; i++) {
  196.         if (ip->i_addr[i] != 0)
  197.             chk(ip->i_addr[i], "data (small)");
  198.     }
  199. }
  200.  
  201. chk(ab, s)
  202. char *ab;
  203. {
  204.     register char *b;
  205.     register n, m;
  206.  
  207.     b = ab;
  208.     if (ino)
  209.         nused++;
  210.     if (b<sblock.s_isize+2 || b>=sblock.s_fsize) {
  211.         printf("%l bad; inode=%l, class=%s\n", b, ino, s);
  212.         return(1);
  213.     }
  214.     m = 1 << (b&017);
  215.     n = (b>>4) & 07777;
  216.     if (bmap[n]&m) {
  217.         printf("%l dup; inode=%l, class=%s\n", b, ino, s);
  218.         ndup++;
  219.     }
  220.     bmap[n] =| m;
  221.     for (n=0; blist[n] != -1; n++)
  222.         if (b == blist[n])
  223.             printf("%l arg; inode=%l, class=%s\n", b, ino, s);
  224.     return(0);
  225. }
  226.  
  227. alloc()
  228. {
  229.     register b, i;
  230.     int buf[256];
  231.  
  232.     i = --sblock.s_nfree;
  233.     if (i<0 || i>=100) {
  234.         printf("bad freeblock\n");
  235.         return(0);
  236.     }
  237.     b = sblock.s_free[i];
  238.     if (b == 0)
  239.         return(0);
  240.     if (sblock.s_nfree <= 0) {
  241.         bread(b, buf, 512);
  242.         sblock.s_nfree = buf[0];
  243.         for(i=0; i<100; i++)
  244.             sblock.s_free[i] = buf[i+1];
  245.     }
  246.     return(b);
  247. }
  248.  
  249. bread(bno, buf, cnt)
  250. int *buf;
  251. {
  252.     register *ip;
  253.  
  254.     seek(fi, bno, 3);
  255.     if (read(fi, buf, cnt) != cnt) {
  256.         printf("read error %d\n", bno);
  257.         if (sflg) {
  258.             printf("No update\n");
  259.             sflg = 0;
  260.         }
  261.         for (ip = buf; ip < &buf[256];)
  262.             *ip++ = 0;
  263.     }
  264. }
  265.  
  266. free(in)
  267. {
  268.     register i;
  269.     int buf[256];
  270.  
  271.     if (sblock.s_nfree >= 100) {
  272.         buf[0] = sblock.s_nfree;
  273.         for(i=0; i<100; i++)
  274.             buf[i+1] = sblock.s_free[i];
  275.         sblock.s_nfree = 0;
  276.         bwrite(in, buf);
  277.     }
  278.     sblock.s_free[sblock.s_nfree++] = in;
  279. }
  280.  
  281. bwrite(bno, buf)
  282. {
  283.  
  284.     seek(fi, bno, 3);
  285.     if (write(fi, buf, 512) != 512)
  286.         printf("write error %d\n", bno);
  287. }
  288.  
  289. number(as)
  290. char *as;
  291. {
  292.     register n, c;
  293.     register char *s;
  294.  
  295.     s = as;
  296.     n = 0;
  297.     while ((c = *s++) >= '0' && c <= '9') {
  298.         n = n*10+c-'0';
  299.     }
  300.     return(n);
  301. }
  302.  
  303. makefree()
  304. {
  305.     register i;
  306.  
  307.     sblock.s_nfree = 0;
  308.     sblock.s_ninode = 0;
  309.     sblock.s_flock = 0;
  310.     sblock.s_ilock = 0;
  311.     sblock.s_fmod = 0;
  312.     free(0);
  313.     for(i=sblock.s_fsize-1; i>=sblock.s_isize+2; i--) {
  314.         if ((bmap[(i>>4)&07777] & (1<<(i&017)))==0)
  315.             free(i);
  316.     }
  317.     bwrite(1, &sblock);
  318.     close(fi);
  319.     sync();
  320.     return;
  321. }
  322.