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