* 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@noos.fr>, 1999-2000
- * Stelian Pop <pop@noos.fr> - Alcôve <www.alcove.fr>, 2000
+ * Stelian Pop <stelian@popies.net>, 1999-2000
+ * Stelian Pop <stelian@popies.net> - Alcôve <www.alcove.com>, 2000-2002
*/
/*-
#ifndef lint
static const char rcsid[] =
- "$Id: tape.c,v 1.45 2001/04/27 15:22:47 stelian Exp $";
+ "$Id: tape.c,v 1.63 2002/02/21 09:25:31 stelian Exp $";
#endif /* not lint */
#include <config.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 <sys/stat.h>
#include <bsdcompat.h>
#elif defined sunos
#include <sys/vnode.h>
#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 */
long blocksthisvol; /* number of blocks on current output file */
extern int ntrec; /* blocking factor on tape */
extern int cartridge;
-extern char *host;
char *nexttape;
extern pid_t rshpid;
int eot_code = 1;
long long tapea_bytes = 0; /* bytes_written at start of current volume */
+static int magtapeout; /* output is really a 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));
+#ifdef USE_QFA
+static int GetTapePos __P((long long *));
+static void MkTapeString __P((struct s_spcl *, long long));
+#endif
/*
* Concurrent dump mods (Caltech) - disk block reading and tape writing
slp->req[trecno].count = 1;
/* XXX post increment triggers an egcs-1.1.2-12 bug on alpha/sparc */
*(union u_spcl *)(*(nextblock)) = *(union u_spcl *)dp;
+
+ /* Need to write it to the archive file */
+ if (Afile < 0 && isspcl && (spcl.c_type == TS_END))
+ Afile = -Afile;
+ if (Afile > 0) {
+ /* When we dump an inode which is not a directory,
+ * it means we ended the archive contents */
+ if (isspcl && (spcl.c_type == TS_INODE) &&
+ ((spcl.c_dinode.di_mode & S_IFMT) != IFDIR))
+ Afile = -Afile;
+ else {
+ union u_spcl tmp;
+ tmp = *(union u_spcl *)dp;
+ /* Write the record, _uncompressed_ */
+ if (isspcl) {
+ tmp.s_spcl.c_flags &= ~DR_COMPRESSED;
+ mkchecksum(&tmp);
+ }
+ if (write(Afile, &tmp, TP_BSIZE) != TP_BSIZE)
+ msg("error writing archive file: %s\n",
+ strerror(errno));
+ }
+ }
+
nextblock++;
if (isspcl)
lastspclrec = spcl.c_tapea;
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 slave *tslp;
+ struct req *p, *q = NULL, *prev;
+ struct slave *tslp;
int i, size, savedtapea, got;
union u_spcl *ntb, *otb;
struct slave_results returned;
if (!query("Do you want to retry the open?"))
dumpabort(0);
}
+#ifdef RDUMP
+ if (!host)
+#endif
+ {
+ struct mtget mt_stat;
+ magtapeout = ioctl(tapefd, MTIOCGET, (char *)&mt_stat) == 0;
+ /*
+ msg("Output is to %s\n",
+ magtapeout ? "tape" : "file/pipe");
+ */
+ }
enslave(); /* Share open tape file descriptor with slaves */
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((dump_ino_t)slp->inode);
if (tapeno > 1)
msg("Volume %d begins with blocks from inode %d\n",
tapeno, slp->inode);
+ if (tapeno < TP_NINOS)
+ volinfo[tapeno] = slp->inode;
}
}
#ifdef LINUX_FORK_BUG
int i, j;
#else
- register int i, j;
+ int i, j;
#endif
master = getpid();
!= 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
void
killall(void)
{
- register int i;
+ int i;
for (i = 0; i < SLAVES; i++)
if (slaves[i].pid > 0) {
* slaves.
*/
static void
-doslave(int cmd, int slave_number)
+doslave(int cmd, int slave_number, int first)
{
- register int nread;
+ 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, 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;
+ long long curtapepos;
union u_spcl *uspclptr;
struct s_spcl *spclptr;
#endif /* USE_QFA */
+ sigset_t set;
+
+ sigemptyset(&set);
+ sigaddset(&set, SIGUSR2);
+ sigprocmask(SIG_BLOCK, &set, NULL);
+ sigemptyset(&set);
/*
* Need our own seek pointer.
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
*/
while ((nread = atomic_read( cmd, (char *)slp->req, reqsiz)) == reqsiz) {
- register struct req *p = slp->req;
+ struct req *p = slp->req;
for (trecno = 0; trecno < ntrec;
trecno += p->count, p += p->count) {
bufsize = writesize; /* length to write */
returns.clen = returns.unclen = bufsize;
-#ifdef HAVE_ZLIB
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
/*
- * 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.
+ * 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;
- compresult = Z_DATA_ERROR;
- if (do_compress)
- compresult = compress2(comp_buf->buf, &worklen,
- (char *)slp->tblock[0], writesize, compressed);
- if (compresult == Z_OK && worklen <= writesize-32) {
+ compresult = 1;
+#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();
+ sigsuspend(&set);
}
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)) {
- /* 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");
- }
+ int i;
+ for (i = 0; i < ntrec; ++i) {
+ uspclptr = (union u_spcl *)&slp->tblock[i];
+ spclptr = &uspclptr->s_spcl;
+ if ((spclptr->c_magic == NFS_MAGIC) &&
+ (spclptr->c_type == TS_INODE) &&
+ ((spclptr->c_dinode.di_mode & S_IFMT) != IFDIR) &&
+ (spclptr->c_date == gThisDumpDate)) {
+ /* if an error occured previously don't
+ * try again */
+ if (gtperr == 0) {
+ if ((gtperr = GetTapePos(&curtapepos)) == 0)
+ MkTapeString(spclptr, curtapepos);
}
}
}
/*
* read the current tape position
*/
-int
-GetTapePos(long *pos)
+static int
+GetTapePos(long long *pos)
{
int err = 0;
- *pos = 0;
- if (ioctl(tapefd, MTIOCPOS, pos) == -1) {
+#ifdef RDUMP
+ if (host) {
+ *pos = (long long) rmtseek(0, SEEK_CUR);
+ err = *pos < 0;
+ }
+ else
+#endif
+ {
+ if (magtapeout) {
+ long mtpos;
+ *pos = 0;
+ err = (ioctl(tapefd, MTIOCPOS, &mtpos) < 0);
+ *pos = (long long)mtpos;
+ }
+ else {
+ *pos = LSEEK(tapefd, 0, SEEK_CUR);
+ err = (*pos < 0);
+ }
+ }
+ if (err) {
err = errno;
- msg("[%ld] error: %d (getting tapepos: %ld)\n", getpid(),
+ msg("[%ld] error: %d (getting tapepos: %lld)\n", getpid(),
err, *pos);
return err;
}
return err;
}
+
+static void
+MkTapeString(struct s_spcl *spclptr, long long curtapepos) {
+
+#ifdef DEBUG_QFA
+ msg("inode %ld at tapepos %lld\n", spclptr->c_inumber, curtapepos);
+#endif
+
+ snprintf(gTps, sizeof(gTps), "%ld\t%d\t%lld\n",
+ (unsigned long)spclptr->c_inumber,
+ tapeno,
+ curtapepos);
+ gTps[sizeof(gTps) - 1] = '\0';
+ if (write(gTapeposfd, gTps, strlen(gTps)) != strlen(gTps)) {
+ warn("error writing tapepos file.\n");
+ }
+}
#endif /* USE_QFA */