abolish ino32_t

[unleashed.git] / usr / src / cmd / backup / dump / dumptape.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
/*        All Rights Reserved   */

/*
 * Portions of this source code were derived from Berkeley 4.3 BSD
 * under license from the Regents of the University of California.
 */

#include "dump.h"
#include <setjmp.h>
#include <sys/fdio.h>
#include <sys/mtio.h>
#include <sys/mkdev.h>
#include <assert.h>
#include <limits.h>

#define SLEEPMS         50

static uint_t writesize;        /* size of malloc()ed buffer for tape */
static ino_t inos[TP_NINOS];    /* starting inodes on each tape */

/*
 * The req structure is used to pass commands from the parent
 * process through the pipes to the slave processes.  It comes
 * in two flavors, depending on which mode dump is operating under:
 * an inode request (on-line mode) and a disk block request ("old" mode).
 */
/*
 * The inode request structure is used during on-line mode.
 * The master passes inode numbers and starting offsets to
 * the slaves.  The tape writer passes out the current inode,
 * offset, and number of tape records written after completing a volume.
 */
struct ireq {
        ino_t   inumber;        /* inode number to open/dump */
        long    igen;           /* inode generation number */
        off_t   offset;         /* starting offset in inode */
        int     count;          /* count for 1st spclrec */
};
/*
 * The block request structure is used in off-line mode to pass
 * commands to dump disk blocks from the parent process through
 * the pipes to the slave processes.
 */
struct breq {
        diskaddr_t dblk;                /* disk address to read */
        size_t  size;           /* number of bytes to read from disk */
        ulong_t spclrec[1];     /* actually longer */
};

struct req {
        short   aflag;          /* write data to archive process as well */
        short   tflag;          /* begin new tape */
        union   reqdata {
                struct ireq ino;        /* used for on-line mode */
                struct breq blks;       /* used for off-line mode */
        } data;
};

#define ir_inumber      data.ino.inumber
#define ir_igen         data.ino.igen
#define ir_offset       data.ino.offset
#define ir_count        data.ino.count

#define br_dblk         data.blks.dblk
#define br_size         data.blks.size
#define br_spcl         data.blks.spclrec

static int reqsiz = 0;  /* alloctape will initialize */

#define SLAVES 3
struct slaves {
        int     sl_slavefd;     /* pipe from master to slave */
        pid_t   sl_slavepid;    /* slave pid; used by killall() */
        ino_t   sl_inos;        /* inos, if this record starts tape */
        int     sl_offset;      /* logical blocks written for object */
        int     sl_count;       /* logical blocks left in spclrec */
        int     sl_tapea;       /* header number, if starting tape */
        int     sl_firstrec;    /* number of first block on tape */
        int     sl_state;       /* dump output state */
        struct  req *sl_req;    /* instruction packet to slave */
};
static struct slaves slaves[SLAVES];    /* one per slave */
static struct slaves *slp;      /* pointer to current slave */
static struct slaves chkpt;     /* checkpointed data */

struct bdesc {
        char    *b_data;        /* pointer to buffer data */
        int     b_flags;        /* flags (see below) */
};

/*
 * The following variables are in shared memory, and must be
 * explicitly checkpointed and/or reset.
 */
static caddr_t shared;          /* pointer to block of shared memory */
static struct bdesc *bufp;      /* buffer descriptors */
static struct bdesc **current;  /* output buffer to fill */
static int *tapea;              /* logical record count */

#ifdef INSTRUMENT
static int      *readmissp;     /* number of times writer was idle */
static int      *idle;          /* number of times slaves were idle */
#endif  /* INSTRUMENT */

/*
 * Buffer flags
 */
#define BUF_EMPTY       0x0     /* nothing in buffer */
#define BUF_FULL        0x1     /* data in buffer */
#define BUF_SPCLREC     0x2     /* contains special record */
#define BUF_ARCHIVE     0x4     /* dump to archive */

static int recsout;             /* number of req's sent to slaves */
static int totalrecsout;        /* total number of req's sent to slaves */
static int rotor;               /* next slave to be instructed */
static pid_t master;            /* pid of master, for sending error signals */
static int writer = -1;         /* fd of tape writer */
static pid_t writepid;          /* pid of tape writer */
static int arch;                /* fd of output archiver */
static pid_t archivepid;        /* pid of output archiver */
static int archivefd;           /* fd of archive file (proper) */
static offset_t lf_archoffset;  /* checkpointed offset into archive file */

int caught;                     /* caught signal -- imported by mapfile() */

#ifdef DEBUG
extern  int xflag;
#endif

#ifdef __STDC__
static void cmdwrterr(void);
static void cmdrderr(void);
static void freetape(void);
static void bufclear(void);
static pid_t setuparchive(void);
static pid_t setupwriter(void);
static void nextslave(void);
static void tperror(int);
static void rollforward(int);
static void nap(int);
static void alrm(int);
static void just_rewind(void);
static void killall(void);
static void proceed(int);
static void die(int);
static void enslave(void);
static void wait_our_turn(void);
static void dumpoffline(int, pid_t, int);
static void onxfsz(int);
static void dowrite(int);
static void checkpoint(struct bdesc *, int);
static ssize_t atomic(int (*)(), int, char *, int);
#else
static void cmdwrterr();
static void cmdrderr();
static void freetape();
static void bufclear();
static pid_t setuparchive();
static pid_t setupwriter();
static void nextslave();
static void tperror();
static void rollforward();
static void nap();
static void alrm();
static void just_rewind();
static void killall();
static void proceed();
static void die();
static void enslave();
static void wait_our_turn();
static void dumpoffline();
static void onxfsz();
static void dowrite();
static void checkpoint();
static ssize_t atomic();
#endif

static size_t tapesize;

/*
 * Allocate buffers and shared memory variables.  Tape buffers are
 * allocated on page boundaries for tape write() efficiency.
 */
void
#ifdef __STDC__
#else
#endif
alloctape(void)
{
        struct slaves *slavep;
        ulong_t pgoff = (unsigned)(getpagesize() - 1); /* 2**n - 1 */
        int     mapfd;
        char    *obuf;
        int     saverr;
        int     i, j;

        writesize = ntrec * tp_bsize;
        if (!printsize)
                msg(gettext("Writing %d Kilobyte records\n"),
                        writesize / TP_BSIZE_MIN);

        /*
         * set up shared memory seg for here and child
         */
        mapfd = open("/dev/zero", O_RDWR);
        if (mapfd == -1) {
                saverr = errno;
                msg(gettext("Cannot open `%s': %s\n"),
                        "/dev/zero", strerror(saverr));
                dumpabort();
                /*NOTREACHED*/
        }
        /*
         * Allocate space such that buffers are page-aligned and
         * pointers are aligned on 4-byte boundaries (for SPARC).
         * This code assumes that (NBUF * writesize) is a multiple
         * of the page size and that pages are aligned on 4-byte
         * boundaries.  Space is allocated as follows:
         *
         *    (NBUF * writesize) for the actual buffers
         *    (pagesize - 1) for padding so the buffers are page-aligned
         *    (NBUF * ntrec * sizeof (struct bdesc)) for each buffer
         *    (n * sizeof (int)) for [n] debugging variables/pointers
         *    (n * sizeof (int)) for [n] miscellaneous variables/pointers
         */
        tapesize =
            (NBUF * writesize)                          /* output buffers */
                /* LINTED: pgoff fits into a size_t */
            + (size_t)pgoff                             /* page alignment */
                                                        /* buffer descriptors */
            + (((size_t)sizeof (struct bdesc)) * NBUF * ntrec)
#ifdef INSTRUMENT
            + (2 * (size_t)sizeof (int *))              /* instrumentation */
#endif
                                                        /* shared variables */
            + (size_t)sizeof (struct bdesc **)
            + (size_t)sizeof (int *)
            + (3 * (size_t)sizeof (time_t));

        shared = mmap(NULL, tapesize, PROT_READ|PROT_WRITE,
            MAP_SHARED, mapfd, (off_t)0);
        if (shared == (caddr_t)-1) {
                saverr = errno;
                msg(gettext("Cannot memory map output buffers: %s\n"),
                    strerror(saverr));
                dumpabort();
                /*NOTREACHED*/
        }
        (void) close(mapfd);

        /*
         * Buffers and buffer headers
         */
        obuf = (char *)(((ulong_t)shared + pgoff) & ~pgoff);
        /* LINTED obuf and writesize are aligned */
        bufp = (struct bdesc *)(obuf + NBUF*writesize);
        /*
         * Shared memory variables
         */
        current = (struct bdesc **)&bufp[NBUF*ntrec];
        tapea = (int *)(current + 1);
        /* LINTED pointer alignment ok */
        telapsed = (time_t *)(tapea + 1);
        tstart_writing = telapsed + 1;
        tschedule = tstart_writing + 1;
#ifdef INSTRUMENT
        /*
         * Debugging and instrumentation variables
         */
        readmissp = (int *)(tschedule + 1);
        idle = readmissp + 1;
#endif
        for (i = 0, j = 0; i < NBUF * ntrec; i++, j += tp_bsize) {
                bufp[i].b_data = &obuf[j];
        }

        reqsiz = sizeof (struct req) + tp_bsize - sizeof (long);
        for (slavep = slaves; slavep < &slaves[SLAVES]; slavep++)
                slavep->sl_req = (struct req *)xmalloc(reqsiz);

        chkpt.sl_offset = 0;            /* start at offset 0 */
        chkpt.sl_count = 0;
        chkpt.sl_inos = UFSROOTINO;     /* in root inode */
        chkpt.sl_firstrec = 1;
        chkpt.sl_tapea = 0;
}

static void
#ifdef __STDC__
freetape(void)
#else
freetape()
#endif
{
        if (shared == NULL)
                return;
        (void) timeclock((time_t)0);
        (void) munmap(shared, tapesize);
        shared = NULL;
}

/*
 * Reset tape state variables -- called
 * before a pass to dump active files.
 */
void
#ifdef __STDC__
reset(void)
#else
reset()
#endif
{
        bufclear();

#ifdef INSTRUMENT
        (*readmissp) = 0;
        (*idle) = 0;
#endif

        spcl.c_flags = 0;
        spcl.c_volume = 0;
        tapeno = 0;

        chkpt.sl_offset = 0;            /* start at offset 0 */
        chkpt.sl_count = 0;
        chkpt.sl_inos = UFSROOTINO;     /* in root inode */
        chkpt.sl_firstrec = 1;
        chkpt.sl_tapea = 0;
}

static void
#ifdef __STDC__
bufclear(void)
#else
bufclear()
#endif
{
        struct bdesc *bp;
        int i;

        for (i = 0, bp = bufp; i < NBUF * ntrec; i++, bp++)
                bp->b_flags = BUF_EMPTY;
        if ((caddr_t)current < shared ||
            (caddr_t)current > (shared + tapesize)) {
                msg(gettext(
            "bufclear: current pointer out of range of shared memory\n"));
                dumpabort();
                /*NOTREACHED*/
        }
        if ((*current != NULL) &&
            (*current < &bufp[0] || *current > &bufp[NBUF*ntrec])) {
                /* ANSI string catenation, to shut cstyle up */
                msg(gettext("bufclear: current buffer pointer (0x%x) "
                        "out of range of buffer\naddresses (0x%x - 0x%x)\n"),
                    *current, &bufp[0], &bufp[NBUF*ntrec]);
                dumpabort();
                /*NOTREACHED*/
        }
        *current = bufp;
}

/*
 * Start a process to collect information describing the dump.
 * This data takes two forms:
 *    the bitmap and directory information being written to
 *      the front of the tape (the "archive" file)
 *    information describing each directory and inode (to
 *      be included in the database tmp file)
 * Write the data to the files as it is received so huge file
 * systems don't cause dump to consume large amounts of memory.
 */
static pid_t
setuparchive(void)
{
        struct slaves *slavep;
        int cmd[2];
        pid_t pid;
        ssize_t size;
        char *data;
        char *errmsg;
        int flags, saverr;
        int punt = 0;

        /*
         * Both the archive and database tmp files are
         * checkpointed by taking their current offsets
         * (sizes) after completing each volume.  Restoring
         * from a checkpoint involves truncating to the
         * checkpointed size.
         */
        if (archive && !doingactive) {
                /* It's allowed/expected to exist, so can't use O_EXCL */
                archivefd = safe_file_open(archivefile, O_WRONLY, 0600);
                if (archivefd < 0) {
                        saverr = errno;
                        msg(gettext("Cannot open archive file `%s': %s\n"),
                            archivefile, strerror(saverr));
                        dumpabort();
                        /*NOTREACHED*/
                }

                archive_opened = 1;

                if (lseek64(archivefd, lf_archoffset, 0) < 0) {
                        saverr = errno;
                        msg(gettext(
                                    "Cannot position archive file `%s' : %s\n"),
                            archivefile, strerror(saverr));
                        dumpabort();
                        /*NOTREACHED*/
                }
                if (ftruncate64(archivefd, lf_archoffset) < 0) {
                        saverr = errno;
                        msg(gettext(
                                    "Cannot truncate archive file `%s' : %s\n"),
                            archivefile, strerror(saverr));
                        dumpabort();
                        /*NOTREACHED*/
                }
        }

        if (pipe(cmd) < 0) {
                saverr = errno;
                msg(gettext("%s: %s error: %s\n"),
                    "setuparchive", "pipe", strerror(saverr));
                return (0);
        }
        sighold(SIGINT);
        if ((pid = fork()) < 0) {
                saverr = errno;
                msg(gettext("%s: %s error: %s\n"),
                    "setuparchive", "fork", strerror(saverr));
                return (0);
        }
        if (pid > 0) {
                sigrelse(SIGINT);
                /* parent process */
                (void) close(cmd[0]);
                arch = cmd[1];
                return (pid);
        }
        /*
         * child process
         */
        (void) signal(SIGINT, SIG_IGN);         /* master handles this */
#ifdef TDEBUG
        (void) sleep(4);        /* allow time for parent's message to get out */
        /* XGETTEXT:  #ifdef TDEBUG only */
        msg(gettext("Archiver has pid = %ld\n"), (long)getpid());
#endif
        freeino();      /* release unneeded resources */
        freetape();
        for (slavep = &slaves[0]; slavep < &slaves[SLAVES]; slavep++) {
                if (slavep->sl_slavefd != -1) {
                        (void) close(slavep->sl_slavefd);
                        slavep->sl_slavefd = -1;
                }
        }
        (void) close(to);
        (void) close(fi);
        to = fi = -1;
        (void) close(cmd[1]);
        data = xmalloc(tp_bsize);
        for (;;) {
                size = atomic((int(*)())read, cmd[0], (char *)&flags,
                    sizeof (flags));
                if ((unsigned)size != sizeof (flags))
                        break;
                size = atomic((int(*)())read, cmd[0], data, tp_bsize);
                if (size == tp_bsize) {
                        if (archive && flags & BUF_ARCHIVE && !punt &&
                            (size = write(archivefd, data, tp_bsize))
                            != tp_bsize) {
                                struct stat64 stats;

                                if (size != -1) {
                                        errmsg = strdup(gettext(
                                            "Output truncated"));
                                        if (errmsg == NULL)
                                                errmsg = "";
                                } else {
                                        errmsg = strerror(errno);
                                }

                                if (fstat64(archivefd, &stats) < 0)
                                    stats.st_size = -1;

                                /* cast to keep lint&printf happy */
                                msg(gettext(
                    "Cannot write archive file `%s' at offset %lld: %s\n"),
                                    archivefile, (longlong_t)stats.st_size,
                                    errmsg);
                                msg(gettext(
                    "Archive file will be deleted, dump will continue\n"));
                                punt++;
                                if ((size != -1) && (*errmsg != '\0')) {
                                        free(errmsg);
                                }
                        }
                } else {
                        break;
                }
        }
        (void) close(cmd[0]);
        if (archive) {
                (void) close(archivefd);
                archivefd = -1;
        }
        if (punt) {
                (void) unlink(archivefile);
                Exit(X_ABORT);
        }
        Exit(X_FINOK);
        /* NOTREACHED */
        return (0);
}

/*
 * Start a process to read the output buffers and write the data
 * to the output device.
 */
static pid_t
setupwriter(void)
{
        struct slaves *slavep;
        int cmd[2];
        pid_t pid;
        int saverr;

        caught = 0;
        if (pipe(cmd) < 0) {
                saverr = errno;
                msg(gettext("%s: %s error: %s\n"),
                        "setupwriter", "pipe", strerror(saverr));
                return (0);
        }
        sighold(SIGINT);
        if ((pid = fork()) < 0) {
                saverr = errno;
                msg(gettext("%s: %s error: %s\n"),
                        "setupwriter", "fork", strerror(saverr));
                return (0);
        }
        if (pid > 0) {
                /*
                 * Parent process
                 */
                sigrelse(SIGINT);
                (void) close(cmd[0]);
                writer = cmd[1];
                return (pid);
        }
        /*
         * Child (writer) process
         */
        (void) signal(SIGINT, SIG_IGN);         /* master handles this */
#ifdef TDEBUG
        (void) sleep(4);        /* allow time for parent's message to get out */
        /* XGETTEXT:  #ifdef TDEBUG only */
        msg(gettext("Writer has pid = %ld\n"), (long)getpid());
#endif
        child_chdir();
        freeino();      /* release unneeded resources */
        for (slavep = &slaves[0]; slavep < &slaves[SLAVES]; slavep++) {
                if (slavep->sl_slavefd != -1) {
                        (void) close(slavep->sl_slavefd);
                        slavep->sl_slavefd = -1;
                }
        }
        (void) close(fi);
        fi = -1;
        (void) close(cmd[1]);
        dowrite(cmd[0]);
        if (arch >= 0) {
                (void) close(arch);
                arch = -1;
        }
        (void) close(cmd[0]);
        Exit(X_FINOK);
        /* NOTREACHED */
        return (0);
}

void
#ifdef __STDC__
spclrec(void)
#else
spclrec()
#endif
{
        int s, i;
        int32_t *ip;
        int flags = BUF_SPCLREC;

        if ((BIT(ino, shamap)) && (spcl.c_type == TS_INODE)) {
                spcl.c_type = TS_ADDR;
                /* LINTED: result fits in a short */
                spcl.c_dinode.di_mode &= ~S_IFMT;
                /* LINTED: result fits in a short */
                spcl.c_dinode.di_mode |= IFSHAD;
        }

        /*
         * Only TS_INODEs should have short metadata, if this
         * isn't such a spclrec, clear the metadata flag and
         * the c_shadow contents.
         */
        if (!(spcl.c_type == TS_INODE && (spcl.c_flags & DR_HASMETA))) {
                spcl.c_flags &= ~DR_HASMETA;
                bcopy(c_shadow_save, &(spcl.c_shadow),
                    sizeof (spcl.c_shadow));
        }

        if (spcl.c_type == TS_END) {
                spcl.c_count = 1;
                spcl.c_flags |= DR_INODEINFO;
                bcopy((char *)inos, (char *)spcl.c_inos, sizeof (inos));
        } else if (spcl.c_type == TS_TAPE) {
                spcl.c_flags |= DR_NEWHEADER;
                if (doingactive)
                        spcl.c_flags |= DR_REDUMP;
        } else if (spcl.c_type != TS_INODE)
                flags = BUF_SPCLREC;
        spcl.c_tapea = *tapea;
        /* LINTED for now, max inode # is 2**31 (ufs max size is 4TB) */
        spcl.c_inumber = (uint32_t)ino;
        spcl.c_magic = (tp_bsize == TP_BSIZE_MIN) ? NFS_MAGIC : MTB_MAGIC;
        spcl.c_checksum = 0;
        ip = (int32_t *)&spcl;
        s = CHECKSUM;
        assert((tp_bsize % sizeof (*ip)) == 0);
        i = tp_bsize / sizeof (*ip);
        assert((i%8) == 0);
        i /= 8;
        do {
                s -= *ip++; s -= *ip++; s -= *ip++; s -= *ip++;
                s -= *ip++; s -= *ip++; s -= *ip++; s -= *ip++;
        } while (--i > 0);
        spcl.c_checksum = s;
        taprec((uchar_t *)&spcl, flags, sizeof (spcl));
        if (spcl.c_type == TS_END)
                spcl.c_flags &= ~DR_INODEINFO;
        else if (spcl.c_type == TS_TAPE)
                spcl.c_flags &= ~(DR_NEWHEADER|DR_REDUMP|DR_TRUEINC);
}

/*
 * Fill appropriate buffer
 */
void
taprec(uchar_t *dp, int flags, int size)
{
        if (size > tp_bsize) {
                msg(gettext(
                    "taprec: Unexpected buffer size, expected %d, got %d.\n"),
                    tp_bsize, size);
                dumpabort();
                /*NOTREACHED*/
        }

        while ((*current)->b_flags & BUF_FULL)
                nap(10);

        bcopy(dp, (*current)->b_data, (size_t)size);
        if (size < tp_bsize) {
                bzero((*current)->b_data + size, tp_bsize - size);
        }

        if (dumptoarchive)
                flags |= BUF_ARCHIVE;

        /* no locking as we assume only one reader and one writer active */
        (*current)->b_flags = (flags | BUF_FULL);
        if (++*current >= &bufp[NBUF*ntrec])
                (*current) = &bufp[0];
        (*tapea)++;
}

void
dmpblk(daddr32_t blkno, size_t size, off_t offset)
{
        diskaddr_t dblkno;

        assert((offset >> DEV_BSHIFT) <= INT32_MAX);
        dblkno = fsbtodb(sblock, blkno) + (offset >> DEV_BSHIFT);
        size = (size + DEV_BSIZE-1) & ~(DEV_BSIZE-1);
        slp->sl_req->br_dblk = dblkno;
        slp->sl_req->br_size = size;
        if (dumptoarchive) {
                /* LINTED: result fits in a short */
                slp->sl_req->aflag |= BUF_ARCHIVE;
        }
        toslave((void(*)())0, ino);
}

/*ARGSUSED*/
static void
tperror(int sig)
{
        char buf[3000];

        if (pipeout) {
                msg(gettext("Write error on %s\n"), tape);
                msg(gettext("Cannot recover\n"));
                dumpabort();
                /* NOTREACHED */
        }
        if (!doingverify) {
                broadcast(gettext("WRITE ERROR!\n"));
                (void) snprintf(buf, sizeof (buf),
                    gettext("Do you want to restart?: (\"yes\" or \"no\") "));
                if (!query(buf)) {
                        dumpabort();
                        /*NOTREACHED*/
                }
                if (tapeout && (isrewind(to) || offline)) {
                        /* ANSI string catenation, to shut cstyle up */
                        msg(gettext("This tape will rewind.  After "
                                    "it is rewound,\nreplace the faulty tape "
                                    "with a new one;\nthis dump volume will "
                                    "be rewritten.\n"));
                }
        } else {
                broadcast(gettext("TAPE VERIFICATION ERROR!\n"));
                (void) snprintf(buf, sizeof (buf), gettext(
                    "Do you want to rewrite?: (\"yes\" or \"no\") "));
                if (!query(buf)) {
                        dumpabort();
                        /*NOTREACHED*/
                }
                msg(gettext(
                        "This tape will be rewritten and then verified\n"));
        }
        killall();
        trewind();
        Exit(X_REWRITE);
}

/*
 * Called by master from pass() to send a request to dump files/blocks
 * to one of the slaves.  Slaves return whether the file was active
 * when it was being dumped.  The tape writer process sends checkpoint
 * info when it completes a volume.
 */
void
toslave(void (*fn)(), ino_t inumber)
{
        int     wasactive;

        if (recsout >= SLAVES) {
                if ((unsigned)atomic((int(*)())read, slp->sl_slavefd,
                    (char *)&wasactive, sizeof (wasactive)) !=
                    sizeof (wasactive)) {
                        cmdrderr();
                        dumpabort();
                        /*NOTREACHED*/
                }
                if (wasactive) {
                        active++;
                        msg(gettext(
                "The file at inode `%lu' was active and will be recopied\n"),
                                slp->sl_req->ir_inumber);
                        /* LINTED: 32-bit to 8-bit assignment ok */
                        BIS(slp->sl_req->ir_inumber, activemap);
                }
        }
        slp->sl_req->aflag = 0;
        if (dumptoarchive) {
                /* LINTED: result fits in a short */
                slp->sl_req->aflag |= BUF_ARCHIVE;
        }
        if (fn)
                (*fn)(inumber);

        if (atomic((int(*)())write, slp->sl_slavefd, (char *)slp->sl_req,
            reqsiz) != reqsiz) {
                cmdwrterr();
                dumpabort();
                /*NOTREACHED*/
        }
        ++recsout;
        nextslave();
}

void
dospcl(ino_t inumber)
{
        /* LINTED for now, max inode # is 2**31 (ufs max size is 1TB) */
        spcl.c_inumber = (uint32_t)inumber;
        slp->sl_req->br_dblk = 0;
        bcopy((char *)&spcl, (char *)slp->sl_req->br_spcl, tp_bsize);
}

static void
#ifdef __STDC__
nextslave(void)
#else
nextslave()
#endif
{
        if (++rotor >= SLAVES) {
                rotor = 0;
        }
        slp = &slaves[rotor];
}

void
#ifdef __STDC__
flushcmds(void)
#else
flushcmds()
#endif
{
        int i;
        int wasactive;

        /*
         * Retrieve all slave status
         */
        if (recsout < SLAVES) {
                slp = slaves;
                rotor = 0;
        }
        for (i = 0; i < (recsout < SLAVES ? recsout : SLAVES); i++) {
                if ((unsigned)atomic((int(*)())read, slp->sl_slavefd,
                    (char *)&wasactive, sizeof (wasactive)) !=
                    sizeof (wasactive)) {
                        cmdrderr();
                        dumpabort();
                        /*NOTREACHED*/
                }
                if (wasactive) {
                        active++;
                        msg(gettext(
                            "inode %d was active and will be recopied\n"),
                                slp->sl_req->ir_inumber);
                        /* LINTED: 32-bit to 8-bit assignment ok */
                        BIS(slp->sl_req->ir_inumber, activemap);
                }
                nextslave();
        }
}

void
#ifdef __STDC__
flusht(void)
#else
flusht()
#endif
{
        sigset_t block_set, oset;       /* hold SIGUSR1 and atomically sleep */

        (void) sigemptyset(&block_set);
        (void) sigaddset(&block_set, SIGUSR1);
        (void) sigprocmask(SIG_BLOCK, &block_set, &oset);
        (void) kill(writepid, SIGUSR1); /* tell writer to flush */
        (void) sigpause(SIGUSR1);       /* wait for SIGUSR1 from writer */
        /*NOTREACHED*/
}

jmp_buf checkpoint_buf;

/*
 * Roll forward to the next volume after receiving
 * an EOT signal from writer.  Get checkpoint data
 * from writer and return if done, otherwise fork
 * a new process and jump back to main state loop
 * to begin the next volume.  Installed as the master's
 * signal handler for SIGUSR1.
 */
/*ARGSUSED*/
static void
rollforward(int sig)
{
        int status;
        (void) sighold(SIGUSR1);

        /*
         * Writer sends us checkpoint information after
         * each volume.  A returned state of DS_DONE with no
         * unwritten (left-over) records differentiates a
         * clean flush from one in which EOT was encountered.
         */
        if ((unsigned)atomic((int(*)())read, writer, (char *)&chkpt,
            sizeof (struct slaves)) != sizeof (struct slaves)) {
                cmdrderr();
                dumpabort();
                /*NOTREACHED*/
        }
        if (atomic((int(*)())read, writer, (char *)&spcl,
            TP_BSIZE_MIN) != TP_BSIZE_MIN) {
                cmdrderr();
                dumpabort();
                /*NOTREACHED*/
        }
        ino = chkpt.sl_inos - 1;
        pos = chkpt.sl_offset;
        leftover = chkpt.sl_count;
        dumpstate = chkpt.sl_state;
        blockswritten = ++chkpt.sl_tapea;

        if (dumpstate == DS_DONE) {
                if (archivepid) {
                        /*
                         * If archiving (either archive or
                         * database), signal the archiver
                         * to finish up.  This must happen
                         * before the writer exits in order
                         * to avoid a race.
                         */
                        (void) kill(archivepid, SIGUSR1);
                }
                (void) signal(SIGUSR1, SIG_IGN);
                (void) sigrelse(SIGUSR1);
                (void) kill(writepid, SIGUSR1); /* tell writer to exit */

                lf_archoffset = 0LL;
                longjmp(checkpoint_buf, 1);
                /*NOTREACHED*/
        }

        if (leftover) {
                (void) memmove(spcl.c_addr,
                    &spcl.c_addr[spcl.c_count-leftover], leftover);
                bzero(&spcl.c_addr[leftover], TP_NINDIR-leftover);
        }
        if (writepid) {
                (void) kill(writepid, SIGUSR1); /* tell writer to exit */
                (void) close(writer);
                writer = -1;
        }
        if (archivepid) {
                (void) waitpid(archivepid, &status, 0); /* wait for archiver */
#ifdef TDEBUG

                /* XGETTEXT:  #ifdef TDEBUG only */
                msg(gettext("Archiver %ld returns with status %d\n"),
                    (long)archivepid, status);
#endif
                archivepid = 0;
        }
        /*
         * Checkpoint archive file
         */
        if (!doingverify && archive) {
                lf_archoffset = lseek64(archivefd, (off64_t)0, 2);
                if (lf_archoffset < 0) {
                        int saverr = errno;
                        msg(gettext("Cannot position archive file `%s': %s\n"),
                                archivefile, strerror(saverr));
                        dumpabort();
                        /*NOTREACHED*/
                }
                (void) close(archivefd);
                archivefd = -1;
        }
        resetino(ino);

        if (dumpstate == DS_START) {
                msg(gettext(
                        "Tape too short: changing volumes and restarting\n"));
                reset();
        }

        if (!pipeout) {
                if (verify && !doingverify)
                        trewind();
                else {
                        close_rewind();
                        changevol();
                }
        }

        (void) sigrelse(SIGUSR1);
        otape(0);
        longjmp(checkpoint_buf, 1);
        /*NOTREACHED*/
}

static void
nap(int ms)
{
        struct timeval tv;

        tv.tv_sec = ms / 1000;
        tv.tv_usec = (ms - tv.tv_sec * 1000) * 1000;
        (void) select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
}

static jmp_buf alrm_buf;

/*ARGSUSED*/
static void
alrm(int sig)
{
        longjmp(alrm_buf, 1);
        /*NOTREACHED*/
}

void
#ifdef __STDC__
nextdevice(void)
#else
nextdevice()
#endif
{
        char    *cp;

        cp = spcl.c_host;
        /*
         * dumpdev is provided for use in prompts and is of
         * the form:
         *      hostname:device
         * sdumpdev is of the form:
         *      hostname:device
         * for remote devices, and simply:
         *      device
         * for local devices.
         */
        if (dumpdev != NULL) {
                /* LINTED: dumpdev is not NULL */
                free(dumpdev);
        }
        /*LINTED [cast to smaller integer]*/
        dumpdev = xmalloc((size_t)((sizeof (spcl.c_host) + strlen(tape) + 2)));
        /* LINTED unsigned -> signed cast ok */
        (void) sprintf(dumpdev, "%.*s:%s", (int)sizeof (spcl.c_host), cp, tape);
        if (cp == spcl.c_host)
                sdumpdev = strchr(dumpdev, ':') + 1;
        else
                sdumpdev = dumpdev;
}

/*
 * Gross hack due to misfeature of mt tape driver that causes
 * the device to rewind if we generate any signals.  Guess
 * whether tape is rewind device or not -- for local devices
 * we can just look at the minor number.  For rmt devices,
 * make an educated guess.
 */
int
isrewind(int f)
{
        struct stat64 sbuf;
        int     rewind;

        if (fstat64(f, &sbuf) < 0) {
                msg(gettext(
                    "Cannot obtain status of output device `%s'\n"),
                    tape);
                dumpabort();
                /*NOTREACHED*/
        }
        rewind = minor(sbuf.st_rdev) & MT_NOREWIND ? 0 : 1;
        return (rewind);
}

static void
#ifdef __STDC__
just_rewind(void)
#else
just_rewind()
#endif
{
        struct slaves *slavep;
        char *rewinding = gettext("Tape rewinding\n");

        for (slavep = &slaves[0]; slavep < &slaves[SLAVES]; slavep++) {
                if (slavep->sl_slavepid > 0)    /* signal normal exit */
                        (void) kill(slavep->sl_slavepid, SIGTERM);
                if (slavep->sl_slavefd >= 0) {
                        (void) close(slavep->sl_slavefd);
                        slavep->sl_slavefd = -1;
                }
        }

        /* wait for any signals from slaves */
        while (waitpid(0, (int *)0, 0) >= 0)
                /*LINTED [empty body]*/
                continue;

        if (pipeout)
                return;

        if (doingverify) {
                /*
                 * Space to the end of the tape.
                 * Backup first in case we already read the EOF.
                 */
                static struct mtop bsr = { MTBSR, 1 };
                static struct mtop eom = { MTEOM, 1 };
                static struct mtop fsf = { MTFSF, 1 };

                (void) ioctl(to, MTIOCTOP, &bsr);
                if (ioctl(to, MTIOCTOP, &eom) < 0)
                        (void) ioctl(to, MTIOCTOP, &fsf);
        }

        /*
         * Guess whether the tape is rewinding so we can tell
         * the operator if it's going to take a long time.
         */
        if (tapeout && isrewind(to)) {
                /* tape is probably rewinding */
                msg(rewinding);
        }
}

void
#ifdef __STDC__
trewind(void)
#else
trewind()
#endif
{
        (void) timeclock((time_t)0);
        if (offline && (!verify || doingverify)) {
                close_rewind();
        } else {
                just_rewind();
                (void) close(to);
        }
}

void
#ifdef __STDC__
close_rewind(void)
#else
close_rewind()
#endif
{
        char *rewinding = gettext("Tape rewinding\n");

        (void) timeclock((time_t)0);
        just_rewind();
        /*
         * The check in just_rewind won't catch the case in
         * which the current volume is being taken off-line
         * and is not mounted on a no-rewind device (and is
         * not the last volume, which is not taken off-line).
         */
        if (tapeout && !isrewind(to) && offline) {
                /* tape is probably rewinding */
                msg(rewinding);
        }
        if (offline || autoload) {
                static struct mtop offl = { MTOFFL, 0 };

                (void) ioctl(to, MTIOCTOP, &offl);
                if (diskette)
                        (void) ioctl(to, FDEJECT, 0);
        }
        (void) close(to);
        to = -1;
}

void
#ifdef __STDC__
changevol(void)
#else
changevol()
#endif
{
        char buf1[3000], buf2[3000];
        char volname[LBLSIZE+1];

        /*CONSTANTCONDITION*/
        assert(sizeof (spcl.c_label) < sizeof (volname));

        filenum = 1;
        nextdevice();
        (void) strcpy(spcl.c_label, tlabel);
        /*
         * Make volume switching as automatic as possible
         * while avoiding overwriting volumes.  We will
         * switch automatically under the following condition:
         *    1) The user specified autoloading from the
         *      command line.
         * At one time, we (in the guise of hsmdump) had the
         * concept of a sequence of devices to rotate through,
         * but that's never been a ufsdump feature.
         */
        if (autoload) {
                int tries;

                /*
                 * Stop the clock for throughput calculations.
                 */
                if ((telapsed != NULL) && (tstart_writing != NULL)) {
                        *telapsed += time(NULL) - *tstart_writing;
                }

                (void) snprintf(volname, sizeof (volname), "#%d", tapeno+1);
                (void) snprintf(buf1, sizeof (buf1), gettext(
                    "Mounting volume %s on %s\n"), volname, dumpdev);
                msg(buf1);
                broadcast(buf1);

                /*
                 * Wait for the tape to autoload.  Note that the delay
                 * period doesn't take into account however long it takes
                 * for the open to fail (measured at 21 seconds for an
                 * Exabyte 8200 under 2.7 on an Ultra 2).
                 */
                for (tries = 0; tries < autoload_tries; tries++) {
                        int f, m;

                        m = (access(tape, F_OK) == 0) ? 0 : O_CREAT;
                        if ((f = doingverify ?
                            safe_device_open(tape, O_RDONLY, 0600) :
                            safe_device_open(tape, O_RDONLY|m, 0600))
                            >= 0) {
                                (void) close(f);
                                return;
                        }
                        (void) sleep(autoload_period);
                }
                /*
                 * Autoload timed out, ask the operator to do it.
                 * Note that query() will update *telapsed, and we
                 * shouldn't charge for the autoload time.  So, since
                 * we updated *telapsed ourselves above, we just set
                 * tstart_writing to the current time, and query()
                 * will end up making a null-effect change.  This,
                 * of course, assumes that our caller will be resetting
                 * *tstart_writing.  This is currently the case.
                 * If tstart_writing is NULL (should never happen),
                 * we're ok, since time(2) will accept a NULL pointer.
                 */
                (void) time(tstart_writing);
        }

        if (strncmp(spcl.c_label, "none", 5)) {
                (void) strncpy(volname, spcl.c_label, sizeof (spcl.c_label));
                volname[sizeof (spcl.c_label)] = '\0';
        } else
                (void) snprintf(volname, sizeof (volname), "#%d", tapeno+1);

        timeest(1, spcl.c_tapea);
        (void) snprintf(buf1, sizeof (buf1), gettext(
            "Change Volumes: Mount volume `%s' on `%s'\n"), volname, dumpdev);
        msg(buf1);
        broadcast(gettext("CHANGE VOLUMES!\7\7\n"));
        (void) snprintf(buf1, sizeof (buf1), gettext(
            "Is the new volume (%s) mounted on `%s' and ready to go?: %s"),
            volname, dumpdev, gettext("(\"yes\" or \"no\") "));
        while (!query(buf1)) {
                (void) snprintf(buf2, sizeof (buf2), gettext(
                    "Do you want to abort dump?: (\"yes\" or \"no\") "));
                if (query(buf2)) {
                        dumpabort();
                        /*NOTREACHED*/
                }
        }
}

/*
 *      We implement taking and restoring checkpoints on the tape level.
 *      When each tape is opened, a new process is created by forking; this
 *      saves all of the necessary context in the parent.  The child
 *      continues the dump; the parent waits around, saving the context.
 *      If the child returns X_REWRITE, then it had problems writing that tape;
 *      this causes the parent to fork again, duplicating the context, and
 *      everything continues as if nothing had happened.
 */

void
otape(int top)
{
        static struct mtget mt;
        char buf[3000];
        pid_t parentpid;
        pid_t childpid;
        pid_t waitproc;
        int status;
        struct sigvec sv, osv;

        sv.sv_flags = SA_RESTART;
        (void) sigemptyset(&sv.sa_mask);
        sv.sv_handler = SIG_IGN;
        (void) sigvec(SIGINT, &sv, NULL);

        parentpid = getpid();

        if (verify) {
                if (doingverify)
                        doingverify = 0;
                else
                        Exit(X_VERIFY);
        }
restore_check_point:

        sv.sv_handler = interrupt;
        (void) sigvec(SIGINT, &sv, NULL);
        (void) fflush(stderr);
        /*
         *      All signals are inherited...
         */
        sighold(SIGINT);
        childpid = fork();
        if (childpid < 0) {
                msg(gettext(
                    "Context-saving fork failed in parent %ld\n"),
                        (long)parentpid);
                Exit(X_ABORT);
        }
        if (childpid != 0) {
                /*
                 *      PARENT:
                 *      save the context by waiting
                 *      until the child doing all of the work returns.
                 *      let the child catch user interrupts
                 */
                sv.sv_handler = SIG_IGN;
                (void) sigvec(SIGINT, &sv, NULL);
                sigrelse(SIGINT);
#ifdef TDEBUG

                /* XGETTEXT:  #ifdef TDEBUG only */
                msg(gettext(
                    "Volume: %d; parent process: %ld child process %ld\n"),
                        tapeno+1, (long)parentpid, (long)childpid);
#endif /* TDEBUG */
                for (;;) {
                        waitproc = waitpid(0, &status, 0);
                        if (waitproc == childpid)
                                break;
                        msg(gettext(
        "Parent %ld waiting for child %ld had another child %ld return\n"),
                            (long)parentpid, (long)childpid, (long)waitproc);
                }
                if (WIFSIGNALED(status)) {
                        msg(gettext("Process %ld killed by signal %d: %s\n"),
                            (long)childpid, WTERMSIG(status),
                            strsignal(WTERMSIG(status)));
                        status = X_ABORT;
                } else
                        status = WEXITSTATUS(status);
#ifdef TDEBUG
                switch (status) {
                case X_FINOK:
                        /* XGETTEXT:  #ifdef TDEBUG only */
                        msg(gettext(
                            "Child %ld finishes X_FINOK\n"), (long)childpid);
                        break;
                case X_ABORT:
                        /* XGETTEXT:  #ifdef TDEBUG only */
                        msg(gettext(
                            "Child %ld finishes X_ABORT\n"), (long)childpid);
                        break;
                case X_REWRITE:
                        /* XGETTEXT:  #ifdef TDEBUG only */
                        msg(gettext(
                            "Child %ld finishes X_REWRITE\n"), (long)childpid);
                        break;
                case X_RESTART:
                        /* XGETTEXT:  #ifdef TDEBUG only */
                        msg(gettext(
                            "Child %ld finishes X_RESTART\n"), (long)childpid);
                        break;
                case X_VERIFY:
                        /* XGETTEXT:  #ifdef TDEBUG only */
                        msg(gettext(
                            "Child %ld finishes X_VERIFY\n"), (long)childpid);
                        break;
                default:
                        /* XGETTEXT:  #ifdef TDEBUG only */
                        msg(gettext("Child %ld finishes unknown %d\n"),
                            (long)childpid, status);
                        break;
                }
#endif /* TDEBUG */
                switch (status) {
                case X_FINOK:
                        /* wait for children */
                        while (waitpid(0, (int *)0, 0) >= 0)
                                /*LINTED [empty body]*/
                                continue;
                        Exit(X_FINOK);
                        /*NOTREACHED*/
                case X_ABORT:
                        Exit(X_ABORT);
                        /*NOTREACHED*/
                case X_VERIFY:
                        doingverify++;
                        goto restore_check_point;
                        /*NOTREACHED*/
                case X_REWRITE:
                        doingverify = 0;
                        changevol();
                        goto restore_check_point;
                        /* NOTREACHED */
                case X_RESTART:
                        doingverify = 0;
                        if (!top) {
                                Exit(X_RESTART);
                        }
                        if (!offline)
                                autoload = 0;
                        changevol();
                        sv.sv_handler = interrupt;
                        (void) sigvec(SIGINT, &sv, NULL);
                        return;
                        /* NOTREACHED */
                default:
                        msg(gettext("Bad return code from dump: %d\n"), status);
                        Exit(X_ABORT);
                        /*NOTREACHED*/
                }
                /*NOTREACHED*/
        } else {        /* we are the child; just continue */
                child_chdir();
                sigrelse(SIGINT);
#ifdef TDEBUG
                (void) sleep(4); /* time for parent's message to get out */
                /* XGETTEXT:  #ifdef TDEBUG only */
                msg(gettext(
                    "Child on Volume %d has parent %ld, my pid = %ld\n"),
                        tapeno+1, (long)parentpid, (long)getpid());
#endif
                (void) snprintf(buf, sizeof (buf), gettext(
"Cannot open `%s'.  Do you want to retry the open?: (\"yes\" or \"no\") "),
                    dumpdev);
                if (doingverify) {
                        /* 1 for stdout */
                        while ((to = pipeout ? 1 :
                            safe_device_open(tape, O_RDONLY, 0600)) < 0) {
                                perror(tape);
                                if (autoload) {
                                        if (!query_once(buf, 1)) {
                                                dumpabort();
                                                /*NOTREACHED*/
                                        }
                                } else {
                                        if (!query(buf)) {
                                                dumpabort();
                                                /*NOTREACHED*/
                                        }
                                }
                        }

                        /*
                         * If we're using the non-rewinding tape device,
                         * the tape will be left positioned after the
                         * EOF mark.  We need to back up to the beginning
                         * of this tape file (cross two tape marks in the
                         * reverse direction and one in the forward
                         * direction) before the verify pass.
                         */
                        static struct mtop bsf = { MTBSF, 2 };
                        static struct mtop fsf = { MTFSF, 1 };
                        static struct mtop nbsf = { MTNBSF, 1 };

                        if (ioctl(to, MTIOCTOP, &bsf) >= 0)
                                (void) ioctl(to, MTIOCTOP, &fsf);
                        else
                                (void) ioctl(to, MTIOCTOP, &nbsf);
                } else {
                        /*
                         * XXX Add logic to test for "tape" being a
                         * XXX device or a non-existent file.
                         * Current behaviour is that it must exist,
                         * and we over-write whatever's there.
                         * This can be bad if tape == "/etc/passwd".
                         */
                        if (!pipeout && doposition && (tapeno == 0)) {
                                positiontape(buf);
                                if (setjmp(alrm_buf)) {
                                        /*
                                         * The tape is rewinding;
                                         * we're screwed.
                                         */
                                    msg(gettext(
                            "Cannot position tape using rewind device!\n"));
                                    dumpabort();
                                    /*NOTREACHED*/
                                } else {
                                        sv.sv_handler = alrm;
                                        (void) sigvec(SIGALRM, &sv, &osv);
                                        (void) alarm(15);
                                }
                                while ((to = safe_device_open(tape, O_WRONLY,
                                    0600)) < 0)
                                        (void) sleep(10);
                                (void) alarm(0);
                                (void) sigvec(SIGALRM, &osv,
                                    NULL);
                        } else {
                                int m;
                                m = (access(tape, F_OK) == 0) ? 0 : O_CREAT;
                                /*
                                 * Only verify the tape label if label
                                 * verification is on and we are at BOT
                                 */
                                if (pipeout)
                                        to = 1;
                                else while ((to = safe_device_open(tape,
                                    O_WRONLY|m, 0600)) < 0)
                                        if (!query_once(buf, 1)) {
                                                dumpabort();
                                                /*NOTREACHED*/
                                        }
                        }
                }
                if (!pipeout) {
                        tapeout = ioctl(to, MTIOCGET, &mt) >= 0;        /* set state */
                        /*
                         * Make sure the tape is positioned
                         * where it is supposed to be
                         */
                        if (tapeout && (tapeno > 0) &&
                            (mt.mt_fileno != (filenum-1))) {
                                (void) snprintf(buf, sizeof (buf), gettext(
                                    "Warning - tape positioning error!\n\
\t%s current file %ld, should be %ld\n"),
                                    tape, mt.mt_fileno+1, filenum);
                                msg(buf);
                                dumpailing();
                        }
                }
                tapeno++;               /* current tape sequence */
                if (tapeno < TP_NINOS)
                        inos[tapeno] = chkpt.sl_inos;
                spcl.c_firstrec = chkpt.sl_firstrec;
                spcl.c_tapea = (*tapea) = chkpt.sl_tapea;
                spcl.c_volume++;

                enslave();      /* Share tape buffers with slaves */

#ifdef DEBUG
                if (xflag) {
                        /* XGETTEXT:  #ifdef DEBUG only */
                        msg(gettext("Checkpoint state:\n"));
                        msg("    blockswritten %u\n", blockswritten);
                        msg("    ino %u\n", ino);
                        msg("    pos %u\n", pos);
                        msg("    left %u\n", leftover);
                        msg("    tapea %u\n", (*tapea));
                        msg("    state %d\n", dumpstate);
                }
#endif
                spcl.c_type = TS_TAPE;
                spcl.c_tpbsize = tp_bsize;
                if (leftover == 0) {
                        spcl.c_count = 0;
                        spclrec();
                        newtape = 0;
                } else
                        newtape++;      /* new volume indication */
                if (doingverify) {
                        msg(gettext("Starting verify pass\n"));
                } else if (tapeno > 1) {
                        msg(gettext(
                            "Volume %d begins with blocks from inode %lu\n"),
                                tapeno, chkpt.sl_inos);
                }
                (void) timeclock((time_t)1);
                (void) time(tstart_writing);
                timeest(0, spcl.c_tapea);
        }
}

void
#ifdef __STDC__
dumpabort(void)
#else
dumpabort()
#endif
{

        if (master && master != getpid())
                /*
                 * signal master to call dumpabort
                 */
                (void) kill(master, SIGTERM);
        else {
                killall();

                if (archivefile && archive_opened)
                        (void) unlink(archivefile);
                msg(gettext("The ENTIRE dump is aborted.\n"));
        }
        Exit(X_ABORT);
}

void
dumpailing(void)
{

        broadcast(gettext("DUMP IS AILING!\n"));
        if (!query(gettext(
            "Do you want to attempt to continue? (\"yes\" or \"no\") "))) {
                dumpabort();
                /*NOTREACHED*/
        }
}

void
Exit(status)
{
        /*
         * Clean up message system
         */
#ifdef TDEBUG

        /* XGETTEXT:  #ifdef TDEBUG only */
        msg(gettext("pid = %ld exits with status %d\n"),
                (long)getpid(), status);
#endif /* TDEBUG */
        exit(status);
}

static void
#ifdef __STDC__
killall(void)
#else
killall()
#endif
{
        struct slaves *slavep;

        for (slavep = &slaves[0]; slavep < &slaves[SLAVES]; slavep++)
                if (slavep->sl_slavepid > 0) {
                        (void) kill(slavep->sl_slavepid, SIGKILL);
#ifdef TDEBUG

                        /* XGETTEXT:  #ifdef TDEBUG only */
                        msg(gettext("Slave child %ld killed\n"),
                                (long)slavep->sl_slavepid);
#endif
                }
        if (writepid) {
                (void) kill(writepid, SIGKILL);
#ifdef TDEBUG

                /* XGETTEXT:  #ifdef TDEBUG only */
                msg(gettext("Writer child %ld killed\n"), (long)writepid);
#endif
        }
        if (archivepid) {
                (void) kill(archivepid, SIGKILL);
#ifdef TDEBUG

                /* XGETTEXT:  #ifdef TDEBUG only */
                msg(gettext("Archiver child %ld killed\n"), (long)archivepid);
#endif
        }
}

/*ARGSUSED*/
static void
proceed(int sig)
{
        caught++;
}

/*ARGSUSED*/
static void
die(int sig)
{
        Exit(X_FINOK);
}

static void
#ifdef __STDC__
enslave(void)
#else
enslave()
#endif
{
        int cmd[2];                     /* file descriptors */
        int i;
        struct sigvec sv;
        struct slaves *slavep;
        int saverr;

        sv.sv_flags = SA_RESTART;
        (void) sigemptyset(&sv.sa_mask);
        master = getpid();
        /*
         * slave sends SIGTERM on dumpabort
         */
        sv.sv_handler = (void(*)(int))dumpabort;
        (void) sigvec(SIGTERM, &sv, NULL);
        sv.sv_handler = tperror;
        (void) sigvec(SIGUSR2, &sv, NULL);
        sv.sv_handler = proceed;
        (void) sigvec(SIGUSR1, &sv, NULL);
        totalrecsout += recsout;
        caught = 0;
        recsout = 0;
        rotor = 0;
        bufclear();
        for (slavep = &slaves[0]; slavep < &slaves[SLAVES]; slavep++)
                slavep->sl_slavefd = -1;
        archivefd = arch = writer = -1;
        for (i = 0; i < SLAVES; i++) {
                if (pipe(cmd) < 0) {
                        saverr = errno;
                        msg(gettext(
                            "Cannot create pipe for slave process: %s\n"),
                            strerror(saverr));
                        dumpabort();
                        /*NOTREACHED*/
                }
                sighold(SIGUSR2);
                sighold(SIGINT);
                sighold(SIGTERM);
                if ((slaves[i].sl_slavepid = fork()) < 0) {
                        saverr = errno;
                        msg(gettext("Cannot create slave process: %s\n"),
                            strerror(saverr));
                        dumpabort();
                        /*NOTREACHED*/
                }
                slaves[i].sl_slavefd = cmd[1];
                if (slaves[i].sl_slavepid == 0) {   /* Slave starts up here */
                        pid_t next;                 /* pid of neighbor */

                        sv.sv_handler = SIG_DFL;
                        (void) sigvec(SIGUSR2, &sv, NULL);
                        sv.sv_handler = SIG_IGN;        /* master handler INT */
                        (void) sigvec(SIGINT, &sv, NULL);
                        sv.sv_handler = die;            /* normal slave exit */
                        (void) sigvec(SIGTERM, &sv, NULL);

                        child_chdir();
                        sigrelse(SIGUSR2);
                        sigrelse(SIGINT);
                        sigrelse(SIGTERM);

                        freeino();      /* release unneeded resources */
#ifdef TDEBUG
                (void) sleep(4); /* time for parent's message to get out */
                /* XGETTEXT:  #ifdef TDEBUG only */
                msg(gettext("Neighbor has pid = %ld\n"), (long)getpid());
#endif
                        /* Closes cmd[1] as a side-effect */
                        for (slavep = &slaves[0];
                            slavep < &slaves[SLAVES];
                            slavep++)
                                if (slavep->sl_slavefd >= 0) {
                                        (void) close(slavep->sl_slavefd);
                                        slavep->sl_slavefd = -1;
                                }
                        (void) close(to);
                        (void) close(fi);           /* Need our own seek ptr */
                        to = -1;

                        fi = open(disk, O_RDONLY);

                        if (fi < 0) {
                                saverr = errno;
                                msg(gettext(
                                    "Cannot open dump device `%s': %s\n"),
                                        disk, strerror(saverr));
                                dumpabort();
                                /*NOTREACHED*/
                        }

                        if ((unsigned)atomic((int(*)())read, cmd[0],
                            (char *)&next, sizeof (next)) != sizeof (next)) {
                                cmdrderr();
                                dumpabort();
                                /*NOTREACHED*/
                        }
                        dumpoffline(cmd[0], next, i);
                        Exit(X_FINOK);
                }
                /* Parent continues here */
                sigrelse(SIGUSR2);
                sigrelse(SIGINT);
                sigrelse(SIGTERM);
                (void) close(cmd[0]);
        }

        if (archive) {
                archivepid = setuparchive();
                if (!archivepid) {
                        dumpabort();
                        /*NOTREACHED*/
                }
        }

        writepid = setupwriter();
        if (!writepid) {
                dumpabort();
                /*NOTREACHED*/
        }

        if (arch >= 0) {
                (void) close(arch);             /* only writer has this open */
                arch = -1;
        }

        /* Tell each slave who follows it */
        for (i = 0; i < SLAVES; i++) {
                if ((unsigned)atomic((int(*)())write, slaves[i].sl_slavefd,
                    (char *)&(slaves[(i + 1) % SLAVES].sl_slavepid),
                    sizeof (int)) != sizeof (int)) {
                        cmdwrterr();
                        dumpabort();
                        /*NOTREACHED*/
                }
        }
        sv.sv_handler = rollforward;            /* rcvd from writer on EOT */
        (void) sigvec(SIGUSR1, &sv, NULL);
        slp = slaves;
        (void) kill(slp->sl_slavepid, SIGUSR1);
        master = 0;
}

static void
#ifdef __STDC__
wait_our_turn(void)
#else
wait_our_turn()
#endif
{
        (void) sighold(SIGUSR1);

        if (!caught) {
#ifdef INSTRUMENT
                (*idle)++;
#endif
                (void) sigpause(SIGUSR1);
        }
        caught = 0;
        (void) sigrelse(SIGUSR1);
}

static void
dumpoffline(int cmd, pid_t next, int mynum)
{
        struct req *p = slaves[mynum].sl_req;
        ulong_t i;
        uchar_t *cp;
        uchar_t *blkbuf;
        int notactive = 0;

        blkbuf = xmalloc(sblock->fs_bsize);

        /*CONSTANTCONDITION*/
        assert(sizeof (spcl) == TP_BSIZE_MIN);

        while (atomic((int(*)())read, cmd, (char *)p, reqsiz) == reqsiz) {
                if (p->br_dblk) {
                        bread(p->br_dblk, (uchar_t *)blkbuf, p->br_size);
                } else {
                        bcopy((char *)p->br_spcl, (char *)&spcl,
                            sizeof (spcl));
                        ino = spcl.c_inumber;
                }
                dumptoarchive = p->aflag & BUF_ARCHIVE;
                wait_our_turn();
                if (p->br_dblk) {
                        for (i = p->br_size, cp = blkbuf;
                            i > 0;
                            /* LINTED character pointers aren't signed */
                            cp += i > tp_bsize ? tp_bsize : i,
                            i -= i > tp_bsize ? tp_bsize : i) {
                                /* LINTED unsigned to signed conversion ok */
                                taprec(cp, 0, i > tp_bsize ? tp_bsize : (int)i);
                        }
                } else
                        spclrec();
                (void) kill(next, SIGUSR1);     /* Next slave's turn */
                /*
                 * Note that we lie about file activity since we don't
                 * check for it.
                 */
                if ((unsigned)atomic((int(*)())write, cmd, (char *)&notactive,
                    sizeof (notactive)) != sizeof (notactive)) {
                        cmdwrterr();
                        dumpabort();
                        /*NOTREACHED*/
                }
        }

        free(blkbuf);
}

static int count;               /* tape blocks written since last spclrec */

/*ARGSUSED*/
static void
onxfsz(int sig)
{
        msg(gettext("File size limit exceeded writing output volume %d\n"),
            tapeno);
        (void) kill(master, SIGUSR2);
        Exit(X_REWRITE);
}

static long     lastnonaddr;            /* last DS_{INODE,CLRI,BITS} written */
static long     lastnonaddrm;           /* and the mode thereof */
/*
 * dowrite -- the main body of the output writer process
 */
static void
dowrite(int cmd)
{
        struct bdesc *last =
            &bufp[(NBUF*ntrec)-1];              /* last buffer in pool */
        struct bdesc *bp = bufp;                /* current buf in tape block */
        struct bdesc *begin = bufp;             /* first buf of tape block */
        struct bdesc *end = bufp + (ntrec-1);   /* last buf of tape block */
        int siz;                                /* bytes written (block) */
        int trecs;                              /* records written (block)  */
        long asize = 0;                         /* number of 0.1" units... */
                                                /* ...written on current tape */
        char *tp, *rbuf = NULL;
        char *recmap = spcl.c_addr;             /* current tape record map */
        char *endmp;                            /* end of valid map data */
        char *mp;                               /* current map entry */
        union u_spcl *sp;

        (void) signal(SIGXFSZ, onxfsz);

        bzero((char *)&spcl, sizeof (spcl));
        count = 0;

        if (doingverify) {
                rbuf = (char *)malloc((uint_t)writesize);
                if (rbuf == 0) {
                        /* Restart from checkpoint */
                        (void) kill(master, SIGUSR2);
                        Exit(X_REWRITE);
                }
        }

        for (;;) {
                /* START: wait until all buffers in tape block are full */
                if ((bp->b_flags & BUF_FULL) == 0) {
                        if (caught) {           /* master signalled flush */
                                (void) sighold(SIGUSR1);
                                caught = 0;
                                /* signal ready */
                                (void) kill(master, SIGUSR1);
                                chkpt.sl_count = 0;     /* signal not at EOT */
                                checkpoint(bp-1, cmd);  /* send data */
                                (void) sigpause(SIGUSR1);
                                break;
                        }
#ifdef INSTRUMENT
                        (*readmissp)++;
#endif
                        nap(50);
                        continue;
                }
                if (bp < end) {
                        bp++;
                        continue;
                }
                /* END: wait until all buffers in tape block are full */

                tp = begin->b_data;
                (void) sighold(SIGUSR1);
                if (!doingverify)
                        siz = write(to, tp, writesize);
                else if ((siz = read(to, rbuf, writesize)) ==
                    writesize && bcmp(rbuf, tp, writesize))
                        siz = -1;
                if (siz < 0 && diskette && errno == ENOSPC)
                        siz = 0;        /* really EOF */
                (void) sigrelse(SIGUSR1);
                if (siz < 0 ||
                    (pipeout && siz != writesize)) {
                        char buf[3000];

                        /*
                         * Isn't i18n wonderful?
                         */
                        if (doingverify) {
                                if (diskette)
                                        (void) snprintf(buf, sizeof (buf),
                                            gettext(
                    "Verification error %ld blocks into diskette %d\n"),
                                            asize * 2, tapeno);
                                else if (tapeout)
                                        (void) snprintf(buf, sizeof (buf),
                                            gettext(
                    "Verification error %ld feet into tape %d\n"),
                                            (cartridge ? asize/tracks :
                                                asize)/120L,
                                            tapeno);
                                else
                                        (void) snprintf(buf, sizeof (buf),
                                            gettext(
                    "Verification error %ld blocks into volume %d\n"),
                                            asize * 2, tapeno);

                        } else {
                                if (diskette)
                                        (void) snprintf(buf, sizeof (buf),
                                            gettext(
                        "Write error %ld blocks into diskette %d\n"),
                                            asize * 2, tapeno);
                                else if (tapeout)
                                        (void) snprintf(buf, sizeof (buf),
                                            gettext(
                        "Write error %ld feet into tape %d\n"),
                                            (cartridge ? asize/tracks :
                                                asize)/120L, tapeno);
                                else
                                        (void) snprintf(buf, sizeof (buf),
                                            gettext(
                        "Write error %ld blocks into volume %d\n"),
                                            asize * 2, tapeno);
                        }

                        msg(buf);
                        /* Restart from checkpoint */
#ifdef TDEBUG

                        /* XGETTEXT:  #ifdef TDEBUG only */
                        msg(gettext("sending SIGUSR2 to pid %ld\n"), master);
#endif
                        (void) kill(master, SIGUSR2);
                        Exit(X_REWRITE);
                }
                trecs = siz / tp_bsize;
                if (diskette)
                        asize += trecs; /* asize == blocks written */
                else
                        asize += (siz/density + tenthsperirg);
                if (trecs)
                        chkpt.sl_firstrec++;
                for (bp = begin; bp < begin + trecs; bp++) {
                        if ((arch >= 0) && (bp->b_flags & BUF_ARCHIVE)) {
                                if ((unsigned)atomic((int(*)())write, arch,
                                    (char *)&bp->b_flags, sizeof (bp->b_flags))
                                    != sizeof (bp->b_flags)) {
                                        cmdwrterr();
                                        dumpabort();
                                        /*NOTREACHED*/
                                }
                                if (atomic((int(*)())write, arch, bp->b_data,
                                    tp_bsize) != tp_bsize) {
                                        cmdwrterr();
                                        dumpabort();
                                        /*NOTREACHED*/
                                }
                        }
                        if (bp->b_flags & BUF_SPCLREC) {
                                /*LINTED [bp->b_data is aligned]*/
                                sp = (union u_spcl *)bp->b_data;
                                if (sp->s_spcl.c_type != TS_ADDR) {
                                        lastnonaddr = sp->s_spcl.c_type;
                                        lastnonaddrm =
                                                sp->s_spcl.c_dinode.di_mode;
                                        if (sp->s_spcl.c_type != TS_TAPE)
                                                chkpt.sl_offset = 0;
                                }
                                chkpt.sl_count = sp->s_spcl.c_count;
                                bcopy((char *)sp,
                                        (char *)&spcl, sizeof (spcl));
                                mp = recmap;
                                endmp = &recmap[spcl.c_count];
                                count = 0;
                        } else {
                                chkpt.sl_offset++;
                                chkpt.sl_count--;
                                count++;
                                mp++;
                        }
                        /*
                         * Adjust for contiguous hole
                         */
                        for (; mp < endmp; mp++) {
                                if (*mp)
                                        break;
                                chkpt.sl_offset++;
                                chkpt.sl_count--;
                        }
                }
                /*
                 * Check for end of tape
                 */
                if (trecs < ntrec ||
                    (!pipeout && tsize > 0 && asize > tsize)) {
                        if (tapeout)
                                msg(gettext("End-of-tape detected\n"));
                        else
                                msg(gettext("End-of-file detected\n"));
                        (void) sighold(SIGUSR1);
                        caught = 0;
                        (void) kill(master, SIGUSR1);   /* signal EOT */
                        checkpoint(--bp, cmd);  /* send checkpoint data */
                        (void) sigpause(SIGUSR1);
                        break;
                }
                for (bp = begin; bp <= end; bp++)
                        bp->b_flags = BUF_EMPTY;
                if (end + ntrec > last) {
                        bp = begin = bufp;
                        timeest(0, spcl.c_tapea);
                } else
                        bp = begin = end+1;
                end = begin + (ntrec-1);
        }

        free(rbuf);
}

/*
 * Send checkpoint info back to master.  This information
 * consists of the current inode number, number of logical
 * blocks written for that inode (or bitmap), the last logical
 * block number written, the number of logical blocks written
 * to this volume, the current dump state, and the current
 * special record map.
 */
static void
checkpoint(struct bdesc *bp, int cmd)
{
        int     state, type;
        ino_t   ino;

        if (++bp >= &bufp[NBUF*ntrec])
                bp = bufp;

        /*
         * If we are dumping files and the record following
         * the last written to tape is a special record, use
         * it to get an accurate indication of current state.
         */
        if ((bp->b_flags & BUF_SPCLREC) && (bp->b_flags & BUF_FULL) &&
            lastnonaddr == TS_INODE) {
                /*LINTED [bp->b_data is aligned]*/
                union u_spcl *nextspcl = (union u_spcl *)bp->b_data;

                if (nextspcl->s_spcl.c_type == TS_INODE) {
                        chkpt.sl_offset = 0;
                        chkpt.sl_count = 0;
                } else if (nextspcl->s_spcl.c_type == TS_END) {
                        chkpt.sl_offset = 0;
                        chkpt.sl_count = 1;     /* EOT indicator */
                }
                ino = nextspcl->s_spcl.c_inumber;
                type = nextspcl->s_spcl.c_type;
        } else {
                /*
                 * If not, use what we have.
                 */
                ino = spcl.c_inumber;
                type = spcl.c_type;
        }

        switch (type) {         /* set output state */
        case TS_ADDR:
                switch (lastnonaddr) {
                case TS_INODE:
                case TS_TAPE:
                        if ((lastnonaddrm & IFMT) == IFDIR ||
                            (lastnonaddrm & IFMT) == IFATTRDIR)
                                state = DS_DIRS;
                        else
                                state = DS_FILES;
                        break;
                case TS_CLRI:
                        state = DS_CLRI;
                        break;
                case TS_BITS:
                        state = DS_BITS;
                        break;
                }
                break;
        case TS_INODE:
                if ((spcl.c_dinode.di_mode & IFMT) == IFDIR ||
                    (spcl.c_dinode.di_mode & IFMT) == IFATTRDIR)
                        state = DS_DIRS;
                else
                        state = DS_FILES;
                break;
        case 0:                 /* EOT on 1st record */
        case TS_TAPE:
                state = DS_START;
                ino = UFSROOTINO;
                break;
        case TS_CLRI:
                state = DS_CLRI;
                break;
        case TS_BITS:
                state = DS_BITS;
                break;
        case TS_END:
                if (spcl.c_type == TS_END)
                        state = DS_DONE;
                else
                        state = DS_END;
                break;
        }

        /*
         * Checkpoint info to be processed by rollforward():
         *      The inode with which the next volume should begin
         *      The last inode number on this volume
         *      The last logical block number on this volume
         *      The current output state
         *      The offset within the current inode (already in sl_offset)
         *      The number of records left from last spclrec (in sl_count)
         *      The physical block the next vol begins with (in sl_firstrec)
         */
        chkpt.sl_inos = ino;
        chkpt.sl_tapea = spcl.c_tapea + count;
        chkpt.sl_state = state;

        if ((unsigned)atomic((int(*)())write, cmd, (char *)&chkpt,
            sizeof (chkpt)) != sizeof (chkpt)) {
                cmdwrterr();
                dumpabort();
                /*NOTREACHED*/
        }
        if ((unsigned)atomic((int(*)())write, cmd, (char *)&spcl,
            sizeof (spcl)) != sizeof (spcl)) {
                cmdwrterr();
                dumpabort();
                /*NOTREACHED*/
        }
#ifdef DEBUG
        if (xflag) {
                /* XGETTEXT:  #ifdef DEBUG only */
                msg(gettext("sent chkpt to master:\n"));
                msg("    ino %u\n", chkpt.sl_inos);
                msg("    1strec %u\n", chkpt.sl_firstrec);
                msg("    lastrec %u\n", chkpt.sl_tapea);
                msg("    written %u\n", chkpt.sl_offset);
                msg("    left %u\n", chkpt.sl_count);
                msg("    state %d\n", chkpt.sl_state);
        }
#endif
}

/*
 * Since a read from a pipe may not return all we asked for,
 * or a write may not write all we ask if we get a signal,
 * loop until the count is satisfied (or error).
 */
static ssize_t
atomic(int (*func)(), int fd, char *buf, int count)
{
        ssize_t got = 0, need = count;

        /* don't inherit random value if immediately get zero back from func */
        errno = 0;
        while (need > 0) {
                got = (*func)(fd, buf, MIN(need, 4096));
                if (got < 0 && errno == EINTR)
                        continue;
                if (got <= 0)
                        break;
                buf += got;
                need -= got;
        }
        /* if we got what was asked for, return count, else failure (got) */
        return ((need != 0) ? got : count);
}

void
#ifdef __STDC__
positiontape(char *msgbuf)
#else
positiontape(char *msgbuf)
#endif
{
        /* Static as never change, no need to waste stack space */
        static struct mtget mt;
        static struct mtop rew = { MTREW, 1 };
        static struct mtop fsf = { MTFSF, 1 };
        char *info = strdup(gettext("Positioning `%s' to file %ld\n"));
        char *fail = strdup(gettext("Cannot position tape to file %d\n"));
        int m;

        /* gettext()'s return value is volatile, hence the strdup()s */

        m = (access(tape, F_OK) == 0) ? 0 : O_CREAT;

        /*
         * To avoid writing tape marks at inappropriate places, we open the
         * device read-only, position it, close it, and reopen it for writing.
         */
        while ((to = safe_device_open(tape, O_RDONLY|m, 0600)) < 0) {
                if (autoload) {
                        if (!query_once(msgbuf, 1)) {
                                dumpabort();
                                /*NOTREACHED*/
                        }
                } else {
                        if (!query(msgbuf)) {
                                dumpabort();
                                /*NOTREACHED*/
                        }
                }
        }

        if (ioctl(to, MTIOCGET, &mt) >= 0 &&
            ioctl(to, MTIOCTOP, &rew) >= 0 &&
            filenum > 1) {
                msg(info, dumpdev, filenum);
                fsf.mt_count = filenum - 1;
                if (ioctl(to, MTIOCTOP, &fsf) < 0) {
                        msg(fail, filenum);
                        dumpabort();
                        /*NOTREACHED*/
                }
        }
        (void) close(to);
        to = -1;

        free(info);
        free(fail);
}

static void
#ifdef __STDC__
cmdwrterr(void)
#else
cmdwrterr()
#endif
{
        int saverr = errno;
        msg(gettext("Error writing command pipe: %s\n"), strerror(saverr));
}

static void
#ifdef __STDC__
cmdrderr(void)
#else
cmdrderr()
#endif
{
        int saverr = errno;
        msg(gettext("Error reading command pipe: %s\n"), strerror(saverr));
}