xref: /onnv-gate/usr/src/cmd/backup/dump/dumptape.c (revision 1053)

/*
 * 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 2005 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.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include "dump.h"
#include <rmt.h>
#include <setjmp.h>
#include <sys/fdio.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((char *)0, 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*/
		}

		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 = (ino32_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 = (ino32_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;

	if (host != NULL)	/* we set the host only once in ufsdump */
		return;

	host = NULL;
	if (strchr(tape, ':')) {
		if (diskette) {
			msg(gettext("Cannot do remote dump to diskette\n"));
			Exit(X_ABORT);
		}
		host = tape;
		tape = strchr(host, ':');
		*tape++ = 0;
		cp = strchr(host, '@');	/* user@host? */
		if (cp != (char *)0)
			cp++;
		else
			cp = host;
	} else
		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 != (char *)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;
	char    *c;
	int	unit;
	int	rewind;

	if (host) {
		c = strrchr(tape, '/');
		if (c == NULL)
			c = tape;
		else
			c++;
		/*
		 * If the last component begins or ends with an 'n', it is
		 * assumed to be a non-rewind device.
		 */
		if (c[0] == 'n' || c[strlen(c)-1] == 'n')
			rewind = 0;
		else if ((strstr(tape, "mt") || strstr(tape, "st")) &&
		    sscanf(tape, "%*[a-zA-Z/]%d", &unit) == 1 &&
		    (unit & MT_NOREWIND))
			rewind = 0;
		else
			rewind = 1;
	} else {
		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.
		 */
		if (host) {
			(void) rmtioctl(MTBSR, 1);
			if (rmtioctl(MTEOM, 1) < 0)
				(void) rmtioctl(MTFSF, 1);
		} else {
			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();
		if (host)
			rmtclose();
		else {
			(void) close(to);
			to = -1;
		}
	}
}

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 (host) {
		if (offline || autoload)
			(void) rmtioctl(MTOFFL, 0);
		rmtclose();
	} else {
		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);
	if (host) {
		char	*rhost = host;
		char	*cp = strchr(host, '@');
		if (cp == (char *)0)
			cp = host;
		else
			cp++;

		if (rmthost(rhost, ntrec) == 0) {
			msg(gettext("Cannot connect to tape host `%s'\n"), cp);
			dumpabort();
			/*NOTREACHED*/
		}
		if (rhost != host)
			free(rhost);
	}

	/*
	 * 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((time_t *)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++) {
			if (host) {
				if (rmtopen(tape, O_RDONLY) >= 0) {
					rmtclose();
					return;
				}
			} else {
				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, (struct sigvec *)0);

	parentpid = getpid();

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

	sv.sv_handler = interrupt;
	(void) sigvec(SIGINT, &sv, (struct sigvec *)0);
	(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, (struct sigvec *)0);
		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, (struct sigvec *)0);
			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 = host ? rmtopen(tape, O_RDONLY) :
			    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.
			 */
			if (host) {
				if (rmtioctl(MTBSF, 2) >= 0)
					(void) rmtioctl(MTFSF, 1);
				else
					(void) rmtioctl(MTNBSF, 1);
			} else {
				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 = host ? rmtopen(tape, O_WRONLY) :
				    safe_device_open(tape, O_WRONLY, 0600)) < 0)
					(void) sleep(10);
				(void) alarm(0);
				(void) sigvec(SIGALRM, &osv,
				    (struct sigvec *)0);
			} 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 = host ?
				    rmtopen(tape, O_WRONLY) :
				    safe_device_open(tape, O_WRONLY|m, 0600))
				    < 0)
					if (!query_once(buf, 1)) {
						dumpabort();
						/*NOTREACHED*/
					}
			}
		}
		if (!pipeout) {
			tapeout = host ? rmtstatus(&mt) >= 0 :
			    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)
			(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, (struct sigvec *)0);
	sv.sv_handler = tperror;
	(void) sigvec(SIGUSR2, &sv, (struct sigvec *)0);
	sv.sv_handler = proceed;
	(void) sigvec(SIGUSR1, &sv, (struct sigvec *)0);
	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, (struct sigvec *)0);
			sv.sv_handler = SIG_IGN;	/* master handler INT */
			(void) sigvec(SIGINT, &sv, (struct sigvec *)0);
			sv.sv_handler = die;		/* normal slave exit */
			(void) sigvec(SIGTERM, &sv, (struct sigvec *)0);

			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, (struct sigvec *)0);
	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 (host) {
			if (!doingverify)
				siz = rmtwrite(tp, writesize);
			else if ((siz = rmtread(rbuf, writesize)) ==
			    writesize && bcmp(rbuf, tp, writesize))
				siz = -1;
		} else {
			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);
	}

	if (rbuf != NULL)
		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 = host ? rmtopen(tape, O_RDONLY) :
	    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 (host) {
		if (rmtstatus(&mt) >= 0 &&
		    rmtioctl(MTREW, 1) >= 0 &&
		    filenum > 1) {
			msg(info, dumpdev, filenum);
			if (rmtioctl(MTFSF, filenum-1) < 0) {
				msg(fail, filenum);
				dumpabort();
				/*NOTREACHED*/
			}
		}
		rmtclose();
	} else {
		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));
}