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