dump/tape.c

   1 /*
   2  *      Ported to Linux's Second Extended File System as part of the
   3  *      dump and restore backup suit
   4  *      Remy Card <card@Linux.EU.Org>, 1994-1997
   5  *      Stelian Pop <pop@noos.fr>, 1999-2000
   6  *      Stelian Pop <pop@noos.fr> - Alcôve <www.alcove.fr>, 2000
   7  */
   8
   9 /*-
  10  * Copyright (c) 1980, 1991, 1993
  11  *      The Regents of the University of California.  All rights reserved.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. All advertising materials mentioning features or use of this software
  22  *    must display the following acknowledgement:
  23  *      This product includes software developed by the University of
  24  *      California, Berkeley and its contributors.
  25  * 4. Neither the name of the University nor the names of its contributors
  26  *    may be used to endorse or promote products derived from this software
  27  *    without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  39  * SUCH DAMAGE.
  40  */
  41
  42 #ifndef lint
  43 static const char rcsid[] =
  44         "$Id: tape.c,v 1.49 2001/07/18 09:50:48 stelian Exp $";
  45 #endif /* not lint */
  46
  47 #include <config.h>
  48 #include <compatlfs.h>
  49 #include <errno.h>
  50 #include <fcntl.h>
  51 #include <setjmp.h>
  52 #include <signal.h>
  53 #include <stdio.h>
  54 #include <compaterr.h>
  55 #ifdef __STDC__
  56 #include <stdlib.h>
  57 #include <string.h>
  58 #include <unistd.h>
  59 #else
  60 int    write(), read();
  61 #endif
  62
  63 #ifdef __linux__
  64 #include <sys/types.h>
  65 #include <sys/time.h>
  66 #include <time.h>
  67 #endif
  68 #include <sys/param.h>
  69 #include <sys/socket.h>
  70 #include <sys/time.h>
  71 #include <sys/wait.h>
  72 #include <sys/mtio.h>
  73 #ifdef __linux__
  74 #ifdef HAVE_EXT2FS_EXT2_FS_H
  75 #include <ext2fs/ext2_fs.h>
  76 #else
  77 #include <linux/ext2_fs.h>
  78 #endif
  79 #include <ext2fs/ext2fs.h>
  80 #include <bsdcompat.h>
  81 #elif defined sunos
  82 #include <sys/vnode.h>
  83
  84 #include <ufs/fs.h>
  85 #include <ufs/inode.h>
  86 #else
  87 #include <ufs/ufs/dinode.h>
  88 #include <ufs/ffs/fs.h>
  89 #endif  /* __linux__ */
  90
  91 #include <protocols/dumprestore.h>
  92
  93 #ifdef HAVE_ZLIB
  94 #include <zlib.h>
  95 #endif /* HAVE_ZLIB */
  96
  97 #include "dump.h"
  98
  99 int     writesize;              /* size of malloc()ed buffer for tape */
 100 long    lastspclrec = -1;       /* tape block number of last written header */
 101 int     trecno = 0;             /* next record to write in current block */
 102 extern  long blocksperfile;     /* number of blocks per output file */
 103 long    blocksthisvol;          /* number of blocks on current output file */
 104 extern  int ntrec;              /* blocking factor on tape */
 105 extern  int cartridge;
 106 extern  char *host;
 107 char    *nexttape;
 108 extern  pid_t rshpid;
 109 int     eot_code = 1;
 110 long long tapea_bytes = 0;      /* bytes_written at start of current volume */
 111
 112 static  ssize_t atomic_read __P((int, void *, size_t));
 113 static  ssize_t atomic_write __P((int, const void *, size_t));
 114 static  void doslave __P((int, int));
 115 static  void enslave __P((void));
 116 static  void flushtape __P((void));
 117 static  void killall __P((void));
 118 static  void rollforward __P((void));
 119 static  int system_command __P((const char *, const char *, int));
 120
 121 /*
 122  * Concurrent dump mods (Caltech) - disk block reading and tape writing
 123  * are exported to several slave processes.  While one slave writes the
 124  * tape, the others read disk blocks; they pass control of the tape in
 125  * a ring via signals. The parent process traverses the filesystem and
 126  * sends writeheader()'s and lists of daddr's to the slaves via pipes.
 127  * The following structure defines the instruction packets sent to slaves.
 128  */
 129 struct req {
 130         daddr_t dblk;
 131         int count;
 132 };
 133 int reqsiz;
 134
 135 struct slave_results {
 136         ssize_t unclen;         /* uncompressed length */
 137         ssize_t clen;           /* compressed length */
 138 };
 139
 140 #define SLAVES 3                /* 1 slave writing, 1 reading, 1 for slack */
 141 struct slave {
 142         int tapea;              /* header number at start of this chunk */
 143         int count;              /* count to next header (used for TS_TAPE */
 144                                 /* after EOT) */
 145         int inode;              /* inode that we are currently dealing with */
 146         int fd;                 /* FD for this slave */
 147         int pid;                /* PID for this slave */
 148         int sent;               /* 1 == we've sent this slave requests */
 149         int firstrec;           /* record number of this block */
 150         char (*tblock)[TP_BSIZE]; /* buffer for data blocks */
 151         struct req *req;        /* buffer for requests */
 152 } slaves[SLAVES+1];
 153 struct slave *slp;
 154
 155 char    (*nextblock)[TP_BSIZE];
 156
 157 static time_t tstart_volume;    /* time of volume start */
 158 static int tapea_volume;        /* value of spcl.c_tapea at volume start */
 159
 160 int master;             /* pid of master, for sending error signals */
 161 int tenths;             /* length of tape overhead per block written */
 162 static int caught;      /* have we caught the signal to proceed? */
 163 static int ready;       /* have we reached the lock point without having */
 164                         /* received the SIGUSR2 signal from the prev slave? */
 165 static sigjmp_buf jmpbuf;       /* where to jump to if we are ready when the */
 166                         /* SIGUSR2 arrives from the previous slave */
 167 #ifdef USE_QFA
 168 static int gtperr = 0;
 169 #endif
 170
 171 int
 172 alloctape(void)
 173 {
 174         int pgoff = getpagesize() - 1;
 175         char *buf;
 176         int i;
 177
 178         writesize = ntrec * TP_BSIZE;
 179         reqsiz = (ntrec + 1) * sizeof(struct req);
 180         /*
 181          * CDC 92181's and 92185's make 0.8" gaps in 1600-bpi start/stop mode
 182          * (see DEC TU80 User's Guide).  The shorter gaps of 6250-bpi require
 183          * repositioning after stopping, i.e, streaming mode, where the gap is
 184          * variable, 0.30" to 0.45".  The gap is maximal when the tape stops.
 185          */
 186         if (blocksperfile == 0 && !unlimited)
 187                 tenths = (cartridge ? 16 : density == 625 ? 5 : 8);
 188         else {
 189                 tenths = 0;
 190                 density = 1;
 191         }
 192         /*
 193          * Allocate tape buffer contiguous with the array of instruction
 194          * packets, so flushtape() can write them together with one write().
 195          * Align tape buffer on page boundary to speed up tape write().
 196          */
 197         for (i = 0; i <= SLAVES; i++) {
 198                 buf = (char *)
 199                     malloc((unsigned)(reqsiz + writesize + pgoff + TP_BSIZE));
 200                 if (buf == NULL)
 201                         return(0);
 202                 slaves[i].tblock = (char (*)[TP_BSIZE])
 203 #ifdef  __linux__
 204                     (((long)&buf[reqsiz] + pgoff) &~ pgoff);
 205 #else
 206                     (((long)&buf[ntrec + 1] + pgoff) &~ pgoff);
 207 #endif
 208                 slaves[i].req = (struct req *)slaves[i].tblock - ntrec - 1;
 209         }
 210         slp = &slaves[0];
 211         slp->count = 1;
 212         slp->tapea = 0;
 213         slp->firstrec = 0;
 214         nextblock = slp->tblock;
 215         return(1);
 216 }
 217
 218 void
 219 writerec(const void *dp, int isspcl)
 220 {
 221
 222         slp->req[trecno].dblk = (daddr_t)0;
 223         slp->req[trecno].count = 1;
 224         /* XXX post increment triggers an egcs-1.1.2-12 bug on alpha/sparc */
 225         *(union u_spcl *)(*(nextblock)) = *(union u_spcl *)dp;
 226         nextblock++;
 227         if (isspcl)
 228                 lastspclrec = spcl.c_tapea;
 229         trecno++;
 230         spcl.c_tapea++;
 231         if (trecno >= ntrec)
 232                 flushtape();
 233 }
 234
 235 void
 236 dumpblock(daddr_t blkno, int size)
 237 {
 238         int avail, tpblks, dblkno;
 239
 240         dblkno = fsbtodb(sblock, blkno);
 241         tpblks = size >> tp_bshift;
 242         while ((avail = MIN(tpblks, ntrec - trecno)) > 0) {
 243                 slp->req[trecno].dblk = dblkno;
 244                 slp->req[trecno].count = avail;
 245                 trecno += avail;
 246                 spcl.c_tapea += avail;
 247                 if (trecno >= ntrec)
 248                         flushtape();
 249                 dblkno += avail << (tp_bshift - dev_bshift);
 250                 tpblks -= avail;
 251         }
 252 }
 253
 254 int     nogripe = 0;
 255
 256 static void
 257 tperror(int errnum)
 258 {
 259
 260         if (pipeout) {
 261                 msg("write error on %s: %s\n", tape, strerror(errnum));
 262                 quit("Cannot recover\n");
 263                 /* NOTREACHED */
 264         }
 265         msg("write error %d blocks into volume %d: %s\n",
 266             blocksthisvol, tapeno, strerror(errnum));
 267         broadcast("DUMP WRITE ERROR!\n");
 268         if (query("Do you want to rewrite this volume?")) {
 269                 msg("Closing this volume.  Prepare to restart with new media;\n");
 270                 msg("this dump volume will be rewritten.\n");
 271                 killall();
 272                 nogripe = 1;
 273                 close_rewind();
 274                 Exit(X_REWRITE);
 275         }
 276         if (query("Do you want to start the next tape?"))
 277                 return;
 278         dumpabort(0);
 279 }
 280
 281 static void
 282 sigpipe(int signo)
 283 {
 284
 285         quit("Broken pipe\n");
 286 }
 287
 288 /*
 289  * do_stats --
 290  *     Update xferrate stats
 291  */
 292 time_t
 293 do_stats(void)
 294 {
 295         time_t tnow, ttaken;
 296         int blocks;
 297
 298         tnow = time(NULL);
 299         ttaken = tnow - tstart_volume;
 300         blocks = spcl.c_tapea - tapea_volume;
 301         msg("Volume %d completed at: %s", tapeno, ctime(&tnow));
 302         if (! compressed)
 303                 msg("Volume %d %ld tape blocks (%.2fMB)\n", tapeno,
 304                         blocks, ((double)blocks * TP_BSIZE / 1048576));
 305         if (ttaken > 0) {
 306                 long volkb = (bytes_written - tapea_bytes) / 1024;
 307                 long txfrate = volkb / ttaken;
 308                 msg("Volume %d took %d:%02d:%02d\n", tapeno,
 309                         ttaken / 3600, (ttaken % 3600) / 60, ttaken % 60);
 310                 msg("Volume %d transfer rate: %ld kB/s\n", tapeno,
 311                         txfrate);
 312                 xferrate += txfrate;
 313                 if (compressed) {
 314                         double rate = .0005 + (double) blocks / (double) volkb;
 315                         msg("Volume %d %ldkB uncompressed, %ldkB compressed,"
 316                                 " %1.3f:1\n",
 317                                 tapeno, blocks, volkb, rate);
 318                 }
 319         }
 320         return(tnow);
 321 }
 322
 323 char *
 324 mktimeest(time_t tnow)
 325 {
 326         static char msgbuf[128];
 327         time_t deltat;
 328
 329         msgbuf[0] = '\0';
 330
 331         if (blockswritten < 500)
 332                 return NULL;
 333         if (blockswritten > tapesize)
 334                 tapesize = blockswritten;
 335         deltat = tstart_writing - tnow + (1.0 * (tnow - tstart_writing))
 336                 / blockswritten * tapesize;
 337         if (tnow > tstart_volume)
 338                 (void)snprintf(msgbuf, sizeof(msgbuf),
 339                         "%3.2f%% done at %ld kB/s, finished in %d:%02d\n",
 340                         (blockswritten * 100.0) / tapesize,
 341                         (spcl.c_tapea - tapea_volume) / (tnow - tstart_volume),
 342                         (int)(deltat / 3600), (int)((deltat % 3600) / 60));
 343         else
 344                 (void)snprintf(msgbuf, sizeof(msgbuf),
 345                         "%3.2f%% done, finished in %d:%02d\n",
 346                         (blockswritten * 100.0) / tapesize,
 347                         (int)(deltat / 3600), (int)((deltat % 3600) / 60));
 348
 349         return msgbuf;
 350 }
 351
 352 #if defined(SIGINFO)
 353 /*
 354  * statussig --
 355  *     information message upon receipt of SIGINFO
 356  */
 357 void
 358 statussig(int notused)
 359 {
 360         int save_errno = errno;
 361         char *buf;
 362
 363         buf = mktimeest(time(NULL));
 364         if (buf)
 365                 write(STDERR_FILENO, buf, strlen(buf));
 366         errno = save_errno;
 367 }
 368 #endif
 369
 370 static void
 371 flushtape(void)
 372 {
 373         int i, blks, got;
 374         long lastfirstrec;
 375         struct slave_results returned;
 376
 377         int siz = (char *)nextblock - (char *)slp->req;
 378
 379         slp->req[trecno].count = 0;                     /* Sentinel */
 380
 381         if (atomic_write( slp->fd, (char *)slp->req, siz) != siz)
 382                 quit("error writing command pipe: %s\n", strerror(errno));
 383         slp->sent = 1; /* we sent a request, read the response later */
 384
 385         lastfirstrec = slp->firstrec;
 386
 387         if (++slp >= &slaves[SLAVES])
 388                 slp = &slaves[0];
 389
 390         /* Read results back from next slave */
 391         if (slp->sent) {
 392                 if (atomic_read( slp->fd, (char *)&returned, sizeof returned)
 393                     != sizeof returned) {
 394                         perror("  DUMP: error reading command pipe in master");
 395                         dumpabort(0);
 396                 }
 397                 got = returned.unclen;
 398                 bytes_written += returned.clen;
 399                 if (returned.unclen == returned.clen)
 400                         uncomprblks++;
 401                 slp->sent = 0;
 402
 403                 /* Check for errors or end of tape */
 404                 if (got <= 0) {
 405                         /* Check for errors */
 406                         if (got < 0)
 407                                 tperror(-got);
 408                         else
 409                                 msg("End of tape detected\n");
 410
 411                         /*
 412                          * Drain the results, don't care what the values were.
 413                          * If we read them here then trewind won't...
 414                          */
 415                         for (i = 0; i < SLAVES; i++) {
 416                                 if (slaves[i].sent) {
 417                                         if (atomic_read( slaves[i].fd,
 418                                             (char *)&returned, sizeof returned)
 419                                             != sizeof returned) {
 420                                                 perror("  DUMP: error reading command pipe in master");
 421                                                 dumpabort(0);
 422                                         }
 423                                         slaves[i].sent = 0;
 424                                 }
 425                         }
 426
 427                         close_rewind();
 428                         rollforward();
 429                         return;
 430                 }
 431         }
 432
 433         blks = 0;
 434         if (spcl.c_type != TS_END) {
 435                 for (i = 0; i < spcl.c_count; i++)
 436                         if (spcl.c_addr[i] != 0)
 437                                 blks++;
 438         }
 439         slp->count = lastspclrec + blks + 1 - spcl.c_tapea;
 440         slp->tapea = spcl.c_tapea;
 441         slp->firstrec = lastfirstrec + ntrec;
 442         slp->inode = curino;
 443         nextblock = slp->tblock;
 444         trecno = 0;
 445         asize += tenths + returned.clen / density;
 446         csize += returned.clen;
 447         blockswritten += ntrec;
 448         blocksthisvol += ntrec;
 449         if (!pipeout && !unlimited) {
 450                 if (blocksperfile) {
 451                         if ( compressed ? csize >= blocksperfile * 1024
 452                                         : blocksthisvol >= blocksperfile ) {
 453                                 close_rewind();
 454                                 startnewtape(0);
 455                         }
 456                 }
 457                 else if (asize > tsize) {
 458                         close_rewind();
 459                         startnewtape(0);
 460                 }
 461         }
 462         timeest();
 463 }
 464
 465 /*
 466  * Executes the command in a shell.
 467  * Returns -1 if an error occured, the exit status of
 468  * the command on success.
 469  */
 470 int system_command(const char *command, const char *device, int volnum) {
 471         int pid, status;
 472         char commandstr[4096];
 473
 474         pid = fork();
 475         if (pid == -1) {
 476                 perror("  DUMP: unable to fork");
 477                 return -1;
 478         }
 479         if (pid == 0) {
 480                 setuid(getuid());
 481                 setgid(getgid());
 482 #if OLD_STYLE_FSCRIPT
 483                 snprintf(commandstr, sizeof(commandstr), "%s", command);
 484 #else
 485                 snprintf(commandstr, sizeof(commandstr), "%s %s %d", command, device, volnum);
 486 #endif
 487                 commandstr[sizeof(commandstr) - 1] = '\0';
 488                 execl("/bin/sh", "sh", "-c", commandstr, NULL);
 489                 perror("  DUMP: unable to execute shell");
 490                 exit(-1);
 491         }
 492         do {
 493                 if (waitpid(pid, &status, 0) == -1) {
 494                         if (errno != EINTR) {
 495                                 perror("  DUMP: waitpid error");
 496                                 return -1;
 497                         }
 498                 } else {
 499                         if (WIFEXITED(status))
 500                                 return WEXITSTATUS(status);
 501                         else
 502                                 return -1;
 503                 }
 504         } while(1);
 505 }
 506
 507 time_t
 508 trewind(void)
 509 {
 510         int f;
 511         int got;
 512         struct slave_results returned;
 513
 514         for (f = 0; f < SLAVES; f++) {
 515                 /*
 516                  * Drain the results, but unlike EOT we DO (or should) care
 517                  * what the return values were, since if we detect EOT after
 518                  * we think we've written the last blocks to the tape anyway,
 519                  * we have to replay those blocks with rollforward.
 520                  *
 521                  * fixme: punt for now.
 522                  */
 523                 if (slaves[f].sent) {
 524                         if (atomic_read( slaves[f].fd, (char *)&returned, sizeof returned)
 525                             != sizeof returned) {
 526                                 perror("  DUMP: error reading command pipe in master");
 527                                 dumpabort(0);
 528                         }
 529                         got = returned.unclen;
 530                         bytes_written += returned.clen;
 531                         if (returned.unclen == returned.clen)
 532                                 uncomprblks++;
 533                         slaves[f].sent = 0;
 534
 535                         if (got < 0)
 536                                 tperror(-got);
 537
 538                         if (got == 0) {
 539                                 msg("EOT detected in last 2 tape records!\n");
 540                                 msg("Use a longer tape, decrease the size estimate\n");
 541                                 quit("or use no size estimate at all.\n");
 542                         }
 543                 }
 544                 (void) close(slaves[f].fd);
 545         }
 546         while (wait((int *)NULL) >= 0)  /* wait for any signals from slaves */
 547                 /* void */;
 548
 549         if (!pipeout) {
 550
 551                 msg("Closing %s\n", tape);
 552
 553 #ifdef RDUMP
 554                 if (host) {
 555                         rmtclose();
 556                         while (rmtopen(tape, 0) < 0)
 557                                 sleep(10);
 558                         rmtclose();
 559                 }
 560                 else
 561 #endif
 562                 {
 563                         (void) close(tapefd);
 564                         if (!fifoout) {
 565                                 while ((f = OPEN(tape, 0)) < 0)
 566                                         sleep (10);
 567                                 (void) close(f);
 568                         }
 569                 }
 570                 eot_code = 1;
 571                 if (eot_script && spcl.c_type != TS_END) {
 572                         msg("Launching %s\n", eot_script);
 573                         eot_code = system_command(eot_script, tape, tapeno);
 574                 }
 575                 if (eot_code != 0 && eot_code != 1) {
 576                         msg("Dump aborted by the end of tape script\n");
 577                         dumpabort(0);
 578                 }
 579         }
 580         return do_stats();
 581 }
 582
 583
 584 void
 585 close_rewind(void)
 586 {
 587         (void)trewind();
 588         if (nexttape || Mflag || (eot_code == 0) )
 589                 return;
 590         if (!nogripe) {
 591                 msg("Change Volumes: Mount volume #%d\n", tapeno+1);
 592                 broadcast("CHANGE DUMP VOLUMES!\7\7\n");
 593         }
 594         while (!query("Is the new volume mounted and ready to go?"))
 595                 if (query("Do you want to abort?")) {
 596                         dumpabort(0);
 597                         /*NOTREACHED*/
 598                 }
 599 }
 600
 601 void
 602 rollforward(void)
 603 {
 604         register struct req *p, *q, *prev;
 605         register struct slave *tslp;
 606         int i, size, savedtapea, got;
 607         union u_spcl *ntb, *otb;
 608         struct slave_results returned;
 609 #ifdef __linux__
 610         int blks;
 611         long lastfirstrec;
 612 #endif
 613         tslp = &slaves[SLAVES];
 614         ntb = (union u_spcl *)tslp->tblock[1];
 615
 616         /*
 617          * Each of the N slaves should have requests that need to
 618          * be replayed on the next tape.  Use the extra slave buffers
 619          * (slaves[SLAVES]) to construct request lists to be sent to
 620          * each slave in turn.
 621          */
 622         for (i = 0; i < SLAVES; i++) {
 623                 q = &tslp->req[1];
 624                 otb = (union u_spcl *)slp->tblock;
 625
 626                 /*
 627                  * For each request in the current slave, copy it to tslp.
 628                  */
 629
 630                 prev = NULL;
 631                 for (p = slp->req; p->count > 0; p += p->count) {
 632                         *q = *p;
 633                         if (p->dblk == 0)
 634                                 *ntb++ = *otb++; /* copy the datablock also */
 635                         prev = q;
 636                         q += q->count;
 637                 }
 638                 if (prev == NULL)
 639                         quit("rollforward: protocol botch");
 640                 if (prev->dblk != 0)
 641                         prev->count -= 1;
 642                 else
 643                         ntb--;
 644                 q -= 1;
 645                 q->count = 0;
 646                 q = &tslp->req[0];
 647                 if (i == 0) {
 648                         q->dblk = 0;
 649                         q->count = 1;
 650                         trecno = 0;
 651                         nextblock = tslp->tblock;
 652                         savedtapea = spcl.c_tapea;
 653                         spcl.c_tapea = slp->tapea;
 654                         startnewtape(0);
 655                         spcl.c_tapea = savedtapea;
 656                         lastspclrec = savedtapea - 1;
 657                 }
 658                 size = (char *)ntb - (char *)q;
 659                 if (atomic_write( slp->fd, (char *)q, size) != size) {
 660                         perror("  DUMP: error writing command pipe");
 661                         dumpabort(0);
 662                 }
 663                 slp->sent = 1;
 664 #ifdef __linux__
 665                 lastfirstrec = slp->firstrec;
 666 #endif
 667                 if (++slp >= &slaves[SLAVES])
 668                         slp = &slaves[0];
 669
 670                 q->count = 1;
 671
 672                 if (prev->dblk != 0) {
 673                         /*
 674                          * If the last one was a disk block, make the
 675                          * first of this one be the last bit of that disk
 676                          * block...
 677                          */
 678                         q->dblk = prev->dblk +
 679                                 prev->count * (TP_BSIZE / DEV_BSIZE);
 680                         ntb = (union u_spcl *)tslp->tblock;
 681                 } else {
 682                         /*
 683                          * It wasn't a disk block.  Copy the data to its
 684                          * new location in the buffer.
 685                          */
 686                         q->dblk = 0;
 687                         *((union u_spcl *)tslp->tblock) = *ntb;
 688                         ntb = (union u_spcl *)tslp->tblock[1];
 689                 }
 690         }
 691         slp->req[0] = *q;
 692         nextblock = slp->tblock;
 693         if (q->dblk == 0) {
 694 #ifdef __linux__
 695         /* XXX post increment triggers an egcs-1.1.2-12 bug on alpha/sparc */
 696                 *(union u_spcl *)(*nextblock) = *(union u_spcl *)tslp->tblock;
 697 #endif
 698                 nextblock++;
 699         }
 700         trecno = 1;
 701
 702         /*
 703          * Clear the first slaves' response.  One hopes that it
 704          * worked ok, otherwise the tape is much too short!
 705          */
 706         if (slp->sent) {
 707                 if (atomic_read( slp->fd, (char *)&returned, sizeof returned)
 708                     != sizeof returned) {
 709                         perror("  DUMP: error reading command pipe in master");
 710                         dumpabort(0);
 711                 }
 712                 got = returned.unclen;
 713                 bytes_written += returned.clen;
 714                 if (returned.clen == returned.unclen)
 715                         uncomprblks++;
 716                 slp->sent = 0;
 717
 718                 if (got < 0)
 719                         tperror(-got);
 720
 721                 if (got == 0) {
 722                         quit("EOT detected at start of the tape!\n");
 723                 }
 724         }
 725
 726 #ifdef __linux__
 727         blks = 0;
 728         if (spcl.c_type != TS_END) {
 729                 for (i = 0; i < spcl.c_count; i++)
 730                         if (spcl.c_addr[i] != 0)
 731                                 blks++;
 732         }
 733
 734         slp->firstrec = lastfirstrec + ntrec;
 735         slp->count = lastspclrec + blks + 1 - spcl.c_tapea;
 736         slp->inode = curino;
 737         asize += tenths + returned.clen / density;
 738         csize += returned.clen;
 739         blockswritten += ntrec;
 740         blocksthisvol += ntrec;
 741 #endif
 742 }
 743
 744 /*
 745  * We implement taking and restoring checkpoints on the tape level.
 746  * When each tape is opened, a new process is created by forking; this
 747  * saves all of the necessary context in the parent.  The child
 748  * continues the dump; the parent waits around, saving the context.
 749  * If the child returns X_REWRITE, then it had problems writing that tape;
 750  * this causes the parent to fork again, duplicating the context, and
 751  * everything continues as if nothing had happened.
 752  */
 753 void
 754 startnewtape(int top)
 755 {
 756         int     parentpid;
 757         int     childpid;
 758         int     status;
 759         int     waitpid;
 760         char    *p;
 761
 762 #ifdef  __linux__
 763         sigset_t sigs;
 764         sigemptyset(&sigs);
 765         sigaddset(&sigs, SIGINT);
 766         sigprocmask(SIG_BLOCK, &sigs, NULL);
 767 #else   /* __linux__ */
 768 #ifdef sunos
 769         void    (*interrupt_save)();
 770 #else
 771         sig_t   interrupt_save;
 772 #endif
 773         interrupt_save = signal(SIGINT, SIG_IGN);
 774 #endif  /* __linux__ */
 775
 776         parentpid = getpid();
 777         tapea_volume = spcl.c_tapea;
 778         tapea_bytes = bytes_written;
 779         tstart_volume = time(NULL);
 780
 781 restore_check_point:
 782 #ifdef  __linux__
 783         sigprocmask(SIG_UNBLOCK, &sigs, NULL);
 784 #else
 785         (void)signal(SIGINT, interrupt_save);
 786 #endif
 787         /*
 788          *      All signals are inherited...
 789          */
 790         childpid = fork();
 791         if (childpid < 0) {
 792                 msg("Context save fork fails in parent %d\n", parentpid);
 793                 Exit(X_ABORT);
 794         }
 795         if (childpid != 0) {
 796                 /*
 797                  *      PARENT:
 798                  *      save the context by waiting
 799                  *      until the child doing all of the work returns.
 800                  *      don't catch the interrupt
 801                  */
 802 #ifdef  __linux__
 803                 sigprocmask(SIG_BLOCK, &sigs, NULL);
 804 #else
 805                 signal(SIGINT, SIG_IGN);
 806 #endif
 807 #ifdef TDEBUG
 808                 msg("Tape: %d; parent process: %d child process %d\n",
 809                         tapeno+1, parentpid, childpid);
 810 #endif /* TDEBUG */
 811                 while ((waitpid = wait(&status)) != childpid)
 812                         if (waitpid != rshpid)
 813                                 msg("Parent %d waiting for child %d has another child %d return\n",
 814                                 parentpid, childpid, waitpid);
 815                 if (status & 0xFF) {
 816                         msg("Child %d returns LOB status %o\n",
 817                                 childpid, status&0xFF);
 818                 }
 819                 status = (status >> 8) & 0xFF;
 820 #ifdef TDEBUG
 821                 switch(status) {
 822                         case X_FINOK:
 823                                 msg("Child %d finishes X_FINOK\n", childpid);
 824                                 break;
 825                         case X_ABORT:
 826                                 msg("Child %d finishes X_ABORT\n", childpid);
 827                                 break;
 828                         case X_REWRITE:
 829                                 msg("Child %d finishes X_REWRITE\n", childpid);
 830                                 break;
 831                         default:
 832                                 msg("Child %d finishes unknown %d\n",
 833                                         childpid, status);
 834                                 break;
 835                 }
 836 #endif /* TDEBUG */
 837                 switch(status) {
 838                         case X_FINOK:
 839                                 Exit(X_FINOK);
 840                         case X_ABORT:
 841                                 Exit(X_ABORT);
 842                         case X_REWRITE:
 843                                 goto restore_check_point;
 844                         default:
 845                                 msg("Bad return code from dump: %d\n", status);
 846                                 Exit(X_ABORT);
 847                 }
 848                 /*NOTREACHED*/
 849         } else {        /* we are the child; just continue */
 850 #ifdef TDEBUG
 851                 sleep(4);       /* allow time for parent's message to get out */
 852                 msg("Child on Tape %d has parent %d, my pid = %d\n",
 853                         tapeno+1, parentpid, getpid());
 854 #endif /* TDEBUG */
 855                 /*
 856                  * If we have a name like "/dev/rmt0,/dev/rmt1",
 857                  * use the name before the comma first, and save
 858                  * the remaining names for subsequent volumes.
 859                  */
 860                 tapeno++;               /* current tape sequence */
 861                 if (Mflag) {
 862                         snprintf(tape, MAXPATHLEN, "%s%03d", tapeprefix, tapeno);
 863                         tape[MAXPATHLEN - 1] = '\0';
 864                         msg("Dumping volume %d on %s\n", tapeno, tape);
 865                 }
 866                 else if (nexttape || strchr(tapeprefix, ',')) {
 867                         if (nexttape && *nexttape)
 868                                 tapeprefix = nexttape;
 869                         if ((p = strchr(tapeprefix, ',')) != NULL) {
 870                                 *p = '\0';
 871                                 nexttape = p + 1;
 872                         } else
 873                                 nexttape = NULL;
 874                         strncpy(tape, tapeprefix, MAXPATHLEN);
 875                         tape[MAXPATHLEN - 1] = '\0';
 876                         msg("Dumping volume %d on %s\n", tapeno, tape);
 877                 }
 878 #ifdef RDUMP
 879                 while ((tapefd = (host ? rmtopen(tape, 2) : pipeout ?
 880                         fileno(stdout) :
 881                         OPEN(tape, O_WRONLY|O_CREAT, 0666))) < 0)
 882 #else
 883                 while ((tapefd = (pipeout ? fileno(stdout) :
 884                                   OPEN(tape, O_RDWR|O_CREAT, 0666))) < 0)
 885 #endif
 886                     {
 887                         msg("Cannot open output \"%s\".\n", tape);
 888                         if (!query("Do you want to retry the open?"))
 889                                 dumpabort(0);
 890                 }
 891
 892                 enslave();  /* Share open tape file descriptor with slaves */
 893
 894                 asize = 0;
 895                 csize = 0;
 896                 blocksthisvol = 0;
 897                 if (top)
 898                         newtape++;              /* new tape signal */
 899                 spcl.c_count = slp->count;
 900                 /*
 901                  * measure firstrec in TP_BSIZE units since restore doesn't
 902                  * know the correct ntrec value...
 903                  */
 904                 spcl.c_firstrec = slp->firstrec;
 905                 spcl.c_volume++;
 906                 spcl.c_type = TS_TAPE;
 907                 spcl.c_flags |= DR_NEWHEADER;
 908                 spcl.c_ntrec = ntrec;
 909                 if (compressed)
 910                         spcl.c_flags |= DR_COMPRESSED;
 911                 writeheader((dump_ino_t)slp->inode);
 912                 spcl.c_flags &=~ DR_NEWHEADER;
 913                 msg("Volume %d started with block %ld at: %s", tapeno,
 914                     spcl.c_tapea, ctime(&tstart_volume));
 915                 if (tapeno > 1)
 916                         msg("Volume %d begins with blocks from inode %d\n",
 917                                 tapeno, slp->inode);
 918         }
 919 }
 920
 921 void
 922 dumpabort(int signo)
 923 {
 924
 925         if (master != 0 && master != getpid())
 926                 /* Signals master to call dumpabort */
 927                 (void) kill(master, SIGTERM);
 928         else {
 929                 killall();
 930                 msg("The ENTIRE dump is aborted.\n");
 931         }
 932 #ifdef RDUMP
 933         rmtclose();
 934 #endif
 935         Exit(X_ABORT);
 936 }
 937
 938 void
 939 Exit(int status)
 940 {
 941
 942 #ifdef TDEBUG
 943         msg("pid = %d exits with status %d\n", getpid(), status);
 944 #endif /* TDEBUG */
 945         exit(status);
 946 }
 947
 948 /*
 949  * proceed - handler for SIGUSR2, used to synchronize IO between the slaves.
 950  */
 951 static void
 952 proceed(int signo)
 953 {
 954         if (ready)
 955                 siglongjmp(jmpbuf, 1);
 956         caught++;
 957 }
 958
 959 void
 960 enslave(void)
 961 {
 962         int cmd[2];
 963 #ifdef  LINUX_FORK_BUG
 964         int i, j;
 965 #else
 966         register int i, j;
 967 #endif
 968
 969         master = getpid();
 970
 971     {   struct sigaction sa;
 972         memset(&sa, 0, sizeof sa);
 973         sigemptyset(&sa.sa_mask);
 974         sa.sa_handler = dumpabort;
 975         sigaction(SIGTERM, &sa, NULL); /* Slave sends SIGTERM on dumpabort() */
 976         sa.sa_handler = sigpipe;
 977         sigaction(SIGPIPE, &sa, NULL);
 978         sa.sa_handler = proceed;
 979         sa.sa_flags = SA_RESTART;
 980         sigaction(SIGUSR2, &sa, NULL); /* Slave sends SIGUSR2 to next slave */
 981    }
 982
 983         for (i = 0; i < SLAVES; i++) {
 984                 if (i == slp - &slaves[0]) {
 985                         caught = 1;
 986                 } else {
 987                         caught = 0;
 988                 }
 989
 990                 if (socketpair(AF_UNIX, SOCK_STREAM, 0, cmd) < 0 ||
 991                     (slaves[i].pid = fork()) < 0)
 992                         quit("too many slaves, %d (recompile smaller): %s\n",
 993                             i, strerror(errno));
 994
 995                 slaves[i].fd = cmd[1];
 996                 slaves[i].sent = 0;
 997                 if (slaves[i].pid == 0) {           /* Slave starts up here */
 998                         sigset_t sigs;
 999                         for (j = 0; j <= i; j++)
1000                                 (void) close(slaves[j].fd);
1001                         sigemptyset(&sigs);
1002                         sigaddset(&sigs, SIGINT);  /* Master handles this */
1003 #if defined(SIGINFO)
1004                         sigaddset(&sigs, SIGINFO);
1005 #endif
1006                         sigprocmask(SIG_BLOCK, &sigs, NULL);
1007
1008 #ifdef  LINUX_FORK_BUG
1009                         if (atomic_write( cmd[0], (char *) &i, sizeof i)
1010                             != sizeof i)
1011                                 quit("master/slave protocol botched 3\n");
1012 #endif
1013                         doslave(cmd[0], i);
1014                         Exit(X_FINOK);
1015                 }
1016                 else
1017                         close(cmd[0]);
1018         }
1019
1020 #ifdef  LINUX_FORK_BUG
1021         /*
1022          * Wait for all slaves to _actually_ start to circumvent a bug in
1023          * Linux kernels >= 2.1.3 where a signal sent to a child that hasn't
1024          * returned from fork() causes a SEGV in the child process
1025          */
1026         for (i = 0; i < SLAVES; i++)
1027                 if (atomic_read( slaves[i].fd, (char *) &j, sizeof j) != sizeof j)
1028                         quit("master/slave protocol botched 4\n");
1029 #endif
1030
1031         for (i = 0; i < SLAVES; i++)
1032                 (void) atomic_write( slaves[i].fd,
1033                               (char *) &slaves[(i + 1) % SLAVES].pid,
1034                               sizeof slaves[0].pid);
1035
1036         master = 0;
1037 }
1038
1039 void
1040 killall(void)
1041 {
1042         register int i;
1043
1044         for (i = 0; i < SLAVES; i++)
1045                 if (slaves[i].pid > 0) {
1046                         (void) kill(slaves[i].pid, SIGKILL);
1047                         slaves[i].sent = 0;
1048                 }
1049 }
1050
1051 /*
1052  * Synchronization - each process waits for a SIGUSR2 from the
1053  * previous process before writing to the tape, and sends SIGUSR2
1054  * to the next process when the tape write completes. On tape errors
1055  * a SIGUSR1 is sent to the master which then terminates all of the
1056  * slaves.
1057  */
1058 static void
1059 doslave(int cmd, int slave_number)
1060 {
1061         register int nread;
1062         int nextslave, size, eot_count, bufsize;
1063         volatile int wrote = 0;
1064         char *buffer;
1065 #ifdef HAVE_ZLIB
1066         struct tapebuf *comp_buf = NULL;
1067         int compresult, do_compress = slave_number > 0;
1068         unsigned long worklen;
1069 #endif /* HAVE_ZLIB */
1070         struct slave_results returns;
1071 #ifdef  __linux__
1072         errcode_t retval;
1073 #endif
1074 #ifdef USE_QFA
1075         long curtapepos;
1076         union u_spcl *uspclptr;
1077         struct s_spcl *spclptr;
1078 #endif /* USE_QFA */
1079
1080         /*
1081          * Need our own seek pointer.
1082          */
1083         (void) close(diskfd);
1084         if ((diskfd = OPEN(disk, O_RDONLY)) < 0)
1085                 quit("slave couldn't reopen disk: %s\n", strerror(errno));
1086 #ifdef  __linux__
1087         ext2fs_close(fs);
1088         retval = dump_fs_open(disk, &fs);
1089         if (retval)
1090                 quit("slave couldn't reopen disk: %s\n", error_message(retval));
1091 #endif  /* __linux__ */
1092
1093         /*
1094          * Need the pid of the next slave in the loop...
1095          */
1096         if ((nread = atomic_read( cmd, (char *)&nextslave, sizeof nextslave))
1097             != sizeof nextslave) {
1098                 quit("master/slave protocol botched - didn't get pid of next slave.\n");
1099         }
1100
1101 #ifdef HAVE_ZLIB
1102         /* if we're doing a compressed dump, allocate the compress buffer */
1103         if (compressed) {
1104                 comp_buf = malloc(sizeof(struct tapebuf) + TP_BSIZE + writesize);
1105                 if (comp_buf == NULL)
1106                         quit("couldn't allocate a compress buffer.\n");
1107                 comp_buf->flags = 0;
1108         }
1109 #endif /* HAVE_ZLIB */
1110
1111         /*
1112          * Get list of blocks to dump, read the blocks into tape buffer
1113          */
1114         while ((nread = atomic_read( cmd, (char *)slp->req, reqsiz)) == reqsiz) {
1115                 register struct req *p = slp->req;
1116
1117                 for (trecno = 0; trecno < ntrec;
1118                      trecno += p->count, p += p->count) {
1119                         if (p->dblk) {  /* read a disk block */
1120                                 bread(p->dblk, slp->tblock[trecno],
1121                                         p->count * TP_BSIZE);
1122                         } else {        /* read record from pipe */
1123                                 if (p->count != 1 || atomic_read( cmd,
1124                                     (char *)slp->tblock[trecno],
1125                                     TP_BSIZE) != TP_BSIZE)
1126                                        quit("master/slave protocol botched.\n");
1127                         }
1128                 }
1129
1130                 /* Try to write the data... */
1131                 wrote = 0;
1132                 eot_count = 0;
1133                 size = 0;
1134                 buffer = (char *) slp->tblock[0];       /* set write pointer */
1135                 bufsize = writesize;                    /* length to write */
1136                 returns.clen = returns.unclen = bufsize;
1137
1138 #ifdef HAVE_ZLIB
1139                 /*
1140                  * When writing a compressed dump, each block except
1141                  * the first one on each tape is written
1142                  * from struct tapebuf with an 4 byte prefix
1143                  * followed by the data. This can be less than
1144                  * writesize. Restore, on a short read, can compare the
1145                  * length read to the compressed length in the header
1146                  * to verify that the read was good. Blocks which don't
1147                  * compress well are written uncompressed.
1148                  * The first block written by each slave is not compressed
1149                  * and does not have a prefix.
1150                  */
1151
1152                 if (compressed && do_compress) {
1153                         comp_buf->length = bufsize;
1154                         worklen = TP_BSIZE + writesize;
1155                         compresult = compress2(comp_buf->buf, &worklen,
1156                                 (char *)slp->tblock[0], writesize, compressed);
1157                         if (compresult == Z_OK && worklen <= (writesize - 16)) {
1158                                 /* write the compressed buffer */
1159                                 comp_buf->length = worklen;
1160                                 comp_buf->compressed = 1;
1161                                 buffer = (char *) comp_buf;
1162                                 returns.clen = bufsize = worklen + sizeof(struct tapebuf);
1163                         }
1164                         else {
1165                                 /* write the data uncompressed */
1166                                 comp_buf->length = writesize;
1167                                 comp_buf->compressed = 0;
1168                                 buffer = (char *) comp_buf;
1169                                 returns.clen = bufsize = writesize + sizeof(struct tapebuf);
1170                                 returns.unclen = returns.clen;
1171                                 memcpy(comp_buf->buf, (char *)slp->tblock[0], writesize);
1172                         }
1173                 }
1174                 /* compress the remaining blocks if we're compressing */
1175                 do_compress = compressed;
1176 #endif /* HAVE_ZLIB */
1177
1178                 if (sigsetjmp(jmpbuf, 1) == 0) {
1179                         ready = 1;
1180                         if (!caught)
1181                                 (void) pause();
1182                 }
1183                 ready = 0;
1184                 caught = 0;
1185
1186 #ifdef USE_QFA
1187                 if (gTapeposfd >= 0) {
1188                         uspclptr = (union u_spcl *)&slp->tblock[0];
1189                         spclptr = &uspclptr->s_spcl;
1190                         if ((spclptr->c_magic == NFS_MAGIC) &&
1191                             (spclptr->c_type == TS_INODE)) {
1192                                 /* if an error occured previously don't
1193                                  * try again */
1194                                 if (gtperr == 0) {
1195                                         if ((gtperr = GetTapePos(&curtapepos)) == 0) {
1196 #ifdef DEBUG_QFA
1197                                                 msg("inode %ld at tapepos %ld\n", spclptr->c_inumber, curtapepos);
1198 #endif
1199                                                 sprintf(gTps, "%ld\t%d\t%ld\n", (unsigned long)spclptr->c_inumber, tapeno, curtapepos);
1200                                                 if (write(gTapeposfd, gTps, strlen(gTps)) != strlen(gTps)) {
1201                                                         warn("error writing tapepos file.\n");
1202                                                 }
1203                                         }
1204                                 }
1205                         }
1206                 }
1207 #endif /* USE_QFA */
1208
1209                 while (eot_count < 10 && size < bufsize) {
1210 #ifdef RDUMP
1211                         if (host)
1212                                 wrote = rmtwrite(buffer + size, bufsize - size);
1213                         else
1214 #endif
1215                                 wrote = write(tapefd, buffer + size, bufsize - size);
1216 #ifdef WRITEDEBUG
1217                         printf("slave %d wrote %d\n", slave_number, wrote);
1218 #endif
1219                         if (wrote < 0)
1220                                 break;
1221                         if (wrote == 0)
1222                                 eot_count++;
1223                         size += wrote;
1224                 }
1225
1226 #ifdef WRITEDEBUG
1227                 if (size != bufsize)
1228                  printf("slave %d only wrote %d out of %d bytes and gave up.\n",
1229                      slave_number, size, bufsize);
1230 #endif
1231
1232                 /*
1233                  * Handle ENOSPC as an EOT condition.
1234                  */
1235                 if (wrote < 0 && errno == ENOSPC) {
1236                         wrote = 0;
1237                         eot_count++;
1238                 }
1239
1240                 if (eot_count > 0)
1241                         returns.clen = returns.unclen = 0;
1242
1243                 /*
1244                  * pass errno back to master for special handling
1245                  */
1246                 if (wrote < 0)
1247                         returns.unclen = -errno;
1248
1249                 /*
1250                  * pass size of data and size of write back to master
1251                  * (for EOT handling)
1252                  */
1253                 (void) atomic_write( cmd, (char *)&returns, sizeof returns);
1254
1255                 /*
1256                  * Signal the next slave to go.
1257                  */
1258                 (void) kill(nextslave, SIGUSR2);
1259         }
1260         if (nread != 0)
1261                 quit("error reading command pipe: %s\n", strerror(errno));
1262 }
1263
1264 /*
1265  * Since a read from a pipe may not return all we asked for,
1266  * or a write may not write all we ask if we get a signal,
1267  * loop until the count is satisfied (or error).
1268  */
1269 static ssize_t
1270 atomic_read(int fd, void *buf, size_t count)
1271 {
1272         int got, need = count;
1273
1274         do {
1275                 while ((got = read(fd, buf, need)) > 0 && (need -= got) > 0)
1276                         (char *)buf += got;
1277         } while (got == -1 && errno == EINTR);
1278         return (got < 0 ? got : count - need);
1279 }
1280
1281 /*
1282  * Since a read from a pipe may not return all we asked for,
1283  * or a write may not write all we ask if we get a signal,
1284  * loop until the count is satisfied (or error).
1285  */
1286 static ssize_t
1287 atomic_write(int fd, const void *buf, size_t count)
1288 {
1289         int got, need = count;
1290
1291         do {
1292                 while ((got = write(fd, buf, need)) > 0 && (need -= got) > 0)
1293                         (char *)buf += got;
1294         } while (got == -1 && errno == EINTR);
1295         return (got < 0 ? got : count - need);
1296 }
1297
1298
1299 #ifdef USE_QFA
1300 /*
1301  * read the current tape position
1302  */
1303 int
1304 GetTapePos(long *pos)
1305 {
1306         int err = 0;
1307
1308         *pos = 0;
1309         if (ioctl(tapefd, MTIOCPOS, pos) == -1) {
1310                 err = errno;
1311                 msg("[%ld] error: %d (getting tapepos: %ld)\n", getpid(),
1312                         err, *pos);
1313                 return err;
1314         }
1315         return err;
1316 }
1317 #endif /* USE_QFA */