#ifndef lint
static const char rcsid[] =
- "$Id: tape.c,v 1.34 2001/03/19 13:22:48 stelian Exp $";
+ "$Id: tape.c,v 1.56 2001/09/12 09:02:51 stelian Exp $";
#endif /* not lint */
#include <config.h>
+#include <compatlfs.h>
#include <errno.h>
#include <fcntl.h>
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>
#include <compaterr.h>
+#include <system.h>
#ifdef __STDC__
#include <stdlib.h>
#include <string.h>
#ifdef __linux__
#include <sys/types.h>
+#include <sys/time.h>
#include <time.h>
-#include <linux/types.h>
#endif
#include <sys/param.h>
#include <sys/socket.h>
-#include <sys/time.h>
#include <sys/wait.h>
+#include <sys/mtio.h>
#ifdef __linux__
+#include <linux/fs.h>
+#undef atomic_read /* this get wrongly defined in kernel */
+ /* headers and we don't want it */
+#ifdef HAVE_EXT2FS_EXT2_FS_H
+#include <ext2fs/ext2_fs.h>
+#else
#include <linux/ext2_fs.h>
+#endif
#include <ext2fs/ext2fs.h>
#include <bsdcompat.h>
#elif defined sunos
#include <zlib.h>
#endif /* HAVE_ZLIB */
+#ifdef HAVE_BZLIB
+#include <bzlib.h>
+#endif /* HAVE_BZLIB */
+
#include "dump.h"
int writesize; /* size of malloc()ed buffer for tape */
static ssize_t atomic_read __P((int, void *, size_t));
static ssize_t atomic_write __P((int, const void *, size_t));
-static void doslave __P((int, int));
+static void doslave __P((int, int, int));
static void enslave __P((void));
static void flushtape __P((void));
static void killall __P((void));
static void rollforward __P((void));
-static int system_command __P((const char *, const char *, int));
/*
* Concurrent dump mods (Caltech) - disk block reading and tape writing
/* received the SIGUSR2 signal from the prev slave? */
static sigjmp_buf jmpbuf; /* where to jump to if we are ready when the */
/* SIGUSR2 arrives from the previous slave */
+#ifdef USE_QFA
+static int gtperr = 0;
+#endif
int
alloctape(void)
quit("Cannot recover\n");
/* NOTREACHED */
}
- msg("write error %d blocks into volume %d: %s\n", blocksthisvol, tapeno, strerror(errnum));
+ msg("write error %d blocks into volume %d: %s\n",
+ blocksthisvol, tapeno, strerror(errnum));
broadcast("DUMP WRITE ERROR!\n");
if (query("Do you want to rewrite this volume?")) {
msg("Closing this volume. Prepare to restart with new media;\n");
time_t tnow, ttaken;
int blocks;
-#ifdef __linux__
- (void)time4(&tnow);
-#else
- (void)time(&tnow);
-#endif
+ tnow = time(NULL);
ttaken = tnow - tstart_volume;
blocks = spcl.c_tapea - tapea_volume;
- msg("Volume %d completed at: %s", tapeno,
-#ifdef __linux__
- ctime4(&tnow));
-#else
- ctime(&tnow));
-#endif
+ msg("Volume %d completed at: %s", tapeno, ctime(&tnow));
if (! compressed)
msg("Volume %d %ld tape blocks (%.2fMB)\n", tapeno,
blocks, ((double)blocks * TP_BSIZE / 1048576));
long txfrate = volkb / ttaken;
msg("Volume %d took %d:%02d:%02d\n", tapeno,
ttaken / 3600, (ttaken % 3600) / 60, ttaken % 60);
- msg("Volume %d transfer rate: %ld KB/s\n", tapeno,
+ msg("Volume %d transfer rate: %ld kB/s\n", tapeno,
txfrate);
xferrate += txfrate;
if (compressed) {
double rate = .0005 + (double) blocks / (double) volkb;
- msg("Volume %d %ldKB uncompressed, %ldKB compressed,"
- " compression ratio %1.3f\n",
+ msg("Volume %d %ldkB uncompressed, %ldkB compressed,"
+ " %1.3f:1\n",
tapeno, blocks, volkb, rate);
}
}
/ blockswritten * tapesize;
if (tnow > tstart_volume)
(void)snprintf(msgbuf, sizeof(msgbuf),
- "%3.2f%% done at %ld KB/s, finished in %d:%02d\n",
+ "%3.2f%% done at %ld kB/s, finished in %d:%02d\n",
(blockswritten * 100.0) / tapesize,
(spcl.c_tapea - tapea_volume) / (tnow - tstart_volume),
(int)(deltat / 3600), (int)((deltat % 3600) / 60));
void
statussig(int notused)
{
- time_t tnow;
int save_errno = errno;
char *buf;
-#ifdef __linux__
- (void) time4(&tnow);
-#else
- (void) time((time_t *) &tnow);
-#endif
- buf = mktimeest(tnow);
+ buf = mktimeest(time(NULL));
if (buf)
write(STDERR_FILENO, buf, strlen(buf));
errno = save_errno;
uncomprblks++;
slp->sent = 0;
- /* Check for errors */
- if (got < 0)
- tperror(-got);
-
- /* Check for end of tape */
- if (got == 0) {
- msg("End of tape detected\n");
+ /* Check for errors or end of tape */
+ if (got <= 0) {
+ /* Check for errors */
+ if (got < 0)
+ tperror(-got);
+ else
+ msg("End of tape detected\n");
/*
* Drain the results, don't care what the values were.
asize += tenths + returned.clen / density;
blockswritten += ntrec;
blocksthisvol += ntrec;
- if (!pipeout && !unlimited && (blocksperfile ?
- (blocksthisvol >= blocksperfile) : (asize > tsize))) {
- close_rewind();
- startnewtape(0);
- }
- timeest();
-}
-
-/*
- * Executes the command in a shell.
- * Returns -1 if an error occured, the exit status of
- * the command on success.
- */
-int system_command(const char *command, const char *device, int volnum) {
- int pid, status;
- char commandstr[4096];
-
- pid = fork();
- if (pid == -1) {
- perror(" DUMP: unable to fork");
- return -1;
- }
- if (pid == 0) {
- setuid(getuid());
- setgid(getgid());
-#if OLD_STYLE_FSCRIPT
- snprintf(commandstr, sizeof(commandstr), "%s", command);
-#else
- snprintf(commandstr, sizeof(commandstr), "%s %s %d", command, device, volnum);
-#endif
- commandstr[sizeof(commandstr) - 1] = '\0';
- execl("/bin/sh", "sh", "-c", commandstr, NULL);
- perror(" DUMP: unable to execute shell");
- exit(-1);
- }
- do {
- if (waitpid(pid, &status, 0) == -1) {
- if (errno != EINTR) {
- perror(" DUMP: waitpid error");
- return -1;
+ if (!pipeout && !unlimited) {
+ if (blocksperfile) {
+ if ( compressed ? (bytes_written - tapea_bytes + SLAVES * (writesize + sizeof(struct tapebuf))) >= blocksperfile * 1024
+ : blocksthisvol >= blocksperfile ) {
+ close_rewind();
+ startnewtape(0);
}
- } else {
- if (WIFEXITED(status))
- return WEXITSTATUS(status);
- else
- return -1;
}
- } while(1);
+ else if (asize > tsize) {
+ close_rewind();
+ startnewtape(0);
+ }
+ }
+ timeest();
}
time_t
#endif
{
(void) close(tapefd);
- while ((f = open(tape, 0)) < 0)
- sleep (10);
- (void) close(f);
+ if (!fifoout) {
+ while ((f = OPEN(tape, 0)) < 0)
+ sleep (10);
+ (void) close(f);
+ }
}
eot_code = 1;
if (eot_script && spcl.c_type != TS_END) {
void
rollforward(void)
{
- register struct req *p, *q, *prev;
+ register struct req *p, *q = NULL, *prev;
register struct slave *tslp;
int i, size, savedtapea, got;
union u_spcl *ntb, *otb;
parentpid = getpid();
tapea_volume = spcl.c_tapea;
tapea_bytes = bytes_written;
-#ifdef __linux__
- (void)time4(&tstart_volume);
-#else
- (void)time((&tstart_volume);
-#endif
+ tstart_volume = time(NULL);
restore_check_point:
#ifdef __linux__
#ifdef RDUMP
while ((tapefd = (host ? rmtopen(tape, 2) : pipeout ?
fileno(stdout) :
- open(tape, O_WRONLY|O_CREAT, 0666))) < 0)
+ OPEN(tape, O_WRONLY|O_CREAT, 0666))) < 0)
#else
while ((tapefd = (pipeout ? fileno(stdout) :
- open(tape, O_WRONLY|O_CREAT, 0666))) < 0)
+ OPEN(tape, O_RDWR|O_CREAT, 0666))) < 0)
#endif
{
msg("Cannot open output \"%s\".\n", tape);
spcl.c_volume++;
spcl.c_type = TS_TAPE;
spcl.c_flags |= DR_NEWHEADER;
+ spcl.c_ntrec = ntrec;
if (compressed)
spcl.c_flags |= DR_COMPRESSED;
- writeheader((ino_t)slp->inode);
+ writeheader((dump_ino_t)slp->inode);
spcl.c_flags &=~ DR_NEWHEADER;
- msg("Volume %d started at: %s", tapeno,
-#ifdef __linux__
- ctime4(&tstart_volume));
-#else
- ctime(&tstart_volume));
-#endif
+ msg("Volume %d started with block %ld at: %s", tapeno,
+ spcl.c_tapea, ctime(&tstart_volume));
if (tapeno > 1)
msg("Volume %d begins with blocks from inode %d\n",
tapeno, slp->inode);
!= sizeof i)
quit("master/slave protocol botched 3\n");
#endif
- doslave(cmd[0], i);
+ doslave(cmd[0], i, (slaves[i].pid == slp->pid));
Exit(X_FINOK);
}
+ else
+ close(cmd[0]);
}
#ifdef LINUX_FORK_BUG
* slaves.
*/
static void
-doslave(int cmd, int slave_number)
+doslave(int cmd, int slave_number, int first)
{
register int nread;
int nextslave, size, eot_count, bufsize;
volatile int wrote = 0;
char *buffer;
-#ifdef HAVE_ZLIB
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
struct tapebuf *comp_buf = NULL;
- int compresult, complevel = 6, do_compress = 0;
+ int compresult, do_compress = !first;
unsigned long worklen;
-#endif /* HAVE_ZLIB */
+#ifdef HAVE_BZLIB
+ unsigned int worklen2;
+#endif
+#endif /* HAVE_ZLIB || HAVE_BZLIB */
struct slave_results returns;
#ifdef __linux__
errcode_t retval;
#endif
+#ifdef USE_QFA
+ long curtapepos;
+ union u_spcl *uspclptr;
+ struct s_spcl *spclptr;
+#endif /* USE_QFA */
/*
* Need our own seek pointer.
*/
(void) close(diskfd);
- if ((diskfd = open(disk, O_RDONLY)) < 0)
+ if ((diskfd = OPEN(disk, O_RDONLY)) < 0)
quit("slave couldn't reopen disk: %s\n", strerror(errno));
#ifdef __linux__
+#ifdef BLKFLSBUF
+ (void)ioctl(diskfd, BLKFLSBUF);
+#endif
ext2fs_close(fs);
retval = dump_fs_open(disk, &fs);
if (retval)
quit("master/slave protocol botched - didn't get pid of next slave.\n");
}
-#ifdef HAVE_ZLIB
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
/* if we're doing a compressed dump, allocate the compress buffer */
if (compressed) {
comp_buf = malloc(sizeof(struct tapebuf) + TP_BSIZE + writesize);
if (comp_buf == NULL)
quit("couldn't allocate a compress buffer.\n");
- comp_buf->flags = 0;
+ if (bzipflag)
+ comp_buf->flags = COMPRESS_BZLIB;
+ else
+ comp_buf->flags = COMPRESS_ZLIB;
}
-#endif /* HAVE_ZLIB */
+#endif /* HAVE_ZLIB || HAVE_BZLIB */
/*
* Get list of blocks to dump, read the blocks into tape buffer
quit("master/slave protocol botched.\n");
}
}
- if (sigsetjmp(jmpbuf, 1) == 0) {
- ready = 1;
- if (!caught)
- (void) pause();
- }
- ready = 0;
- caught = 0;
/* Try to write the data... */
wrote = 0;
bufsize = writesize; /* length to write */
returns.clen = returns.unclen = bufsize;
-#ifdef HAVE_ZLIB
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
/*
- * The first NR_SLAVE blocks are not compressed.
- * When writing a compressed dump, each block is
- * written from struct tapebuf with an 4 byte prefix
+ * When writing a compressed dump, each block except
+ * the first one on each tape is written
+ * from struct tapebuf with an 4 byte prefix
* followed by the data. This can be less than
* writesize. Restore, on a short read, can compare the
* length read to the compressed length in the header
* to verify that the read was good. Blocks which don't
* compress well are written uncompressed.
+ * The first block written by each slave is not compressed
+ * and does not have a prefix.
*/
- if (compressed) {
+ if (compressed && do_compress) {
comp_buf->length = bufsize;
worklen = TP_BSIZE + writesize;
- if (do_compress)
- compresult = compress2(comp_buf->buf, &worklen,
- (char *)slp->tblock[0], writesize, complevel);
- if (compresult == Z_OK && worklen <= writesize-32) {
+#ifdef HAVE_ZLIB
+ if (!bzipflag) {
+ compresult = compress2(comp_buf->buf,
+ &worklen,
+ (char *)slp->tblock[0],
+ writesize,
+ compressed);
+ if (compresult == Z_OK)
+ compresult = 1;
+ else
+ compresult = 0;
+ }
+#endif /* HAVE_ZLIB */
+#ifdef HAVE_BZLIB
+ if (bzipflag) {
+ worklen2 = worklen;
+ compresult = BZ2_bzBuffToBuffCompress(
+ comp_buf->buf,
+ &worklen2,
+ (char *)slp->tblock[0],
+ writesize,
+ compressed,
+ 0, 30);
+ worklen = worklen2;
+ if (compresult == BZ_OK)
+ compresult = 1;
+ else
+ compresult = 0;
+ }
+
+#endif /* HAVE_BZLIB */
+ if (compresult && worklen <= (writesize - 16)) {
/* write the compressed buffer */
comp_buf->length = worklen;
comp_buf->compressed = 1;
memcpy(comp_buf->buf, (char *)slp->tblock[0], writesize);
}
}
- /* compress the remaining blocks */
+ /* compress the remaining blocks if we're compressing */
do_compress = compressed;
-#endif /* HAVE_ZLIB */
+#endif /* HAVE_ZLIB || HAVE_BZLIB */
+
+ if (sigsetjmp(jmpbuf, 1) == 0) {
+ ready = 1;
+ if (!caught)
+ (void) pause();
+ }
+ ready = 0;
+ caught = 0;
+#ifdef USE_QFA
+ if (gTapeposfd >= 0) {
+ uspclptr = (union u_spcl *)&slp->tblock[0];
+ spclptr = &uspclptr->s_spcl;
+ if ((spclptr->c_magic == NFS_MAGIC) &&
+ (spclptr->c_type == TS_INODE) &&
+ (spclptr->c_date == gThisDumpDate)) {
+ /* if an error occured previously don't
+ * try again */
+ if (gtperr == 0) {
+ if ((gtperr = GetTapePos(&curtapepos)) == 0) {
+#ifdef DEBUG_QFA
+ msg("inode %ld at tapepos %ld\n", spclptr->c_inumber, curtapepos);
+#endif
+ sprintf(gTps, "%ld\t%d\t%ld\n", (unsigned long)spclptr->c_inumber, tapeno, curtapepos);
+ if (write(gTapeposfd, gTps, strlen(gTps)) != strlen(gTps)) {
+ warn("error writing tapepos file.\n");
+ }
+ }
+ }
+ }
+ }
+#endif /* USE_QFA */
+
while (eot_count < 10 && size < bufsize) {
#ifdef RDUMP
if (host)
} while (got == -1 && errno == EINTR);
return (got < 0 ? got : count - need);
}
+
+
+#ifdef USE_QFA
+/*
+ * read the current tape position
+ */
+int
+GetTapePos(long *pos)
+{
+ int err = 0;
+
+ *pos = 0;
+ if (ioctl(tapefd, MTIOCPOS, pos) == -1) {
+ err = errno;
+ msg("[%ld] error: %d (getting tapepos: %ld)\n", getpid(),
+ err, *pos);
+ return err;
+ }
+ return err;
+}
+#endif /* USE_QFA */
git.wh0rd.org / dump.git / blobdiff