*
* dev.c -- low level operations on device (storage device)
*
- * Kern Sibbald
+ * Kern Sibbald, MM
*
* NOTE!!!! None of these routines are reentrant. You must
* use lock_device() and unlock_device() at a higher level,
* Version $Id$
*/
/*
- Copyright (C) 2000-2003 Kern Sibbald and John Walker
+ Copyright (C) 2000-2004 Kern Sibbald and John Walker
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
* to include ST_EOT, which is ephimeral, and ST_WEOT, which is
* persistent. Lots of routines clear ST_EOT, but ST_WEOT is
* cleared only when the problem goes away. Now when ST_WEOT
- * is set all calls to write_dev() are handled as usual. However,
- * in write_block() instead of attempting to write the block to
- * the physical device, it is chained into a list of blocks written
- * after the EOT condition. In addition, all threads are blocked
- * from writing on the tape by calling lock(), and thread other
+ * is set all calls to write_block_to_device() call the fix_up
+ * routine. In addition, all threads are blocked
+ * from writing on the tape by calling lock_dev(), and thread other
* than the first thread to hit the EOT will block on a condition
* variable. The first thread to hit the EOT will continue to
* be able to read and write the tape (he sort of tunnels through
- * the locking mechanism -- see lock() for details).
+ * the locking mechanism -- see lock_dev() for details).
*
* Now presumably somewhere higher in the chain of command
* (device.c), someone will notice the EOT condition and
init_dev(DEVICE *dev, DEVRES *device)
{
struct stat statp;
- int tape, fifo;
+ bool tape, fifo;
int errstat;
+ DCR *dcr = NULL;
/* Check that device is available */
if (stat(device->device_name, &statp) < 0) {
strerror(errno));
return NULL;
}
- tape = FALSE;
- fifo = FALSE;
+ tape = false;
+ fifo = false;
if (S_ISDIR(statp.st_mode)) {
- tape = FALSE;
+ tape = false;
} else if (S_ISCHR(statp.st_mode)) {
- tape = TRUE;
+ tape = true;
} else if (S_ISFIFO(statp.st_mode)) {
- fifo = TRUE;
+ fifo = true;
} else {
if (dev) {
dev->dev_errno = ENODEV;
}
Emsg2(M_FATAL, 0, _("%s is an unknown device type. Must be tape or directory. st_mode=%x\n"),
- dev_name, statp.st_mode);
+ device->device_name, statp.st_mode);
return NULL;
}
if (!dev) {
dev->max_rewind_wait = device->max_rewind_wait;
dev->max_open_wait = device->max_open_wait;
dev->max_open_vols = device->max_open_vols;
+ dev->vol_poll_interval = device->vol_poll_interval;
+ dev->max_spool_size = device->max_spool_size;
+ dev->drive_index = device->drive_index;
+ /* Sanity check */
+ if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
+ dev->vol_poll_interval = 60;
+ }
dev->device = device;
if (tape) {
Mmsg1(&dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), strerror(errstat));
Emsg0(M_FATAL, 0, dev->errmsg);
}
+ if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
+ dev->dev_errno = errstat;
+ Mmsg1(&dev->errmsg, _("Unable to init mutex: ERR=%s\n"), strerror(errstat));
+ Emsg0(M_FATAL, 0, dev->errmsg);
+ }
+ if ((errstat = rwl_init(&dev->lock)) != 0) {
+ dev->dev_errno = errstat;
+ Mmsg1(&dev->errmsg, _("Unable to init mutex: ERR=%s\n"), strerror(errstat));
+ Emsg0(M_FATAL, 0, dev->errmsg);
+ }
+
dev->fd = -1;
+ dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev_is_tape(dev), dev->dev_name);
+
return dev;
}
}
/* If busy retry each second for max_open_wait seconds */
while ((dev->fd = open(dev->dev_name, dev->mode, MODE_RW)) < 0) {
- if (errno == EAGAIN) {
+ if (errno == EINTR || errno == EAGAIN) {
continue;
}
if (errno == EBUSY && timeout-- > 0) {
* Handle opening of File Archive (not a tape)
*/
if (VolName == NULL || *VolName == 0) {
- Mmsg(&dev->errmsg, _("Could not open file device %s. No Volume name given.\n"),
+ Mmsg(dev->errmsg, _("Could not open file device %s. No Volume name given.\n"),
dev->dev_name);
return -1;
}
#undef rewind_dev
int _rewind_dev(char *file, int line, DEVICE *dev)
{
- Dmsg2(000, "rewind_dev called from %s:%d\n", file, line);
+ Dmsg2(100, "rewind_dev called from %s:%d\n", file, line);
return rewind_dev(dev);
}
#endif
}
if (!(dev->state & ST_TAPE)) {
pos = lseek(dev->fd, (off_t)0, SEEK_END);
-// Dmsg1(000, "====== Seek to %lld\n", pos);
+// Dmsg1(100, "====== Seek to %lld\n", pos);
if (pos >= 0) {
update_pos_dev(dev);
dev->state |= ST_EOT;
return 0;
}
#ifdef MTEOM
+
+ if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
+ struct mtget mt_stat;
+ Dmsg0(100,"Using FAST FSF for EOM\n");
+ if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) == 0 && mt_stat.mt_fileno <= 0) {
+ if (!rewind_dev(dev)) {
+ return 0;
+ }
+ }
+ mt_com.mt_op = MTFSF;
+ /*
+ * ***FIXEM*** fix code to handle case that INT16_MAX is
+ * not large enough.
+ */
+ mt_com.mt_count = INT16_MAX; /* use big positive number */
+ if (mt_com.mt_count < 0) {
+ mt_com.mt_count = INT16_MAX; /* brain damaged system */
+ }
+ }
+
if (dev_cap(dev, CAP_EOM)) {
+ Dmsg0(100,"Using EOM for EOM\n");
mt_com.mt_op = MTEOM;
mt_com.mt_count = 1;
+ }
+ if (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM)) {
if ((stat=ioctl(dev->fd, MTIOCTOP, (char *)&mt_com)) < 0) {
Dmsg1(50, "ioctl error: %s\n", strerror(dev->dev_errno));
clrerror_dev(dev, mt_com.mt_op);
dev->dev_name, strerror(dev->dev_errno));
return 0;
}
+
if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
dev->dev_errno = errno;
Mmsg2(&dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
dev->dev_name, strerror(dev->dev_errno));
return 0;
}
- Dmsg2(200, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
+ Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
dev->file = mt_stat.mt_fileno;
/*
if (!rewind_dev(dev)) {
return 0;
}
- while (!(dev->state & ST_EOT)) {
- Dmsg0(200, "Do fsf 1\n");
+ /*
+ * Move file by file to the end of the tape
+ */
+ int file_num;
+ for (file_num=dev->file; !(dev->state & ST_EOT); file_num++) {
+ Dmsg0(200, "eod_dev: doing fsf 1\n");
if (!fsf_dev(dev, 1)) {
Dmsg0(200, "fsf_dev error.\n");
return 0;
}
+ /*
+ * Avoid infinite loop. ***FIXME*** possibly add code
+ * to set EOD or to turn off CAP_FASTFSF if on.
+ */
+ if (file_num == (int)dev->file) {
+ struct mtget mt_stat;
+ Dmsg1(100, "fsf_dev did not advance from file %d\n", file_num);
+ if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) == 0 &&
+ mt_stat.mt_fileno >= 0) {
+ Dmsg2(000, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
+ dev->file = mt_stat.mt_fileno;
+ }
+ stat = 0;
+ break; /* we are not progressing, bail out */
+ }
}
}
/*
* the second EOF.
*/
if (dev_cap(dev, CAP_BSFATEOM)) {
- stat = bsf_dev(dev, 1);
- dev->file++; /* keep same file */
+ struct mtget mt_stat;
+ /* Backup over EOF */
+ stat = bsf_dev(dev, 1);
+ /* If BSF worked and fileno is known (not -1), set file */
+ if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) == 0 && mt_stat.mt_fileno >= 0) {
+ Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
+ dev->file = mt_stat.mt_fileno;
+ } else {
+ dev->file++; /* wing it -- not correct on all OSes */
+ }
} else {
update_pos_dev(dev); /* update position */
stat = 1;
/*
* Set the position of the device -- only for files
* For other devices, there is no generic way to do it.
- * Returns: 1 on succes
- * 0 on error
+ * Returns: true on succes
+ * false on error
*/
-int update_pos_dev(DEVICE *dev)
+bool update_pos_dev(DEVICE *dev)
{
off_t pos;
- int stat = 0;
+ bool ok = true;
if (dev->fd < 0) {
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad device call. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return 0;
+ return false;
}
/* Find out where we are */
dev->dev_errno = errno;
Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
dev->dev_name, strerror(dev->dev_errno));
+ ok = false;
} else {
- stat = 1;
dev->file_addr = pos;
}
- return stat;
}
- return 1;
+ return ok;
}
* currently), which means that for the moment, this
* routine has very little value.
*
- * Returns: 1 on success
- * 0 on error
+ * Returns: status
*/
-int
-status_dev(DEVICE *dev, uint32_t *status)
+uint32_t status_dev(DEVICE *dev)
{
struct mtget mt_stat;
uint32_t stat = 0;
}
if (dev->state & ST_TAPE) {
stat |= BMT_TAPE;
- Dmsg0(-20," Driver status:");
+ Dmsg0(-20," Bacula status:");
Dmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
dev->dev_errno = errno;
} else {
stat |= BMT_ONLINE | BMT_BOT;
}
- *status = stat;
- return 1;
+ return stat;
}
/*
* Load medium in device
- * Returns: 1 on success
- * 0 on failure
+ * Returns: true on success
+ * false on failure
*/
-int load_dev(DEVICE *dev)
+bool load_dev(DEVICE *dev)
{
#ifdef MTLOAD
struct mtop mt_com;
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad call to load_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return 0;
+ return false;
}
if (!(dev->state & ST_TAPE)) {
- return 1;
+ return true;
}
#ifndef MTLOAD
Dmsg0(200, "stored: MTLOAD command not available\n");
dev->dev_errno = ENOTTY; /* function not available */
Mmsg2(&dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
dev->dev_name, strerror(dev->dev_errno)); return 0;
- return 0;
+ return false;
#else
dev->block_num = dev->file = 0;
dev->dev_errno = errno;
Mmsg2(&dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
dev->dev_name, strerror(dev->dev_errno)); return 0;
+ return false;
}
- return 1;
+ return true;
#endif
}
/*
* Rewind device and put it offline
- * Returns: 1 on success
- * 0 on failure
+ * Returns: true on success
+ * false on failure
*/
-int offline_dev(DEVICE *dev)
+bool offline_dev(DEVICE *dev)
{
struct mtop mt_com;
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad call to offline_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return 0;
+ return false;
}
if (!(dev->state & ST_TAPE)) {
- return 1;
+ return true;
}
dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
dev->dev_errno = errno;
Mmsg2(&dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
dev->dev_name, strerror(dev->dev_errno));
- return 0;
+ return false;
}
Dmsg1(100, "Offlined device %s\n", dev->dev_name);
- return 1;
+ return true;
}
int offline_or_rewind_dev(DEVICE *dev)
/*
* Foward space a file
- * Returns: 1 on success
- * 0 on failure
+ * Returns: true on success
+ * false on failure
*/
-int
+bool
fsf_dev(DEVICE *dev, int num)
{
+ struct mtget mt_stat;
struct mtop mt_com;
int stat = 0;
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return 0;
+ return false;
}
if (!(dev->state & ST_TAPE)) {
- return 1;
+ return true;
}
if (dev->state & ST_EOT) {
dev->dev_errno = 0;
Mmsg1(&dev->errmsg, _("Device %s at End of Tape.\n"), dev->dev_name);
- return 0;
+ return false;
}
if (dev->state & ST_EOF) {
Dmsg0(200, "ST_EOF set on entry to FSF\n");
}
- if (dev->state & ST_EOT) {
- Dmsg0(200, "ST_EOT set on entry to FSF\n");
- }
Dmsg0(29, "fsf_dev\n");
dev->block_num = 0;
- if (dev_cap(dev, CAP_FSF)) {
+ /*
+ * If Fast forward space file is set, then we
+ * use MTFSF to forward space and MTIOCGET
+ * to get the file position. We assume that
+ * the SCSI driver will ensure that we do not
+ * forward space over the end of data mark.
+ */
+ if (dev_cap(dev, CAP_FSF) && dev_cap(dev, CAP_FASTFSF)) {
+ mt_com.mt_op = MTFSF;
+ mt_com.mt_count = num;
+ stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
+ if (stat < 0 || ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
+ dev->state |= ST_EOT;
+ Dmsg0(200, "Set ST_EOT\n");
+ clrerror_dev(dev, MTFSF);
+ Mmsg2(&dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
+ dev->dev_name, strerror(dev->dev_errno));
+ Dmsg1(200, "%s", dev->errmsg);
+ return false;
+ }
+ Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
+ dev->file = mt_stat.mt_fileno;
+ dev->state |= ST_EOF; /* just read EOF */
+ dev->file_addr = 0;
+ return true;
+
+ /*
+ * Here if CAP_FSF is set, and virtually all drives
+ * these days support it, we read a record, then forward
+ * space one file. Using this procedure, which is slow,
+ * is the only way we can be sure that we don't read
+ * two consecutive EOF marks, which means End of Data.
+ */
+ } else if (dev_cap(dev, CAP_FSF)) {
POOLMEM *rbuf;
int rbuf_len;
Dmsg0(200, "FSF has cap_fsf\n");
if (dev->state & ST_EOT)
Dmsg0(200, "ST_EOT set on exit FSF\n");
Dmsg1(200, "Return from FSF file=%d\n", dev->file);
- return stat == 0 ? 1 : 0;
+ return stat == 0;
}
/*
* Backward space a file
- * Returns: 0 on failure
- * 1 on success
+ * Returns: false on failure
+ * true on success
*/
-int
+bool
bsf_dev(DEVICE *dev, int num)
{
struct mtop mt_com;
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad call to bsf_dev. Archive device not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return 0;
+ return false;
}
if (!(dev_state(dev, ST_TAPE))) {
Mmsg1(&dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
dev->dev_name);
- return 0;
+ return false;
}
Dmsg0(29, "bsf_dev\n");
dev->state &= ~(ST_EOT|ST_EOF);
dev->dev_name, strerror(dev->dev_errno));
}
update_pos_dev(dev);
- return stat == 0 ? 1 : 0;
+ return stat == 0;
}
/*
* Foward space a record
- * Returns: 0 on failure
- * 1 on success
+ * Returns: false on failure
+ * true on success
*/
-int
+bool
fsr_dev(DEVICE *dev, int num)
{
struct mtop mt_com;
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad call to fsr_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return 0;
+ return false;
}
if (!(dev_state(dev, ST_TAPE))) {
- return 0;
+ return false;
+ }
+ if (!dev_cap(dev, CAP_FSR)) {
+ Mmsg1(&dev->errmsg, _("ioctl MTFSR not permitted on %s.\n"), dev->dev_name);
+ return false;
}
+
Dmsg0(29, "fsr_dev\n");
- dev->block_num += num;
mt_com.mt_op = MTFSR;
mt_com.mt_count = num;
stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
if (stat == 0) {
dev->state &= ~ST_EOF;
+ dev->block_num += num;
} else {
- if (dev->state & ST_EOF) {
- dev->state |= ST_EOT;
+ struct mtget mt_stat;
+ if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) == 0 && mt_stat.mt_fileno >= 0) {
+ Dmsg4(100, "Adjust from %d:%d to %d:%d\n", dev->file,
+ dev->block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
+ dev->file = mt_stat.mt_fileno;
+ dev->block_num = mt_stat.mt_blkno;
} else {
- dev->state |= ST_EOF; /* assume EOF */
- dev->file++;
- dev->file_addr = 0;
+ if (dev->state & ST_EOF) {
+ dev->state |= ST_EOT;
+ } else {
+ dev->state |= ST_EOF; /* assume EOF */
+ dev->file++;
+ dev->block_num = 0;
+ dev->file_addr = 0;
+ }
}
clrerror_dev(dev, MTFSR);
Mmsg2(&dev->errmsg, _("ioctl MTFSR error on %s. ERR=%s.\n"),
dev->dev_name, strerror(dev->dev_errno));
}
update_pos_dev(dev);
- return stat == 0 ? 1 : 0;
+ return stat == 0;
}
/*
* Backward space a record
- * Returns: 0 on failure
- * 1 on success
+ * Returns: false on failure
+ * true on success
*/
-int
+bool
bsr_dev(DEVICE *dev, int num)
{
struct mtop mt_com;
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad call to bsr_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return 0;
+ return false;
}
if (!(dev->state & ST_TAPE)) {
- return 0;
+ return false;
}
if (!dev_cap(dev, CAP_BSR)) {
- Mmsg1(&dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"),
- dev->dev_name);
- return 0;
+ Mmsg1(&dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->dev_name);
+ return false;
}
Dmsg0(29, "bsr_dev\n");
dev->dev_name, strerror(dev->dev_errno));
}
update_pos_dev(dev);
- return stat == 0 ? 1 : 0;
+ return stat == 0;
}
/*
* Reposition the device to file, block
- * Currently only works for tapes.
- * Returns: 0 on failure
- * 1 on success
+ * Returns: false on failure
+ * true on success
*/
-int
+bool
reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
{
if (dev->fd < 0) {
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad call to reposition_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return 0;
+ return false;
}
if (!(dev_state(dev, ST_TAPE))) {
- return 0;
+ off_t pos = (((off_t)file)<<32) + block;
+ Dmsg1(100, "===== lseek to %d\n", (int)pos);
+ if (lseek(dev->fd, pos, SEEK_SET) == (off_t)-1) {
+ dev->dev_errno = errno;
+ Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
+ dev->dev_name, strerror(dev->dev_errno));
+ return false;
+ }
+ dev->file = file;
+ dev->block_num = block;
+ dev->file_addr = pos;
+ return true;
}
Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
dev->file, dev->block_num, file, block);
if (file < dev->file) {
Dmsg0(100, "Rewind_dev\n");
if (!rewind_dev(dev)) {
- return 0;
+ return false;
}
}
if (file > dev->file) {
Dmsg1(100, "fsf %d\n", file-dev->file);
if (!fsf_dev(dev, file-dev->file)) {
- return 0;
+ return false;
}
}
if (block < dev->block_num) {
if (block > dev->block_num) {
/* Ignore errors as Bacula can read to the correct block */
Dmsg1(100, "fsr %d\n", block-dev->block_num);
- fsr_dev(dev, block-dev->block_num);
+ return fsr_dev(dev, block-dev->block_num);
}
- return 1;
+ return true;
}
return -1;
}
- if (!(dev->state & ST_TAPE)) {
+ if (!(dev_state(dev, ST_TAPE))) {
return 0;
}
dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
/*
* Return string message with last error in English
* Be careful not to call this routine from within dev.c
- * while editing an Mmsg(&) or you will end up in a recursive
+ * while editing an Mmsg() or you will end up in a recursive
* loop creating a Segmentation Violation.
*/
char *
void
clrerror_dev(DEVICE *dev, int func)
{
- char *msg = NULL;
+ const char *msg = NULL;
dev->dev_errno = errno; /* save errno */
if (errno == EIO) {
{
/* Read and clear SCSI error status */
union mterrstat mt_errstat;
- Pmsg2(000, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
+ Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
strerror(dev->dev_errno));
ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
}
#endif
}
-int truncate_dev(DEVICE *dev)
+bool truncate_dev(DEVICE *dev)
{
if (dev->state & ST_TAPE) {
- return 1;
+ return true; /* we don't really truncate tapes */
+ /* maybe we should rewind and write and eof ???? */
}
if (ftruncate(dev->fd, 0) != 0) {
Mmsg1(&dev->errmsg, _("Unable to truncate device. ERR=%s\n"), strerror(errno));
- return 0;
+ return false;
}
- return 1;
+ return true;
}
-int
+bool
dev_is_tape(DEVICE *dev)
{
- return (dev->state & ST_TAPE) ? 1 : 0;
+ return (dev->state & ST_TAPE) ? true : false;
}
* if we still have a tape (perhaps not if at end of tape
* and the job is canceled).
*/
-int
+bool
dev_can_write(DEVICE *dev)
{
if ((dev->state & ST_OPENED) && (dev->state & ST_APPEND) &&
(dev->state & ST_LABEL) && !(dev->state & ST_WEOT)) {
- return 1;
+ return true;
} else {
- return 0;
+ return false;
}
}
pthread_mutex_destroy(&dev->mutex);
pthread_cond_destroy(&dev->wait);
pthread_cond_destroy(&dev->wait_next_vol);
+ pthread_mutex_destroy(&dev->spool_mutex);
+ rwl_destroy(&dev->lock);
+ if (dev->attached_dcrs) {
+ delete dev->attached_dcrs;
+ dev->attached_dcrs = NULL;
+ }
if (dev->state & ST_MALLOC) {
free_pool_memory((POOLMEM *)dev);
}
}
+#ifdef xxxx
/*
* We attach a jcr to the device so that when
* the Volume is full during writing, a
}
return jcr->next_dev;
}
+#endif
+
+/*
+ * This routine initializes the device wait timers
+ */
+void init_dev_wait_timers(DEVICE *dev)
+{
+ /* ******FIXME******* put these on config variables */
+ dev->min_wait = 60 * 60;
+ dev->max_wait = 24 * 60 * 60;
+ dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
+ dev->wait_sec = dev->min_wait;
+ dev->rem_wait_sec = dev->wait_sec;
+ dev->num_wait = 0;
+ dev->poll = false;
+ dev->BadVolName[0] = 0;
+}
+
+/*
+ * Returns: true if time doubled
+ * false if max time expired
+ */
+bool double_dev_wait_time(DEVICE *dev)
+{
+ dev->wait_sec *= 2; /* double wait time */
+ if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
+ dev->wait_sec = dev->max_wait;
+ }
+ dev->num_wait++;
+ dev->rem_wait_sec = dev->wait_sec;
+ if (dev->num_wait >= dev->max_num_wait) {
+ return false;
+ }
+ return true;
+}
projects / bacula / bacula / blobdiff