#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.51 2001/07/18 13:12:33 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/wait.h>
#include <sys/mtio.h>
#ifdef __linux__
+#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
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
nextblock = slp->tblock;
trecno = 0;
asize += tenths + returned.clen / density;
+ csize += returned.clen;
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 ? csize >= 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) {
slp->count = lastspclrec + blks + 1 - spcl.c_tapea;
slp->inode = curino;
asize += tenths + returned.clen / density;
+ csize += returned.clen;
blockswritten += ntrec;
blocksthisvol += ntrec;
#endif
enslave(); /* Share open tape file descriptor with slaves */
asize = 0;
+ csize = 0;
blocksthisvol = 0;
if (top)
newtape++; /* new tape signal */
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);
char *buffer;
#ifdef HAVE_ZLIB
struct tapebuf *comp_buf = NULL;
- int compresult, do_compress = 0;
+ int compresult, do_compress = slave_number > 0;
unsigned long worklen;
#endif /* HAVE_ZLIB */
struct slave_results returns;
#ifdef HAVE_ZLIB
/*
- * 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 = compress2(comp_buf->buf, &worklen,
+ (char *)slp->tblock[0], writesize, compressed);
+ if (compresult == Z_OK && 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 */
uspclptr = (union u_spcl *)&slp->tblock[0];
spclptr = &uspclptr->s_spcl;
if ((spclptr->c_magic == NFS_MAGIC) &&
- (spclptr->c_type == TS_INODE)) {
+ (spclptr->c_type == TS_INODE) &&
+ (spclptr->c_date == gThisDumpDate)) {
/* if an error occured previously don't
* try again */
if (gtperr == 0) {
git.wh0rd.org / dump.git / blobdiff