577 lines
15 KiB
C
577 lines
15 KiB
C
/*-
|
|
* Copyright (c) 1980, 1991 The Regents of the University of California.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
/*static char sccsid[] = "from: @(#)dumptape.c 5.18 (Berkeley) 4/24/91";*/
|
|
static char rcsid[] = "$Id: dumptape.c,v 1.4 1993/08/01 18:27:43 mycroft Exp $";
|
|
#endif /* not lint */
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/wait.h>
|
|
#include <ufs/dir.h>
|
|
#include <ufs/dinode.h>
|
|
#include <ufs/fs.h>
|
|
#include <signal.h>
|
|
#include <fcntl.h>
|
|
#include <protocols/dumprestore.h>
|
|
#include <errno.h>
|
|
#ifdef __STDC__
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#endif
|
|
#include "dump.h"
|
|
#include "pathnames.h"
|
|
|
|
char (*tblock)[TP_BSIZE]; /* pointer to malloc()ed buffer for tape */
|
|
int writesize; /* size of malloc()ed buffer for tape */
|
|
long lastspclrec = -1; /* tape block number of last written header */
|
|
int trecno = 0; /* next record to write in current block */
|
|
extern long blocksperfile; /* number of blocks per output file */
|
|
long blocksthisvol; /* number of blocks on current output file */
|
|
extern int ntrec; /* blocking factor on tape */
|
|
extern int cartridge;
|
|
char *nexttape;
|
|
#ifdef RDUMP
|
|
extern char *host;
|
|
int rmtopen(), rmtwrite();
|
|
void rmtclose();
|
|
#endif RDUMP
|
|
|
|
int atomic();
|
|
void doslave(), enslave(), flushtape(), killall();
|
|
|
|
/*
|
|
* Concurrent dump mods (Caltech) - disk block reading and tape writing
|
|
* are exported to several slave processes. While one slave writes the
|
|
* tape, the others read disk blocks; they pass control of the tape in
|
|
* a ring via flock(). The parent process traverses the filesystem and
|
|
* sends writeheader()'s and lists of daddr's to the slaves via pipes.
|
|
*/
|
|
struct req { /* instruction packets sent to slaves */
|
|
daddr_t dblk;
|
|
int count;
|
|
} *req;
|
|
int reqsiz;
|
|
|
|
#define SLAVES 3 /* 1 slave writing, 1 reading, 1 for slack */
|
|
int slavefd[SLAVES]; /* pipes from master to each slave */
|
|
int slavepid[SLAVES]; /* used by killall() */
|
|
int rotor; /* next slave to be instructed */
|
|
int master; /* pid of master, for sending error signals */
|
|
int tenths; /* length of tape used per block written */
|
|
|
|
int
|
|
alloctape()
|
|
{
|
|
int pgoff = getpagesize() - 1;
|
|
|
|
writesize = ntrec * TP_BSIZE;
|
|
reqsiz = ntrec * sizeof(struct req);
|
|
/*
|
|
* CDC 92181's and 92185's make 0.8" gaps in 1600-bpi start/stop mode
|
|
* (see DEC TU80 User's Guide). The shorter gaps of 6250-bpi require
|
|
* repositioning after stopping, i.e, streaming mode, where the gap is
|
|
* variable, 0.30" to 0.45". The gap is maximal when the tape stops.
|
|
*/
|
|
if (blocksperfile == 0)
|
|
tenths = writesize / density +
|
|
(cartridge ? 16 : density == 625 ? 5 : 8);
|
|
/*
|
|
* Allocate tape buffer contiguous with the array of instruction
|
|
* packets, so flushtape() can write them together with one write().
|
|
* Align tape buffer on page boundary to speed up tape write().
|
|
*/
|
|
req = (struct req *)malloc(reqsiz + writesize + pgoff);
|
|
if (req == NULL)
|
|
return(0);
|
|
tblock = (char (*)[TP_BSIZE]) (((long)&req[ntrec] + pgoff) &~ pgoff);
|
|
req = (struct req *)tblock - ntrec;
|
|
return(1);
|
|
}
|
|
|
|
|
|
void
|
|
writerec(dp)
|
|
char *dp;
|
|
{
|
|
req[trecno].dblk = (daddr_t)0;
|
|
req[trecno].count = 1;
|
|
*(union u_spcl *)(*tblock++) = *(union u_spcl *)dp; /* movc3 */
|
|
lastspclrec = spcl.c_tapea;
|
|
trecno++;
|
|
spcl.c_tapea++;
|
|
if (trecno >= ntrec)
|
|
flushtape();
|
|
}
|
|
|
|
void
|
|
dumpblock(blkno, size)
|
|
daddr_t blkno;
|
|
int size;
|
|
{
|
|
int avail, tpblks, dblkno;
|
|
|
|
dblkno = fsbtodb(sblock, blkno);
|
|
tpblks = size >> tp_bshift;
|
|
while ((avail = MIN(tpblks, ntrec - trecno)) > 0) {
|
|
req[trecno].dblk = dblkno;
|
|
req[trecno].count = avail;
|
|
trecno += avail;
|
|
spcl.c_tapea += avail;
|
|
if (trecno >= ntrec)
|
|
flushtape();
|
|
dblkno += avail << (tp_bshift - dev_bshift);
|
|
tpblks -= avail;
|
|
}
|
|
}
|
|
|
|
int nogripe = 0;
|
|
|
|
void
|
|
tperror()
|
|
{
|
|
if (pipeout) {
|
|
msg("write error on %s\n", tape);
|
|
quit("Cannot recover\n");
|
|
/* NOTREACHED */
|
|
}
|
|
msg("write error %d blocks into volume %d\n", blocksthisvol, tapeno);
|
|
broadcast("DUMP WRITE ERROR!\n");
|
|
if (!query("Do you want to restart?"))
|
|
dumpabort();
|
|
msg("Closing this volume. Prepare to restart with new media;\n");
|
|
msg("this dump volume will be rewritten.\n");
|
|
killall();
|
|
nogripe = 1;
|
|
close_rewind();
|
|
Exit(X_REWRITE);
|
|
}
|
|
|
|
void
|
|
sigpipe()
|
|
{
|
|
|
|
quit("Broken pipe\n");
|
|
}
|
|
|
|
void
|
|
flushtape()
|
|
{
|
|
#ifndef __STDC__
|
|
int write();
|
|
#endif
|
|
|
|
int siz = (char *)tblock - (char *)req;
|
|
|
|
if (atomic(write, slavefd[rotor], req, siz) != siz)
|
|
quit("error writing command pipe: %s\n", strerror(errno));
|
|
if (++rotor >= SLAVES)
|
|
rotor = 0;
|
|
tblock = (char (*)[TP_BSIZE]) &req[ntrec];
|
|
trecno = 0;
|
|
asize += tenths;
|
|
blockswritten += ntrec;
|
|
blocksthisvol += ntrec;
|
|
if (!pipeout && (blocksperfile ?
|
|
(blocksthisvol >= blocksperfile) : (asize > tsize))) {
|
|
close_rewind();
|
|
startnewtape();
|
|
}
|
|
timeest();
|
|
}
|
|
|
|
void
|
|
trewind()
|
|
{
|
|
int f;
|
|
|
|
if (pipeout)
|
|
return;
|
|
for (f = 0; f < SLAVES; f++)
|
|
close(slavefd[f]);
|
|
while (wait((int *)NULL) >= 0) /* wait for any signals from slaves */
|
|
/* void */;
|
|
msg("Closing %s\n", tape);
|
|
#ifdef RDUMP
|
|
if (host) {
|
|
rmtclose();
|
|
while (rmtopen(tape, 0) < 0)
|
|
sleep(10);
|
|
rmtclose();
|
|
return;
|
|
}
|
|
#endif RDUMP
|
|
close(tapefd);
|
|
while ((f = open(tape, 0)) < 0)
|
|
sleep (10);
|
|
close(f);
|
|
}
|
|
|
|
void
|
|
close_rewind()
|
|
{
|
|
trewind();
|
|
if (nexttape)
|
|
return;
|
|
if (!nogripe) {
|
|
msg("Change Volumes: Mount volume #%d\n", tapeno+1);
|
|
broadcast("CHANGE DUMP VOLUMES!\7\7\n");
|
|
}
|
|
while (!query("Is the new volume mounted and ready to go?"))
|
|
if (query("Do you want to abort?")) {
|
|
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
|
|
startnewtape()
|
|
{
|
|
int parentpid;
|
|
int childpid;
|
|
int status;
|
|
int waitpid;
|
|
sig_t interrupt;
|
|
int blks, i;
|
|
char *p;
|
|
|
|
interrupt = signal(SIGINT, SIG_IGN);
|
|
parentpid = getpid();
|
|
|
|
restore_check_point:
|
|
(void)signal(SIGINT, interrupt);
|
|
/*
|
|
* All signals are inherited...
|
|
*/
|
|
childpid = fork();
|
|
if (childpid < 0) {
|
|
msg("Context save fork fails in parent %d\n", parentpid);
|
|
Exit(X_ABORT);
|
|
}
|
|
if (childpid != 0) {
|
|
/*
|
|
* PARENT:
|
|
* save the context by waiting
|
|
* until the child doing all of the work returns.
|
|
* don't catch the interrupt
|
|
*/
|
|
signal(SIGINT, SIG_IGN);
|
|
#ifdef TDEBUG
|
|
msg("Tape: %d; parent process: %d child process %d\n",
|
|
tapeno+1, parentpid, childpid);
|
|
#endif TDEBUG
|
|
while ((waitpid = wait(&status)) != childpid)
|
|
msg("Parent %d waiting for child %d has another child %d return\n",
|
|
parentpid, childpid, waitpid);
|
|
if (status & 0xFF) {
|
|
msg("Child %d returns LOB status %o\n",
|
|
childpid, status&0xFF);
|
|
}
|
|
status = (status >> 8) & 0xFF;
|
|
#ifdef TDEBUG
|
|
switch(status) {
|
|
case X_FINOK:
|
|
msg("Child %d finishes X_FINOK\n", childpid);
|
|
break;
|
|
case X_ABORT:
|
|
msg("Child %d finishes X_ABORT\n", childpid);
|
|
break;
|
|
case X_REWRITE:
|
|
msg("Child %d finishes X_REWRITE\n", childpid);
|
|
break;
|
|
default:
|
|
msg("Child %d finishes unknown %d\n",
|
|
childpid, status);
|
|
break;
|
|
}
|
|
#endif TDEBUG
|
|
switch(status) {
|
|
case X_FINOK:
|
|
Exit(X_FINOK);
|
|
case X_ABORT:
|
|
Exit(X_ABORT);
|
|
case X_REWRITE:
|
|
goto restore_check_point;
|
|
default:
|
|
msg("Bad return code from dump: %d\n", status);
|
|
Exit(X_ABORT);
|
|
}
|
|
/*NOTREACHED*/
|
|
} else { /* we are the child; just continue */
|
|
#ifdef TDEBUG
|
|
sleep(4); /* allow time for parent's message to get out */
|
|
msg("Child on Tape %d has parent %d, my pid = %d\n",
|
|
tapeno+1, parentpid, getpid());
|
|
#endif TDEBUG
|
|
/*
|
|
* If we have a name like "/dev/rmt0,/dev/rmt1",
|
|
* use the name before the comma first, and save
|
|
* the remaining names for subsequent volumes.
|
|
*/
|
|
tapeno++; /* current tape sequence */
|
|
if (nexttape || index(tape, ',')) {
|
|
if (nexttape && *nexttape)
|
|
tape = nexttape;
|
|
if (p = index(tape, ',')) {
|
|
*p = '\0';
|
|
nexttape = p + 1;
|
|
} else
|
|
nexttape = NULL;
|
|
msg("Dumping volume %d on %s\n", tapeno, tape);
|
|
}
|
|
#ifdef RDUMP
|
|
while ((tapefd = (host ? rmtopen(tape, 2) :
|
|
pipeout ? 1 : open(tape, O_WRONLY|O_CREAT, 0666))) < 0)
|
|
#else RDUMP
|
|
while ((tapefd =
|
|
pipeout ? 1 : open(tape, O_WRONLY|O_CREAT, 0666)) < 0)
|
|
#endif RDUMP
|
|
{
|
|
msg("Cannot open output \"%s\".\n", tape);
|
|
if (!query("Do you want to retry the open?"))
|
|
dumpabort();
|
|
}
|
|
|
|
enslave(); /* Share open tape file descriptor with slaves */
|
|
|
|
asize = 0;
|
|
blocksthisvol = 0;
|
|
newtape++; /* new tape signal */
|
|
blks = 0;
|
|
if (spcl.c_type != TS_END)
|
|
for (i = 0; i < spcl.c_count; i++)
|
|
if (spcl.c_addr[i] != 0)
|
|
blks++;
|
|
spcl.c_count = blks + 1 - spcl.c_tapea + lastspclrec;
|
|
spcl.c_volume++;
|
|
spcl.c_type = TS_TAPE;
|
|
spcl.c_flags |= DR_NEWHEADER;
|
|
writeheader(curino);
|
|
spcl.c_flags &=~ DR_NEWHEADER;
|
|
if (tapeno > 1)
|
|
msg("Volume %d begins with blocks from inode %d\n",
|
|
tapeno, curino);
|
|
}
|
|
}
|
|
|
|
void
|
|
dumpabort()
|
|
{
|
|
if (master != 0 && master != getpid())
|
|
kill(master, SIGTERM); /* Signals master to call dumpabort */
|
|
else {
|
|
killall();
|
|
msg("The ENTIRE dump is aborted.\n");
|
|
}
|
|
Exit(X_ABORT);
|
|
}
|
|
|
|
void
|
|
Exit(status)
|
|
int status;
|
|
{
|
|
#ifdef TDEBUG
|
|
msg("pid = %d exits with status %d\n", getpid(), status);
|
|
#endif TDEBUG
|
|
exit(status);
|
|
}
|
|
|
|
/*
|
|
* could use pipe() for this if flock() worked on pipes
|
|
*/
|
|
void
|
|
lockfile(fd)
|
|
int fd[2];
|
|
{
|
|
char tmpname[20];
|
|
|
|
strcpy(tmpname, _PATH_LOCK);
|
|
mktemp(tmpname);
|
|
if ((fd[1] = creat(tmpname, 0400)) < 0)
|
|
quit("cannot create lockfile %s: %s\n",
|
|
tmpname, strerror(errno));
|
|
if ((fd[0] = open(tmpname, 0)) < 0)
|
|
quit("cannot reopen lockfile %s: %s\n",
|
|
tmpname, strerror(errno));
|
|
(void) unlink(tmpname);
|
|
}
|
|
|
|
void
|
|
enslave()
|
|
{
|
|
int first[2], prev[2], next[2], cmd[2]; /* file descriptors */
|
|
register int i, j;
|
|
|
|
master = getpid();
|
|
signal(SIGTERM, dumpabort); /* Slave sends SIGTERM on dumpabort() */
|
|
signal(SIGPIPE, sigpipe);
|
|
signal(SIGUSR1, tperror); /* Slave sends SIGUSR1 on tape errors */
|
|
lockfile(first);
|
|
for (i = 0; i < SLAVES; i++) {
|
|
if (i == 0) {
|
|
prev[0] = first[1];
|
|
prev[1] = first[0];
|
|
} else {
|
|
prev[0] = next[0];
|
|
prev[1] = next[1];
|
|
flock(prev[1], LOCK_EX);
|
|
}
|
|
if (i < SLAVES - 1) {
|
|
lockfile(next);
|
|
} else {
|
|
next[0] = first[0];
|
|
next[1] = first[1]; /* Last slave loops back */
|
|
}
|
|
if (pipe(cmd) < 0 || (slavepid[i] = fork()) < 0)
|
|
quit("too many slaves, %d (recompile smaller): %s\n",
|
|
i, strerror(errno));
|
|
slavefd[i] = cmd[1];
|
|
if (slavepid[i] == 0) { /* Slave starts up here */
|
|
for (j = 0; j <= i; j++)
|
|
close(slavefd[j]);
|
|
signal(SIGINT, SIG_IGN); /* Master handles this */
|
|
doslave(cmd[0], prev, next);
|
|
Exit(X_FINOK);
|
|
}
|
|
close(cmd[0]);
|
|
if (i > 0) {
|
|
close(prev[0]);
|
|
close(prev[1]);
|
|
}
|
|
}
|
|
close(first[0]);
|
|
close(first[1]);
|
|
master = 0; rotor = 0;
|
|
}
|
|
|
|
void
|
|
killall()
|
|
{
|
|
register int i;
|
|
|
|
for (i = 0; i < SLAVES; i++)
|
|
if (slavepid[i] > 0)
|
|
kill(slavepid[i], SIGKILL);
|
|
}
|
|
|
|
/*
|
|
* Synchronization - each process has a lockfile, and shares file
|
|
* descriptors to the following process's lockfile. When our write
|
|
* completes, we release our lock on the following process's lock-
|
|
* file, allowing the following process to lock it and proceed. We
|
|
* get the lock back for the next cycle by swapping descriptors.
|
|
*/
|
|
void
|
|
doslave(cmd, prev, next)
|
|
register int cmd, prev[2], next[2];
|
|
{
|
|
register int nread, toggle = 0;
|
|
int nwrite;
|
|
#ifndef __STDC__
|
|
int read();
|
|
#endif
|
|
|
|
/*
|
|
* Need our own seek pointer.
|
|
*/
|
|
close(diskfd);
|
|
if ((diskfd = open(disk, O_RDONLY)) < 0)
|
|
quit("slave couldn't reopen disk: %s\n", strerror(errno));
|
|
/*
|
|
* Get list of blocks to dump, read the blocks into tape buffer
|
|
*/
|
|
while ((nread = atomic(read, cmd, req, reqsiz)) == reqsiz) {
|
|
register struct req *p = req;
|
|
for (trecno = 0; trecno < ntrec; trecno += p->count, p += p->count) {
|
|
if (p->dblk) {
|
|
bread(p->dblk, tblock[trecno],
|
|
p->count * TP_BSIZE);
|
|
} else {
|
|
if (p->count != 1 || atomic(read, cmd,
|
|
tblock[trecno], TP_BSIZE) != TP_BSIZE)
|
|
quit("master/slave protocol botched.\n");
|
|
}
|
|
}
|
|
flock(prev[toggle], LOCK_EX); /* Wait our turn */
|
|
|
|
#ifdef RDUMP
|
|
if ((nwrite = (host ? rmtwrite(tblock[0], writesize)
|
|
: write(tapefd, tblock[0], writesize))) != writesize) {
|
|
#else RDUMP
|
|
if ((nwrite = write(tapefd, tblock[0], writesize))
|
|
!= writesize) {
|
|
#endif RDUMP
|
|
if (nwrite == -1)
|
|
perror("write");
|
|
else
|
|
msg("short write: got %d instead of %d\n",
|
|
nwrite, writesize);
|
|
kill(master, SIGUSR1);
|
|
for (;;)
|
|
sigpause(0);
|
|
}
|
|
toggle ^= 1;
|
|
flock(next[toggle], LOCK_UN); /* Next slave's turn */
|
|
} /* Also jolts him awake */
|
|
if (nread != 0)
|
|
quit("error reading command pipe: %s\n", strerror(errno));
|
|
}
|
|
|
|
/*
|
|
* 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).
|
|
*/
|
|
int
|
|
atomic(func, fd, buf, count)
|
|
int (*func)(), fd, count;
|
|
char *buf;
|
|
{
|
|
int got, need = count;
|
|
|
|
while ((got = (*func)(fd, buf, need)) > 0 && (need -= got) > 0)
|
|
buf += got;
|
|
return (got < 0 ? got : count - need);
|
|
}
|