* Ported to Linux's Second Extended File System as part of the
* dump and restore backup suit
* Remy Card <card@Linux.EU.Org>, 1994-1997
- * Stelian Pop <pop@cybercable.fr>, 1999-2000
+ * Stelian Pop <pop@noos.fr>, 1999-2000
+ * Stelian Pop <pop@noos.fr> - Alcôve <www.alcove.fr>, 2000
*/
/*-
#ifndef lint
static const char rcsid[] =
- "$Id: tape.c,v 1.22 2000/08/21 10:45:40 stelian Exp $";
+ "$Id: tape.c,v 1.34 2001/03/19 13:22:48 stelian Exp $";
#endif /* not lint */
+#include <config.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdio.h>
+#include <compaterr.h>
+#ifdef __STDC__
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#else
+int write(), read();
+#endif
+
#ifdef __linux__
#include <sys/types.h>
+#include <time.h>
#include <linux/types.h>
#endif
#include <sys/param.h>
#include <sys/wait.h>
#ifdef __linux__
#include <linux/ext2_fs.h>
+#include <ext2fs/ext2fs.h>
#include <bsdcompat.h>
-#else /* __linux__ */
-#ifdef sunos
+#elif defined sunos
#include <sys/vnode.h>
#include <ufs/fs.h>
#else
#include <ufs/ufs/dinode.h>
#include <ufs/ffs/fs.h>
-#endif
#endif /* __linux__ */
#include <protocols/dumprestore.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <setjmp.h>
-#include <signal.h>
-#include <stdio.h>
-#include <compaterr.h>
-#ifdef __STDC__
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#else
-int write(), read();
-#endif
-
-#ifdef __linux__
-#include <ext2fs/ext2fs.h>
-#endif
+#ifdef HAVE_ZLIB
+#include <zlib.h>
+#endif /* HAVE_ZLIB */
#include "dump.h"
char *nexttape;
extern pid_t rshpid;
int eot_code = 1;
+long long tapea_bytes = 0; /* bytes_written at start of current volume */
static ssize_t atomic_read __P((int, void *, size_t));
static ssize_t atomic_write __P((int, const void *, size_t));
};
int reqsiz;
+struct slave_results {
+ ssize_t unclen; /* uncompressed length */
+ ssize_t clen; /* compressed length */
+};
+
#define SLAVES 3 /* 1 slave writing, 1 reading, 1 for slack */
struct slave {
int tapea; /* header number at start of this chunk */
static int tapea_volume; /* value of spcl.c_tapea at volume start */
int master; /* pid of master, for sending error signals */
-int tenths; /* length of tape used per block written */
+int tenths; /* length of tape overhead per block written */
static int caught; /* have we caught the signal to proceed? */
static int ready; /* have we reached the lock point without having */
/* received the SIGUSR2 signal from the prev slave? */
* variable, 0.30" to 0.45". The gap is maximal when the tape stops.
*/
if (blocksperfile == 0 && !unlimited)
- tenths = writesize / density +
- (cartridge ? 16 : density == 625 ? 5 : 8);
+ tenths = (cartridge ? 16 : density == 625 ? 5 : 8);
+ else {
+ tenths = 0;
+ density = 1;
+ }
/*
* Allocate tape buffer contiguous with the array of instruction
* packets, so flushtape() can write them together with one write().
int nogripe = 0;
static void
-tperror(int signo)
+tperror(int errnum)
{
if (pipeout) {
- msg("write error on %s\n", tape);
+ msg("write error on %s: %s\n", tape, strerror(errnum));
quit("Cannot recover\n");
/* NOTREACHED */
}
- msg("write error %d blocks into volume %d\n", blocksthisvol, tapeno);
+ 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 restart?"))
- dumpabort(0);
- 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);
+ if (query("Do you want to rewrite this volume?")) {
+ 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);
+ }
+ if (query("Do you want to start the next tape?"))
+ return;
+ dumpabort(0);
}
static void
#else
ctime(&tnow));
#endif
+ if (! compressed)
+ msg("Volume %d %ld tape blocks (%.2fMB)\n", tapeno,
+ blocks, ((double)blocks * TP_BSIZE / 1048576));
if (ttaken > 0) {
+ long volkb = (bytes_written - tapea_bytes) / 1024;
+ 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,
- blocks / ttaken);
- xferrate += blocks / ttaken;
+ txfrate);
+ xferrate += txfrate;
+ if (compressed) {
+ double rate = .0005 + (double) blocks / (double) volkb;
+ msg("Volume %d %ldKB uncompressed, %ldKB compressed,"
+ " compression ratio %1.3f\n",
+ tapeno, blocks, volkb, rate);
+ }
}
return(tnow);
}
+char *
+mktimeest(time_t tnow)
+{
+ static char msgbuf[128];
+ time_t deltat;
+
+ msgbuf[0] = '\0';
+
+ if (blockswritten < 500)
+ return NULL;
+ if (blockswritten > tapesize)
+ tapesize = blockswritten;
+ deltat = tstart_writing - tnow + (1.0 * (tnow - tstart_writing))
+ / blockswritten * tapesize;
+ if (tnow > tstart_volume)
+ (void)snprintf(msgbuf, sizeof(msgbuf),
+ "%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));
+ else
+ (void)snprintf(msgbuf, sizeof(msgbuf),
+ "%3.2f%% done, finished in %d:%02d\n",
+ (blockswritten * 100.0) / tapesize,
+ (int)(deltat / 3600), (int)((deltat % 3600) / 60));
+
+ return msgbuf;
+}
+
#if defined(SIGINFO)
/*
* statussig --
* information message upon receipt of SIGINFO
- * (derived from optr.c::timeest())
*/
void
statussig(int notused)
{
- time_t tnow, deltat;
- char msgbuf[128];
+ time_t tnow;
int save_errno = errno;
+ char *buf;
- if (blockswritten < 500)
- return;
#ifdef __linux__
(void) time4(&tnow);
#else
(void) time((time_t *) &tnow);
#endif
- if (blockswritten > tapesize)
- tapesize = blockswritten;
- deltat = tstart_writing - tnow + (1.0 * (tnow - tstart_writing))
- / blockswritten * tapesize;
- (void)snprintf(msgbuf, sizeof(msgbuf),
- "%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));
- write(STDERR_FILENO, msgbuf, strlen(msgbuf));
+ buf = mktimeest(tnow);
+ if (buf)
+ write(STDERR_FILENO, buf, strlen(buf));
errno = save_errno;
}
#endif
{
int i, blks, got;
long lastfirstrec;
+ struct slave_results returned;
int siz = (char *)nextblock - (char *)slp->req;
/* Read results back from next slave */
if (slp->sent) {
- if (atomic_read( slp->fd, (char *)&got, sizeof got)
- != sizeof got) {
+ if (atomic_read( slp->fd, (char *)&returned, sizeof returned)
+ != sizeof returned) {
perror(" DUMP: error reading command pipe in master");
dumpabort(0);
}
+ got = returned.unclen;
+ bytes_written += returned.clen;
+ if (returned.unclen == returned.clen)
+ uncomprblks++;
slp->sent = 0;
+ /* Check for errors */
+ if (got < 0)
+ tperror(-got);
+
/* Check for end of tape */
- if (got < writesize) {
+ if (got == 0) {
msg("End of tape detected\n");
/*
for (i = 0; i < SLAVES; i++) {
if (slaves[i].sent) {
if (atomic_read( slaves[i].fd,
- (char *)&got, sizeof got)
- != sizeof got) {
+ (char *)&returned, sizeof returned)
+ != sizeof returned) {
perror(" DUMP: error reading command pipe in master");
dumpabort(0);
}
slp->inode = curino;
nextblock = slp->tblock;
trecno = 0;
- asize += tenths;
+ asize += tenths + returned.clen / density;
blockswritten += ntrec;
blocksthisvol += ntrec;
if (!pipeout && !unlimited && (blocksperfile ?
{
int f;
int got;
+ struct slave_results returned;
for (f = 0; f < SLAVES; f++) {
/*
* fixme: punt for now.
*/
if (slaves[f].sent) {
- if (atomic_read( slaves[f].fd, (char *)&got, sizeof got)
- != sizeof got) {
+ if (atomic_read( slaves[f].fd, (char *)&returned, sizeof returned)
+ != sizeof returned) {
perror(" DUMP: error reading command pipe in master");
dumpabort(0);
}
+ got = returned.unclen;
+ bytes_written += returned.clen;
+ if (returned.unclen == returned.clen)
+ uncomprblks++;
slaves[f].sent = 0;
- if (got != writesize) {
+
+ if (got < 0)
+ tperror(-got);
+
+ if (got == 0) {
msg("EOT detected in last 2 tape records!\n");
msg("Use a longer tape, decrease the size estimate\n");
quit("or use no size estimate at all.\n");
register struct slave *tslp;
int i, size, savedtapea, got;
union u_spcl *ntb, *otb;
+ struct slave_results returned;
#ifdef __linux__
int blks;
long lastfirstrec;
* worked ok, otherwise the tape is much too short!
*/
if (slp->sent) {
- if (atomic_read( slp->fd, (char *)&got, sizeof got)
- != sizeof got) {
+ if (atomic_read( slp->fd, (char *)&returned, sizeof returned)
+ != sizeof returned) {
perror(" DUMP: error reading command pipe in master");
dumpabort(0);
}
+ got = returned.unclen;
+ bytes_written += returned.clen;
+ if (returned.clen == returned.unclen)
+ uncomprblks++;
slp->sent = 0;
- if (got != writesize) {
+ if (got < 0)
+ tperror(-got);
+
+ if (got == 0) {
quit("EOT detected at start of the tape!\n");
}
}
slp->firstrec = lastfirstrec + ntrec;
slp->count = lastspclrec + blks + 1 - spcl.c_tapea;
slp->inode = curino;
- asize += tenths;
+ asize += tenths + returned.clen / density;
blockswritten += ntrec;
blocksthisvol += ntrec;
#endif
parentpid = getpid();
tapea_volume = spcl.c_tapea;
+ tapea_bytes = bytes_written;
#ifdef __linux__
(void)time4(&tstart_volume);
#else
spcl.c_volume++;
spcl.c_type = TS_TAPE;
spcl.c_flags |= DR_NEWHEADER;
+ if (compressed)
+ spcl.c_flags |= DR_COMPRESSED;
writeheader((ino_t)slp->inode);
spcl.c_flags &=~ DR_NEWHEADER;
msg("Volume %d started at: %s", tapeno,
master = getpid();
{ struct sigaction sa;
-#if HAVE_SIGACTION_SA_SIGACTION
- sa.sa_sigaction = NULL;
-#endif
+ memset(&sa, 0, sizeof sa);
sigemptyset(&sa.sa_mask);
- sa.sa_flags = 0;
sa.sa_handler = dumpabort;
sigaction(SIGTERM, &sa, NULL); /* Slave sends SIGTERM on dumpabort() */
sa.sa_handler = sigpipe;
sigaction(SIGPIPE, &sa, NULL);
- sa.sa_handler = tperror;
- sigaction(SIGUSR1, &sa, NULL); /* Slave sends SIGUSR1 on tape errors */
sa.sa_handler = proceed;
sa.sa_flags = SA_RESTART;
sigaction(SIGUSR2, &sa, NULL); /* Slave sends SIGUSR2 to next slave */
}
/*
- * 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.
+ * Synchronization - each process waits for a SIGUSR2 from the
+ * previous process before writing to the tape, and sends SIGUSR2
+ * to the next process when the tape write completes. On tape errors
+ * a SIGUSR1 is sent to the master which then terminates all of the
+ * slaves.
*/
static void
doslave(int cmd, int slave_number)
{
register int nread;
- int nextslave, size, eot_count;
+ int nextslave, size, eot_count, bufsize;
volatile int wrote = 0;
- sigset_t sigset;
+ char *buffer;
+#ifdef HAVE_ZLIB
+ struct tapebuf *comp_buf = NULL;
+ int compresult, complevel = 6, do_compress = 0;
+ unsigned long worklen;
+#endif /* HAVE_ZLIB */
+ struct slave_results returns;
#ifdef __linux__
errcode_t retval;
#endif
quit("master/slave protocol botched - didn't get pid of next slave.\n");
}
+#ifdef HAVE_ZLIB
+ /* 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;
+ }
+#endif /* HAVE_ZLIB */
+
/*
* Get list of blocks to dump, read the blocks into tape buffer
*/
for (trecno = 0; trecno < ntrec;
trecno += p->count, p += p->count) {
- if (p->dblk) {
+ if (p->dblk) { /* read a disk block */
bread(p->dblk, slp->tblock[trecno],
p->count * TP_BSIZE);
- } else {
+ } else { /* read record from pipe */
if (p->count != 1 || atomic_read( cmd,
(char *)slp->tblock[trecno],
TP_BSIZE) != TP_BSIZE)
wrote = 0;
eot_count = 0;
size = 0;
+ buffer = (char *) slp->tblock[0]; /* set write pointer */
+ bufsize = writesize; /* length to write */
+ returns.clen = returns.unclen = bufsize;
+
+#ifdef HAVE_ZLIB
+ /*
+ * 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
+ * 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.
+ */
+
+ if (compressed) {
+ 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) {
+ /* write the compressed buffer */
+ comp_buf->length = worklen;
+ comp_buf->compressed = 1;
+ buffer = (char *) comp_buf;
+ returns.clen = bufsize = worklen + sizeof(struct tapebuf);
+ }
+ else {
+ /* write the data uncompressed */
+ comp_buf->length = writesize;
+ comp_buf->compressed = 0;
+ buffer = (char *) comp_buf;
+ returns.clen = bufsize = writesize + sizeof(struct tapebuf);
+ returns.unclen = returns.clen;
+ memcpy(comp_buf->buf, (char *)slp->tblock[0], writesize);
+ }
+ }
+ /* compress the remaining blocks */
+ do_compress = compressed;
+#endif /* HAVE_ZLIB */
- while (eot_count < 10 && size < writesize) {
+ while (eot_count < 10 && size < bufsize) {
#ifdef RDUMP
if (host)
- wrote = rmtwrite(slp->tblock[0]+size,
- writesize-size);
+ wrote = rmtwrite(buffer + size, bufsize - size);
else
#endif
- wrote = write(tapefd, slp->tblock[0]+size,
- writesize-size);
+ wrote = write(tapefd, buffer + size, bufsize - size);
#ifdef WRITEDEBUG
printf("slave %d wrote %d\n", slave_number, wrote);
#endif
}
#ifdef WRITEDEBUG
- if (size != writesize)
+ if (size != bufsize)
printf("slave %d only wrote %d out of %d bytes and gave up.\n",
- slave_number, size, writesize);
+ slave_number, size, bufsize);
#endif
/*
}
if (eot_count > 0)
- size = 0;
-
- if (wrote < 0) {
- (void) kill(master, SIGUSR1);
- sigemptyset(&sigset);
- sigaddset(&sigset, SIGINT);
- for (;;)
- sigsuspend(&sigset);
- } else {
- /*
- * pass size of write back to master
- * (for EOT handling)
- */
- (void) atomic_write( cmd, (char *)&size, sizeof size);
- }
+ returns.clen = returns.unclen = 0;
+
+ /*
+ * pass errno back to master for special handling
+ */
+ if (wrote < 0)
+ returns.unclen = -errno;
+
+ /*
+ * pass size of data and size of write back to master
+ * (for EOT handling)
+ */
+ (void) atomic_write( cmd, (char *)&returns, sizeof returns);
/*
- * If partial write, don't want next slave to go.
- * Also jolts him awake.
+ * Signal the next slave to go.
*/
(void) kill(nextslave, SIGUSR2);
}
git.wh0rd.org / dump.git / blobdiff