#include "stored.h"
/* Forward referenced functions */
-int dev_is_tape(DEVICE *dev);
-void clrerror_dev(DEVICE *dev, int func);
-int fsr_dev(DEVICE *dev, int num);
-
-extern int debug_level;
/*
* Allocate and initialize the DEVICE structure
return dev->fd;
}
if (VolName) {
- strcpy(dev->VolCatInfo.VolCatName, VolName);
+ bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
}
Dmsg3(29, "open_dev: tape=%d dev_name=%s vol=%s\n", dev_is_tape(dev),
if (dev->fd >= 0) {
dev->dev_errno = 0;
dev->state |= ST_OPENED;
- dev->use_count++;
+ dev->use_count = 1;
update_pos_dev(dev); /* update position */
}
/* Stop any open() timer we started */
/*
* 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"),
+ dev->dev_name);
+ return -1;
+ }
archive_name = get_pool_memory(PM_FNAME);
pm_strcpy(&archive_name, dev->dev_name);
if (archive_name[strlen(archive_name)] != '/') {
} else {
dev->dev_errno = 0;
dev->state |= ST_OPENED;
- dev->use_count++;
+ dev->use_count = 1;
update_pos_dev(dev); /* update position */
}
Dmsg1(29, "open_dev: disk fd=%d opened\n", dev->fd);
return dev->fd;
}
+#ifdef debug_tracing
+#undef rewind_dev
+int _rewind_dev(char *file, int line, DEVICE *dev)
+{
+ Dmsg2(100, "rewind_dev called from %s:%d\n", file, line);
+ return rewind_dev(dev);
+}
+#endif
+
+
/*
* Rewind the device.
* Returns: 1 on success
struct mtop mt_com;
unsigned int i;
- Dmsg0(29, "rewind_dev\n");
+ Dmsg1(29, "rewind_dev %s\n", dev->dev_name);
if (dev->fd < 0) {
dev->dev_errno = EBADF;
Mmsg1(&dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
Emsg0(M_FATAL, 0, dev->errmsg);
return 0;
}
- dev->state &= ~(ST_APPEND|ST_READ|ST_EOT | ST_EOF | ST_WEOT); /* remove EOF/EOT flags */
+ dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
dev->block_num = dev->file = 0;
dev->file_addr = 0;
if (dev->state & ST_TAPE) {
}
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 1;
}
+ dev->dev_errno = errno;
+ Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
+ dev->dev_name, strerror(dev->dev_errno));
return 0;
}
#ifdef MTEOM
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(000, "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) == 0);
- 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(000, "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;
if (dev->state & (ST_EOT | ST_WEOT)) {
stat |= BMT_EOD;
- Dmsg0(-20, " EOD-");
+ Dmsg0(-20, " EOD");
}
if (dev->state & ST_EOF) {
stat |= BMT_EOF;
}
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;
}
if (GMT_EOD(mt_stat.mt_gstat)) {
stat |= BMT_EOD;
- Dmsg0(-20, " EOD+");
+ Dmsg0(-20, " EOD");
}
if (GMT_WR_PROT(mt_stat.mt_gstat)) {
stat |= BMT_WR_PROT;
if (dev->fd < 0) {
dev->dev_errno = EBADF;
- Mmsg0(&dev->errmsg, _("Bad call to load_dev. Archive not open\n"));
+ Mmsg0(&dev->errmsg, _("Bad call to offline_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
return 0;
}
return 1;
}
+ dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
dev->block_num = dev->file = 0;
dev->file_addr = 0;
#ifdef MTUNLOCK
return 1;
}
+int offline_or_rewind_dev(DEVICE *dev)
+{
+ if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
+ return offline_dev(dev);
+ } else {
+ /*
+ * Note, this rewind probably should not be here (it wasn't
+ * in prior versions of Bacula), but on FreeBSD, this is
+ * needed in the case the tape was "frozen" due to an error
+ * such as backspacing after writing and EOF. If it is not
+ * done, all future references to the drive get and I/O error.
+ */
+ return rewind_dev(dev);
+ }
+}
/*
* Foward space a file
int
fsf_dev(DEVICE *dev, int num)
{
+ struct mtget mt_stat;
struct mtop mt_com;
int stat = 0;
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 0;
+ }
+ 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 1;
+
+ /*
+ * 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");
/*
* Backward space a file
+ * Returns: 0 on failure
+ * 1 on success
*/
int
bsf_dev(DEVICE *dev, int num)
if (dev->fd < 0) {
dev->dev_errno = EBADF;
- Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
+ Mmsg0(&dev->errmsg, _("Bad call to bsf_dev. Archive device not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return -1;
+ return 0;
}
- if (!(dev->state & ST_TAPE)) {
+ 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;
}
Dmsg0(29, "bsf_dev\n");
dev->dev_name, strerror(dev->dev_errno));
}
update_pos_dev(dev);
- return stat;
+ return stat == 0 ? 1 : 0;
}
/*
* Foward space a record
+ * Returns: 0 on failure
+ * 1 on success
*/
int
fsr_dev(DEVICE *dev, int num)
if (dev->fd < 0) {
dev->dev_errno = EBADF;
- Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
+ Mmsg0(&dev->errmsg, _("Bad call to fsr_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return -1;
+ return 0;
}
- if (!(dev->state & ST_TAPE)) {
+ if (!(dev_state(dev, ST_TAPE))) {
return 0;
}
Dmsg0(29, "fsr_dev\n");
dev->dev_name, strerror(dev->dev_errno));
}
update_pos_dev(dev);
- return stat;
+ return stat == 0 ? 1 : 0;
}
/*
* Backward space a record
- * Returns: 0 on success
- * -1 on failure
+ * Returns: 0 on failure
+ * 1 on success
*/
int
bsr_dev(DEVICE *dev, int num)
if (dev->fd < 0) {
dev->dev_errno = EBADF;
- Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
+ Mmsg0(&dev->errmsg, _("Bad call to bsr_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return -1;
+ return 0;
}
if (!(dev->state & ST_TAPE)) {
dev->dev_name, strerror(dev->dev_errno));
}
update_pos_dev(dev);
- return stat;
+ return stat == 0 ? 1 : 0;
+}
+
+/*
+ * Reposition the device to file, block
+ * Currently only works for tapes.
+ * Returns: 0 on failure
+ * 1 on success
+ */
+int
+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;
+ }
+
+ if (!(dev_state(dev, ST_TAPE))) {
+ return 0;
+ }
+ 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;
+ }
+ }
+ if (file > dev->file) {
+ Dmsg1(100, "fsf %d\n", file-dev->file);
+ if (!fsf_dev(dev, file-dev->file)) {
+ return 0;
+ }
+ }
+ if (block < dev->block_num) {
+ bsf_dev(dev, 1);
+ fsf_dev(dev, 1);
+ }
+ 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 1;
}
if (dev->fd < 0) {
dev->dev_errno = EBADF;
- Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
+ Mmsg0(&dev->errmsg, _("Bad call to weof_dev. Archive drive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
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 */
mt_com.mt_count = num;
stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
if (stat == 0) {
- dev->file++;
+ dev->file += num;
dev->file_addr = 0;
} else {
clrerror_dev(dev, MTWEOF);
- Mmsg2(&dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
- dev->dev_name, strerror(dev->dev_errno));
+ if (stat == -1) {
+ Mmsg2(&dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
+ dev->dev_name, strerror(dev->dev_errno));
+ }
}
return stat;
}
}
if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
switch (func) {
- case -1:
- Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
- break;
- case MTWEOF:
- msg = "WTWEOF";
- dev->capabilities &= ~CAP_EOF; /* turn off feature */
- break;
+ case -1:
+ Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
+ break;
+ case MTWEOF:
+ msg = "WTWEOF";
+ dev->capabilities &= ~CAP_EOF; /* turn off feature */
+ break;
#ifdef MTEOM
- case MTEOM:
- msg = "WTEOM";
- dev->capabilities &= ~CAP_EOM; /* turn off feature */
- break;
+ case MTEOM:
+ msg = "WTEOM";
+ dev->capabilities &= ~CAP_EOM; /* turn off feature */
+ break;
#endif
- case MTFSF:
- msg = "MTFSF";
- dev->capabilities &= ~CAP_FSF; /* turn off feature */
- break;
- case MTBSF:
- msg = "MTBSF";
- dev->capabilities &= ~CAP_BSF; /* turn off feature */
- break;
- case MTFSR:
- msg = "MTFSR";
- dev->capabilities &= ~CAP_FSR; /* turn off feature */
- break;
- case MTBSR:
- msg = "MTBSR";
- dev->capabilities &= ~CAP_BSR; /* turn off feature */
- break;
- default:
- msg = "Unknown";
- break;
+ case MTFSF:
+ msg = "MTFSF";
+ dev->capabilities &= ~CAP_FSF; /* turn off feature */
+ break;
+ case MTBSF:
+ msg = "MTBSF";
+ dev->capabilities &= ~CAP_BSF; /* turn off feature */
+ break;
+ case MTFSR:
+ msg = "MTFSR";
+ dev->capabilities &= ~CAP_FSR; /* turn off feature */
+ break;
+ case MTBSR:
+ msg = "MTBSR";
+ dev->capabilities &= ~CAP_BSR; /* turn off feature */
+ break;
+ default:
+ msg = "Unknown";
+ break;
}
if (msg != NULL) {
dev->dev_errno = ENOSYS;
{
/* Read and clear SCSI error status */
union mterrstat mt_errstat;
+ Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
+ strerror(dev->dev_errno));
ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
}
#endif
static void do_close(DEVICE *dev)
{
- Dmsg0(29, "really close_dev\n");
- close(dev->fd);
+ Dmsg1(29, "really close_dev %s\n", dev->dev_name);
+ if (dev->fd >= 0) {
+ close(dev->fd);
+ }
/* Clean up device packet so it can be reused */
dev->fd = -1;
dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
dev->EndFile = dev->EndBlock = 0;
memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
- dev->use_count--;
if (dev->tid) {
stop_thread_timer(dev->tid);
dev->tid = 0;
}
+ dev->use_count = 0;
}
/*
close_dev(DEVICE *dev)
{
if (!dev) {
- Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
+ Mmsg0(&dev->errmsg, _("Bad call to close_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
return;
}
if (dev->fd >= 0 && dev->use_count == 1) {
do_close(dev);
- } else {
- Dmsg0(29, "close_dev but in use so leave open.\n");
+ } else if (dev->use_count > 0) {
dev->use_count--;
}
+
+#ifdef FULL_DEBUG
+ ASSERT(dev->use_count >= 0);
+#endif
}
/*
- * Used when unmounting the device
+ * Used when unmounting the device, ignore use_count
*/
void force_close_dev(DEVICE *dev)
{
if (!dev) {
- Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
+ Mmsg0(&dev->errmsg, _("Bad call to force_close_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
return;
}
- Dmsg0(29, "really close_dev\n");
+ Dmsg1(29, "Force close_dev %s\n", dev->dev_name);
do_close(dev);
+
+#ifdef FULL_DEBUG
+ ASSERT(dev->use_count >= 0);
+#endif
}
int truncate_dev(DEVICE *dev)
{
if (!dev) {
dev->dev_errno = EBADF;
- Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
+ Mmsg0(&dev->errmsg, _("Bad call to term_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
return;
}
}
}
-
-
+/*
+ * We attach a jcr to the device so that when
+ * the Volume is full during writing, a
+ * JobMedia record will be created for this
+ * Job.
+ */
void attach_jcr_to_device(DEVICE *dev, JCR *jcr)
{
jcr->prev_dev = (JCR *)NULL;