home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / 2014.11.minnie.tuhs.org.tar / minnie.tuhs.org / UnixArchive / PDP-11 / Trees / V6 / usr / source / s1 / dump.c < prev    next >
C/C++ Source or Header  |  1975-05-14  |  7KB  |  452 lines
  1. #
  2.  
  3. /*
  4.  * incremental dump
  5.  * dump fisbuodh filesystem
  6.  * f take output tape from arglist
  7.  * i from date in /etc/dtab
  8.  * s specify tape size in feet (feet = blocks/9)
  9.  * b specify tape size in blocks
  10.  * u update /etc/dtab to current date
  11.  * 0 dump from the epoch
  12.  * d dump specified number of days
  13.  * h dump specified number of hours
  14.  * a on incremental dump, dump files even >= MAXSIZE
  15.  */
  16.  
  17. char    *dargv[]
  18. {
  19.     0,
  20.     "i",
  21.     "/dev/rp0",
  22.     0
  23. };
  24.  
  25. #include "/usr/sys/ino.h"
  26. #include "/usr/sys/filsys.h"
  27. #define    MAXSIZE    1000
  28. struct filsys sblock;
  29. struct
  30. {
  31.     char    name[16];
  32.     int    date[2];
  33. } dtab[10];
  34. char    *dfile    "/etc/dtab";
  35. char    *ofile;
  36. int    *talist;
  37. int    fi;
  38. int    buf[256];
  39. int    dbuf[256];
  40. int    ibuf[256];
  41. int    vbuf[256];
  42. char    *date[2];
  43. char    *ddate[2];
  44. int    fo    -1;
  45. int    pher;
  46. int    dflg;
  47. int    iflg;
  48. int    cflg;
  49. int    aflg;
  50. char    *tsize    19000;
  51. char    *taddr;
  52.  
  53. main(argc, argv)
  54. char **argv;
  55. {
  56.     char *key;
  57.     int s, i, nfil, nblk, f;
  58.     register *tap;
  59.     register struct inode *ip;
  60.     int ino;
  61.  
  62.     ofile = "/dev/mt0";
  63.     time(date);
  64.     if(argc == 1) {
  65.         argv = dargv;
  66.         for(argc = 1; dargv[argc]; argc++);
  67.     }
  68.  
  69.     argc--;
  70.     argv++;
  71.     key = *argv;
  72.     while(*key)
  73.     switch(*key++) {
  74.  
  75.     default:
  76.         printf("bad character in key\n");
  77.         exit();
  78.  
  79.     case 'a': /* dump all (even large) */
  80.         aflg++;
  81.         continue;
  82.  
  83.     case '-':
  84.         continue;
  85.  
  86.     case 'c': /* increment file name */
  87.         cflg++;
  88.         continue;
  89.  
  90.     case 'f': /* file name from arg list */
  91.         argc--;
  92.         argv++;
  93.         ofile = *argv;
  94.         continue;
  95.  
  96.     case 'i': /* date from date file */
  97.         iflg++;
  98.         continue;
  99.  
  100.     case 's': /* tape size */
  101.         tsize = number(argv[1]) * 9;
  102.         argv++;
  103.         argc--;
  104.         continue;
  105.  
  106.     case 'b': /* tape size */
  107.         tsize = number(argv[1]);
  108.         argv++;
  109.         argc--;
  110.         continue;
  111.  
  112.     case 'u': /* rewrite date */
  113.         dflg++;
  114.         continue;
  115.  
  116.     case '0': /* dump all */
  117.         ddate[0] = ddate[1] = 0;
  118.         continue;
  119.  
  120.     case 'd': /* dump some number of days */
  121.         i = 21600;
  122.         goto sd;
  123.  
  124.     case 'h': /* dump some number of hours */
  125.         i = 900;
  126.         goto sd;
  127.  
  128.     sd:
  129.         ddate[0] = date[0];
  130.         ddate[1] = date[1];
  131.         s = number(argv[1])*4;
  132.         argv++;
  133.         argc--;
  134.         while(s) {
  135.             if(i > ddate[1])
  136.                 ddate[0]--;
  137.             ddate[1] =- i;
  138.             s--;
  139.         }
  140.         continue;
  141.     }
  142.     if(argc <= 1) {
  143.         printf("no file system specified\n");
  144.         exit();
  145.     }
  146.     if(iflg) {
  147.         f = open(dfile, 0);
  148.         if(f >= 0) {
  149.             read(f, dtab, sizeof dtab);
  150.             close(f);
  151.             for(i=0; i<10; i++)
  152.                 if(equal(dtab[i].name, argv[1])) {
  153.                     ddate[0] = dtab[i].date[0];
  154.                     ddate[1] = dtab[i].date[1];
  155.                 }
  156.         }
  157.     }
  158.     printf("%s:\n", argv[1]);
  159.     fi = open(argv[1], 0);
  160.     if(fi < 0) {
  161.         printf("cannot open %s\n", argv[1]);
  162.         exit();
  163.     }
  164.     printf("incremental dump from\n");
  165.     pdate(ddate);
  166.     sync();
  167.     bread(1, &sblock);
  168.     talist = sbrk(size(0, sblock.s_isize*32)*512);
  169.     tap = talist;
  170.     if(tap == -1) {
  171.         printf("No memory\n");
  172.         exit();
  173.     }
  174.     nfil = 0;
  175.     nblk = size(0, sblock.s_isize*32);
  176.     ino = 0;
  177.     for(i=0; i<sblock.s_isize; i++) {
  178.         bread(i+2, buf);
  179.         for(ip = &buf[0]; ip < &buf[256]; ip++) {
  180.             ino++;
  181.             if(ip->i_mode == 0 || ip->i_nlink == 0) {
  182.                 *tap++ = -1;
  183.                 continue;
  184.             }
  185.             if(ip->i_mtime[0] < ddate[0])
  186.                 goto no;
  187.             if(ip->i_mtime[0] == ddate[0] &&
  188.                ip->i_mtime[1] <  ddate[1])
  189.                 goto no;
  190.             s = size(ip->i_size0&0377, ip->i_size1) + 1;
  191.             if (s>MAXSIZE && aflg==0 && iflg!=0) {
  192.                 printf("%l big; not dumped.\n", ino);
  193.                 goto no;
  194.             }
  195.             nfil++;
  196.             nblk =+ s;
  197.             *tap++ = s;
  198.             continue;
  199.         no:
  200.             *tap++ = 0;
  201.         }
  202.     }
  203.     printf("%l files\n%l blocks\n", nfil, nblk);
  204.     i = ldiv(0, nblk, ldiv(0, tsize, 10));
  205.     printf("%l.%l tapes\n", i/10, i%10);
  206.     tap = buf;
  207.     clrbuf(tap);
  208.     *tap++ = sblock.s_isize;
  209.     *tap++ = sblock.s_fsize;
  210.     *tap++ = date[0];
  211.     *tap++ = date[1];
  212.     *tap++ = ddate[0];
  213.     *tap++ = ddate[1];
  214.     *tap++ = tsize;
  215.     swrite(buf);
  216.     i = size(0, sblock.s_isize*32);
  217.     tap = talist;
  218.     while(i--) {
  219.         bwrite(tap);
  220.         tap =+ 256;
  221.     }
  222.     tap = talist;
  223.     for(i=0; i<sblock.s_isize; i++) {
  224.         bread(i+2, buf);
  225.         for(ip = &buf[0]; ip < &buf[256]; ip++) {
  226.             if(*tap && *tap != -1)
  227.                 dump(ip, *tap-1);
  228.             tap++;
  229.         }
  230.     }
  231.     printf("%l phase errors\n", pher);
  232.     if(!dflg)
  233.         exit();
  234.     for(i=0; i<10; i++)
  235.         dtab[i].name[0] = 0;
  236.     f = open(dfile, 2);
  237.     if(f < 0) {
  238.         f = creat(dfile, 0666);
  239.         if(f < 0) {
  240.             printf("cannot create %s\n", dfile);
  241.             exit();
  242.         }
  243.     } else
  244.         read(f, dtab, sizeof dtab);
  245.     for(i=0; i<10; i++)
  246.         if(dtab[i].name[0] == 0 || equal(dtab[i].name, argv[1]))
  247.             goto found;
  248.     printf("%s full\n", dfile);
  249.     exit();
  250.  
  251. found:
  252.     for(s=0; s<15; s++) {
  253.         dtab[i].name[s] = argv[1][s];
  254.         if(argv[1][s] == 0)
  255.             break;
  256.     }
  257.     dtab[i].date[0] = date[0];
  258.     dtab[i].date[1] = date[1];
  259.     seek(f, 0, 0);
  260.     write(f, dtab, sizeof dtab);
  261.     printf("date updated\n");
  262.     pdate(date);
  263. }
  264.  
  265. pdate(d)
  266. int *d;
  267. {
  268.  
  269.     if(d[0] == 0 && d[1] == 0)
  270.         printf("the epoch\n"); else
  271.         printf(ctime(d));
  272. }
  273.  
  274. dump(ip, sz)
  275. struct inode *ip;
  276. {
  277.     register *p, *q, *r;
  278.  
  279.     p = dbuf;
  280.     q = ip;
  281.     clrbuf(p);
  282.     while(q < &ip->i_mtime[2])
  283.         *p++ = *q++;
  284.     swrite(dbuf);
  285.     if(ip->i_mode & (IFBLK&IFCHR)) {
  286.         if(sz != 0)
  287.             printf("special\n");
  288.         return;
  289.     }
  290.     for(p = &ip->i_addr[0]; p < &ip->i_addr[8]; p++)
  291.     if(*p) {
  292.         if(ip->i_mode&ILARG) {
  293.             bread(*p, ibuf);
  294.             for(q = &ibuf[0]; q < &ibuf[256]; q++)
  295.             if(*q) {
  296.                 if(p == &ip->i_addr[7]) {
  297.                     bread(*q, vbuf);
  298.                     for(r = &vbuf[0]; r < &vbuf[256]; r++)
  299.                     if(*r) {
  300.                         if(--sz < 0)
  301.                             goto pe;
  302.                         bread(*r, dbuf);
  303.                         bwrite(dbuf);
  304.                     }
  305.                     continue;
  306.                 }
  307.                 if(--sz < 0)
  308.                     goto pe;
  309.                 bread(*q, dbuf);
  310.                 bwrite(dbuf);
  311.             }
  312.         } else {
  313.             if(--sz < 0)
  314.                 goto pe;
  315.             bread(*p, dbuf);
  316.             bwrite(dbuf);
  317.         }
  318.     }
  319.     if(sz)
  320.         goto pe;
  321.     return;
  322.  
  323. pe:
  324.     clrbuf(dbuf);
  325.     while(--sz >= 0)
  326.         bwrite(dbuf);
  327.     pher++;
  328. }
  329.  
  330. bread(bno, b)
  331. {
  332.  
  333.     seek(fi, bno, 3);
  334.     if(read(fi, b, 512) != 512) {
  335.         printf("read error %l\n", bno);
  336.     }
  337. }
  338.  
  339. clrbuf(b)
  340. int *b;
  341. {
  342.     register i, *p;
  343.  
  344.     p = b;
  345.     i = 256;
  346.     while(i--)
  347.         *p++ = 0;
  348. }
  349.  
  350. swrite(b)
  351. int *b;
  352. {
  353.     register i, s, *p;
  354.  
  355.     i = 254;
  356.     s = taddr;
  357.     p = b;
  358.     while(i--)
  359.         s =+ *p++;
  360.     *p++ = taddr;
  361.     *p = 031415 - s;
  362.     bwrite(b);
  363. }
  364.  
  365. bwrite(b)
  366. {
  367.  
  368.     if(taddr == 0) {
  369.         if(fo != -1) {
  370.             printf("change tapes\n");
  371.             close(fo);
  372.             rdline();
  373.         }
  374.         otape();
  375.     }
  376. wloop:
  377.     if(write(fo, b, 512) != 512) {
  378.         printf("write error\n");
  379.         rdline();
  380.         seek(fo, taddr, 3);
  381.         goto wloop;
  382.     }
  383.     taddr++;
  384.     if(taddr >= tsize)
  385.         taddr = 0;
  386. }
  387.  
  388. rdline()
  389. {
  390.     int c;
  391.  
  392. loop:
  393.     c = 0;
  394.     read(0, &c, 1);
  395.     if(c == 0)
  396.         exit();
  397.     if(c != '\n')
  398.         goto loop;
  399. }
  400.  
  401. number(s)
  402. char *s;
  403. {
  404.     register n, c;
  405.  
  406.     n = 0;
  407.     while(c = *s++) {
  408.         if(c<'0' || c>'9')
  409.             continue;
  410.         n = n*10+c-'0';
  411.     }
  412.     return(n);
  413. }
  414.  
  415. size(s0, s1)
  416. {
  417.     register s;
  418.     extern ldivr;
  419.  
  420.     s = ldiv(s0&0377, s1, 512);
  421.     if(ldivr)
  422.         s++;
  423.     return(s);
  424. }
  425.  
  426. otape()
  427. {
  428.     register char *p;
  429.  
  430.     fo = creat(ofile, 0666);
  431.     if(fo < 0) {
  432.         printf("can not open %s\n", ofile);
  433.         exit();
  434.     }
  435.     if(!cflg)
  436.         return;
  437.     p = ofile;
  438.     while(*p++)
  439.         ;
  440.     p[-2]++;
  441. }
  442.  
  443. equal(a, b)
  444. char *a, *b;
  445. {
  446.  
  447.     while(*a++ == *b)
  448.         if(*b++ == 0)
  449.             return(1);
  450.     return(0);
  451. }
  452.