* thus we neither allocate it nor free it. This allows
* the caller to put the packet in shared memory.
*
- * Note, for a tape, the dev_name is the device name
+ * Note, for a tape, the device->device_name is the device name
* (e.g. /dev/nst0), and for a file, the device name
* is the directory in which the file will be placed.
*
*/
DEVICE *
-init_dev(DEVICE *dev, char *dev_name)
+init_dev(DEVICE *dev, DEVRES *device)
{
struct stat statp;
int tape;
int errstat;
/* Check that device is available */
- if (stat(dev_name, &statp) < 0) {
+ if (stat(device->device_name, &statp) < 0) {
if (dev) {
dev->dev_errno = errno;
}
- Emsg2(M_FATAL, 0, "Unable to stat device %s : %s\n", dev_name, strerror(errno));
+ Emsg2(M_FATAL, 0, "Unable to stat device %s : %s\n", device->device_name,
+ strerror(errno));
return NULL;
}
tape = FALSE;
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",
+ Emsg2(M_FATAL, 0, _("%s is an unknown device type. Must be tape or directory. st_mode=%x\n"),
dev_name, statp.st_mode);
return NULL;
}
if (tape) {
dev->state |= ST_TAPE;
}
- dev->dev_name = (char *) get_memory(strlen(dev_name)+1);
- strcpy(dev->dev_name, dev_name);
- dev->errmsg = (char *) get_pool_memory(PM_EMSG);
+ /* Copy user supplied device parameters from Resource */
+ dev->dev_name = get_memory(strlen(device->device_name)+1);
+ strcpy(dev->dev_name, device->device_name);
+ dev->capabilities = device->cap_bits;
+ dev->min_block_size = device->min_block_size;
+ dev->max_block_size = device->max_block_size;
+ dev->max_volume_jobs = device->max_volume_jobs;
+ dev->max_volume_files = device->max_volume_files;
+ dev->max_volume_size = device->max_volume_size;
+ dev->max_file_size = device->max_file_size;
+ dev->volume_capacity = device->volume_capacity;
+ dev->max_rewind_wait = device->max_rewind_wait;
+ dev->max_open_wait = device->max_open_wait;
+ dev->device = device;
+
+ if (dev->max_block_size > 1000000) {
+ Emsg3(M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
+ dev->max_block_size, dev->dev_name, DEFAULT_BLOCK_SIZE);
+ dev->max_block_size = 0;
+ }
+ if (dev->max_block_size % TAPE_BSIZE != 0) {
+ Emsg2(M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
+ dev->max_block_size, dev->dev_name);
+ }
+
+ dev->errmsg = get_pool_memory(PM_EMSG);
*dev->errmsg = 0;
if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
}
dev->state &= ~(ST_APPEND|ST_READ|ST_EOT | ST_EOF | ST_WEOT); /* remove EOF/EOT flags */
dev->block_num = dev->file = 0;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
if (dev->state & ST_TAPE) {
mt_com.mt_op = MTREW;
mt_com.mt_count = 1;
break;
}
} else {
- if (lseek(dev->fd, 0, SEEK_SET) < 0) {
+ if (lseek(dev->fd, (off_t)0, SEEK_SET) < 0) {
dev->dev_errno = errno;
Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
dev->dev_name, strerror(dev->dev_errno));
struct mtop mt_com;
struct mtget mt_stat;
int stat = 0;
- int32_t pos;
+ off_t pos;
Dmsg0(29, "eod_dev\n");
if (dev->state & ST_EOT) {
}
dev->state &= ~(ST_EOF); /* remove EOF flags */
dev->block_num = dev->file = 0;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
if (!(dev->state & ST_TAPE)) {
- pos = lseek(dev->fd, 0, SEEK_END);
- if (pos > 0) {
+ pos = lseek(dev->fd, (off_t)0, SEEK_END);
+// Dmsg1(000, "====== Seek to %lld\n", pos);
+ if (pos >= 0) {
update_pos_dev(dev);
dev->state |= ST_EOT;
return 1;
}
while (!(dev->state & ST_EOT)) {
Dmsg0(200, "Do fsf 1\n");
- if (fsf_dev(dev, 1) < 0) {
- Dmsg0(200, "fsf_dev return < 0\n");
+ if (!fsf_dev(dev, 1)) {
+ Dmsg0(200, "fsf_dev error.\n");
return 0;
}
}
#ifdef xxxx
struct mtget mt_stat;
#endif
- int32_t pos;
+ off_t pos;
int stat = 0;
if (dev->fd < 0) {
/* Find out where we are */
if (!(dev->state & ST_TAPE)) {
dev->file = 0;
- dev->file_bytes = 0;
- pos = lseek(dev->fd, 0, SEEK_CUR);
+ dev->file_addr = 0;
+ pos = lseek(dev->fd, (off_t)0, SEEK_CUR);
if (pos < 0) {
- Dmsg1(200, "Seek error: ERR=%s\n", strerror(dev->dev_errno));
- pos = 0;
+ Dmsg1(000, "Seek error: ERR=%s\n", strerror(dev->dev_errno));
dev->dev_errno = errno;
Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
dev->dev_name, strerror(dev->dev_errno));
} else {
stat = 1;
+ dev->file_addr = pos;
}
return stat;
}
#else
dev->block_num = dev->file = 0;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
mt_com.mt_op = MTLOAD;
mt_com.mt_count = 1;
if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
}
dev->block_num = dev->file = 0;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
#ifdef MTUNLOCK
mt_com.mt_op = MTUNLOCK;
mt_com.mt_count = 1;
/*
* Foward space a file
+ * Returns: 1 on success
+ * 0 on failure
*/
int
fsf_dev(DEVICE *dev, int num)
{
struct mtop mt_com;
- int stat;
+ int stat = 0;
char rbuf[1024];
if (dev->fd < 0) {
dev->dev_errno = EBADF;
Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
Emsg0(M_FATAL, 0, dev->errmsg);
- return -1;
+ return 0;
}
if (!(dev->state & ST_TAPE)) {
- return 0;
+ return 1;
}
if (dev->state & ST_EOT) {
dev->dev_errno = 0;
Mmsg1(&dev->errmsg, _("Device %s at End of Tape.\n"), dev->dev_name);
- return -1;
+ return 0;
}
if (dev->state & ST_EOF)
Dmsg0(200, "ST_EOF set on entry to FSF\n");
} else {
dev->state |= ST_EOF;
dev->file++;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
continue;
}
} else { /* Got data */
} else {
dev->state |= ST_EOF; /* just read EOF */
dev->file++;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
}
}
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;
+ return stat == 0 ? 1 : 0;
}
/*
Dmsg0(29, "bsf_dev\n");
dev->state &= ~(ST_EOT|ST_EOF);
dev->file -= num;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
mt_com.mt_op = MTBSF;
mt_com.mt_count = num;
stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
} else {
dev->state |= ST_EOF; /* assume EOF */
dev->file++;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
}
clrerror_dev(dev, MTFSR);
Mmsg2(&dev->errmsg, _("ioctl MTFSR error on %s. ERR=%s.\n"),
/*
* Backward space a record
+ * Returns: 0 on success
+ * -1 on failure
*/
int
bsr_dev(DEVICE *dev, int num)
stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
if (stat == 0) {
dev->file++;
- dev->file_bytes = 0;
+ dev->file_addr = 0;
} else {
clrerror_dev(dev, MTWEOF);
Mmsg2(&dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
/* 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->block_num = 0;
- dev->file = 0;
- dev->file_bytes = 0;
- dev->LastBlockNumWritten = 0;
+ dev->file = dev->block_num = 0;
+ dev->file_addr = 0;
+ dev->EndFile = dev->EndBlock = 0;
memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
dev->use_count--;
free_pool_memory(dev->errmsg);
dev->errmsg = NULL;
}
+#ifdef NEW_LOCK
+ rwl_destroy(&dev->lock);
+#endif
pthread_mutex_destroy(&dev->mutex);
pthread_cond_destroy(&dev->wait);
pthread_cond_destroy(&dev->wait_next_vol);
free_pool_memory((POOLMEM *)dev);
}
}
+
+
+/* To make following two functions more readable */
+
+#define attached_jcrs ((JCR *)(dev->attached_jcrs))
+
+void attach_jcr_to_device(DEVICE *dev, JCR *jcr)
+{
+ jcr->prev_dev = NULL;
+ jcr->next_dev = attached_jcrs;
+ if (attached_jcrs) {
+ attached_jcrs->prev_dev = jcr;
+ }
+ attached_jcrs = jcr;
+ Dmsg1(100, "Attached Job %s\n", jcr->Job);
+}
+
+void detach_jcr_from_device(DEVICE *dev, JCR *jcr)
+{
+ if (!jcr->prev_dev) {
+ attached_jcrs = jcr->next_dev;
+ } else {
+ jcr->prev_dev->next_dev = jcr->next_dev;
+ }
+ if (jcr->next_dev) {
+ jcr->next_dev->prev_dev = jcr->prev_dev;
+ }
+ jcr->next_dev = jcr->prev_dev = NULL;
+ Dmsg1(100, "Detached Job %s\n", jcr->Job);
+}
+
+JCR *next_attached_jcr(DEVICE *dev, JCR *jcr)
+{
+ if (jcr == NULL) {
+ return attached_jcrs;
+ }
+ return jcr->next_dev;
+}
projects / bacula / bacula / blobdiff