#ifndef lint
static const char rcsid[] =
- "$Id: tape.c,v 1.64 2002/02/27 09:47:48 stelian Exp $";
+ "$Id: tape.c,v 1.69 2002/07/01 11:54:40 stelian Exp $";
#endif /* not lint */
#include <config.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
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 ssize_t dump_atomic_read __P((int, void *, size_t));
+static ssize_t dump_atomic_write __P((int, const void *, size_t));
static void doslave __P((int, int, int));
static void enslave __P((void));
static void flushtape __P((void));
slp->req[trecno].count = 0; /* Sentinel */
- if (atomic_write( slp->fd, (char *)slp->req, siz) != siz)
+ if (dump_atomic_write( slp->fd, (char *)slp->req, siz) != siz)
quit("error writing command pipe: %s\n", strerror(errno));
slp->sent = 1; /* we sent a request, read the response later */
/* Read results back from next slave */
if (slp->sent) {
- if (atomic_read( slp->fd, (char *)&returned, sizeof returned)
+ if (dump_atomic_read( slp->fd, (char *)&returned, sizeof returned)
!= sizeof returned) {
perror(" DUMP: error reading command pipe in master");
dumpabort(0);
*/
for (i = 0; i < SLAVES; i++) {
if (slaves[i].sent) {
- if (atomic_read( slaves[i].fd,
+ if (dump_atomic_read( slaves[i].fd,
(char *)&returned, sizeof returned)
!= sizeof returned) {
perror(" DUMP: error reading command pipe in master");
blocksthisvol += ntrec;
if (!pipeout && !unlimited) {
if (blocksperfile) {
- if ( compressed ? (bytes_written - tapea_bytes + SLAVES * (writesize + sizeof(struct tapebuf))) >= blocksperfile * 1024
+ if ( compressed ? (bytes_written - tapea_bytes + SLAVES * (writesize + sizeof(struct tapebuf))) >= (((long long)blocksperfile) * 1024)
: blocksthisvol >= blocksperfile ) {
close_rewind();
startnewtape(0);
* fixme: punt for now.
*/
if (slaves[f].sent) {
- if (atomic_read( slaves[f].fd, (char *)&returned, sizeof returned)
+ if (dump_atomic_read( slaves[f].fd, (char *)&returned, sizeof returned)
!= sizeof returned) {
perror(" DUMP: error reading command pipe in master");
dumpabort(0);
#ifdef RDUMP
if (host) {
rmtclose();
- while (rmtopen(tape, 0) < 0)
+ while (rmtopen(tape, "O_RDONLY") < 0)
sleep(10);
rmtclose();
}
{
(void) close(tapefd);
if (!fifoout) {
- while ((f = OPEN(tape, 0)) < 0)
+ while ((f = OPEN(tape, O_RDONLY)) < 0)
sleep (10);
(void) close(f);
}
lastspclrec = savedtapea - 1;
}
size = (char *)ntb - (char *)q;
- if (atomic_write( slp->fd, (char *)q, size) != size) {
+ if (dump_atomic_write( slp->fd, (char *)q, size) != size) {
perror(" DUMP: error writing command pipe");
dumpabort(0);
}
* worked ok, otherwise the tape is much too short!
*/
if (slp->sent) {
- if (atomic_read( slp->fd, (char *)&returned, sizeof returned)
+ if (dump_atomic_read( slp->fd, (char *)&returned, sizeof returned)
!= sizeof returned) {
perror(" DUMP: error reading command pipe in master");
dumpabort(0);
msg("Dumping volume %d on %s\n", tapeno, tape);
}
#ifdef RDUMP
- while ((tapefd = (host ? rmtopen(tape, 2) : pipeout ?
+ while ((tapefd = (host ? rmtopen(tape, "O_WRONLY|O_CREAT|O_TRUNC") : pipeout ?
fileno(stdout) :
- OPEN(tape, O_WRONLY|O_CREAT, 0666))) < 0)
+ OPEN(tape, O_WRONLY|O_CREAT|O_TRUNC, 0666))) < 0)
#else
while ((tapefd = (pipeout ? fileno(stdout) :
- OPEN(tape, O_RDWR|O_CREAT, 0666))) < 0)
+ OPEN(tape, O_WRONLY|O_CREAT|O_TRUNC, 0666))) < 0)
#endif
{
- msg("Cannot open output \"%s\".\n", tape);
+ msg("Cannot open output \"%s\": %s\n", tape,
+ strerror(errno));
if (!query("Do you want to retry the open?"))
dumpabort(0);
}
sigprocmask(SIG_BLOCK, &sigs, NULL);
#ifdef LINUX_FORK_BUG
- if (atomic_write( cmd[0], (char *) &i, sizeof i)
+ if (dump_atomic_write( cmd[0], (char *) &i, sizeof i)
!= sizeof i)
quit("master/slave protocol botched 3\n");
#endif
* returned from fork() causes a SEGV in the child process
*/
for (i = 0; i < SLAVES; i++)
- if (atomic_read( slaves[i].fd, (char *) &j, sizeof j) != sizeof j)
+ if (dump_atomic_read( slaves[i].fd, (char *) &j, sizeof j) != sizeof j)
quit("master/slave protocol botched 4\n");
#endif
for (i = 0; i < SLAVES; i++)
- (void) atomic_write( slaves[i].fd,
+ (void) dump_atomic_write( slaves[i].fd,
(char *) &slaves[(i + 1) % SLAVES].pid,
sizeof slaves[0].pid);
/*
* Need the pid of the next slave in the loop...
*/
- if ((nread = atomic_read( cmd, (char *)&nextslave, sizeof nextslave))
+ if ((nread = dump_atomic_read( cmd, (char *)&nextslave, sizeof nextslave))
!= sizeof nextslave) {
quit("master/slave protocol botched - didn't get pid of next slave.\n");
}
/*
* Get list of blocks to dump, read the blocks into tape buffer
*/
- while ((nread = atomic_read( cmd, (char *)slp->req, reqsiz)) == reqsiz) {
+ while ((nread = dump_atomic_read( cmd, (char *)slp->req, reqsiz)) == reqsiz) {
struct req *p = slp->req;
for (trecno = 0; trecno < ntrec;
bread(p->dblk, slp->tblock[trecno],
p->count * TP_BSIZE);
} else { /* read record from pipe */
- if (p->count != 1 || atomic_read( cmd,
+ if (p->count != 1 || dump_atomic_read( cmd,
(char *)slp->tblock[trecno],
TP_BSIZE) != TP_BSIZE)
quit("master/slave protocol botched.\n");
* pass size of data and size of write back to master
* (for EOT handling)
*/
- (void) atomic_write( cmd, (char *)&returns, sizeof returns);
+ (void) dump_atomic_write( cmd, (char *)&returns, sizeof returns);
/*
* Signal the next slave to go.
* loop until the count is satisfied (or error).
*/
static ssize_t
-atomic_read(int fd, void *buf, size_t count)
+dump_atomic_read(int fd, void *buf, size_t count)
{
int got, need = count;
* loop until the count is satisfied (or error).
*/
static ssize_t
-atomic_write(int fd, const void *buf, size_t count)
+dump_atomic_write(int fd, const void *buf, size_t count)
{
int got, need = count;