wait_time = time(NULL);
status_dev(dev, &stat);
if (stat & MT_EOD) {
- Dmsg0(190, "======= Got EOD ========\n");
+ Dmsg0(100, "======= Got EOD ========\n");
block_device(dev, BST_DOING_ACQUIRE);
+ /* Unlock, but leave BLOCKED */
+ unlock_device(dev);
/*
* Walk through all attached jcrs creating a jobmedia_record()
Dmsg1(100, "Walk attached jcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
for (JCR *mjcr=NULL; (mjcr=next_attached_jcr(dev, mjcr)); ) {
Dmsg1(100, "create JobMedia for Job %s\n", mjcr->Job);
- mjcr->end_block = dev->block_num;
- mjcr->end_file = dev->file;
+ if (dev->state & ST_TAPE) {
+ mjcr->EndBlock = dev->EndBlock;
+ mjcr->EndFile = dev->EndFile;
+ Dmsg2(200, "Fixup EndFile=%u EndBlock=%u\n", mjcr->EndFile, mjcr->EndBlock);
+ } else {
+ mjcr->EndBlock = (uint32_t)dev->file_addr;
+ mjcr->EndFile = (uint32_t)(dev->file_addr >> 32);
+ }
if (!dir_create_jobmedia_record(mjcr)) {
Jmsg(mjcr, M_ERROR, 0, _("Could not create JobMedia record for Volume=%s Job=%s\n"),
dev->VolCatInfo.VolCatName, mjcr->Job);
+ P(dev->mutex);
+ unblock_device(dev);
return 0;
}
}
if (!dir_update_volume_info(jcr, &dev->VolCatInfo, 0)) { /* send Volume info to Director */
Jmsg(jcr, M_ERROR, 0, _("Could not update Volume info Volume=%s Job=%s\n"),
dev->VolCatInfo.VolCatName, jcr->Job);
+ P(dev->mutex);
+ unblock_device(dev);
return 0; /* device locked */
}
- Dmsg0(190, "Back from update_vol_info\n");
+ Dmsg0(100, "Back from update_vol_info\n");
strcpy(PrevVolName, dev->VolCatInfo.VolCatName);
strcpy(dev->VolHdr.PrevVolName, PrevVolName);
PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2));
- /* Unlock, but leave BLOCKED */
- unlock_device(dev);
if (!mount_next_write_volume(jcr, dev, label_blk, 1)) {
P(dev->mutex);
unblock_device(dev);
return 0; /* device locked */
}
-
P(dev->mutex); /* lock again */
Jmsg(jcr, M_INFO, 0, _("New volume %s mounted on device %s\n"),
* empty label_blk, and nothing will be written.
*/
Dmsg0(190, "write label block to dev\n");
- if (!write_block_to_dev(dev, label_blk)) {
+ if (!write_block_to_dev(jcr, dev, label_blk)) {
Pmsg1(0, "write_block_to_device Volume label failed. ERR=%s",
strerror_dev(dev));
free_block(label_blk);
/* Write overflow block to tape */
Dmsg0(190, "Write overflow block to dev\n");
- if (!write_block_to_dev(dev, block)) {
+ if (!write_block_to_dev(jcr, dev, block)) {
Pmsg1(0, "write_block_to_device overflow block failed. ERR=%s",
strerror_dev(dev));
free_block(label_blk);
free_block(label_blk);
for (JCR *mjcr=NULL; (mjcr=next_attached_jcr(dev, mjcr)); ) {
/* Set new start/end positions */
- mjcr->start_block = dev->block_num;
- mjcr->start_file = dev->file;
+ if (dev->state & ST_TAPE) {
+ mjcr->StartBlock = dev->block_num;
+ mjcr->StartFile = dev->file;
+ } else {
+ mjcr->StartBlock = (uint32_t)dev->file_addr;
+ mjcr->StartFile = (uint32_t)(dev->file_addr >> 32);
+ }
mjcr->VolFirstFile = mjcr->JobFiles;
mjcr->run_time += time(NULL) - wait_time; /* correct run time */
}
return 1;
}
-
/*
* When dev_blocked is set, all threads EXCEPT thread with id no_wait_id
* must wait. The no_wait_id thread is out obtaining a new volume
* and preparing the label.
*/
-void lock_device(DEVICE *dev)
+void _lock_device(char *file, int line, DEVICE *dev)
{
int stat;
-
- Dmsg1(190, "lock %d\n", dev->dev_blocked);
+ Dmsg3(100, "lock %d from %s:%d\n", dev->dev_blocked, file, line);
P(dev->mutex);
if (dev->dev_blocked && !pthread_equal(dev->no_wait_id, pthread_self())) {
dev->num_waiting++; /* indicate that I am waiting */
}
}
-void unlock_device(DEVICE *dev)
+void _unlock_device(char *file, int line, DEVICE *dev)
{
- Dmsg0(190, "unlock\n");
+ Dmsg2(100, "unlock from %s:%d\n", file, line);
V(dev->mutex);
}
* the current thread can do slip through the lock_device()
* calls without blocking.
*/
-void block_device(DEVICE *dev, int state)
+void _block_device(char *file, int line, DEVICE *dev, int state)
{
- Dmsg1(190, "block set %d\n", state);
+ Dmsg3(100, "block set %d from %s:%d\n", state, file, line);
ASSERT(dev->dev_blocked == BST_NOT_BLOCKED);
dev->dev_blocked = state; /* make other threads wait */
dev->no_wait_id = pthread_self(); /* allow us to continue */
}
+
+
/*
* Unblock the device, and wake up anyone who went to sleep.
*/
-void unblock_device(DEVICE *dev)
+void _unblock_device(char *file, int line, DEVICE *dev)
{
- Dmsg1(190, "unblock %d\n", dev->dev_blocked);
+ Dmsg3(100, "unblock %d from %s:%d\n", dev->dev_blocked, file, line);
ASSERT(dev->dev_blocked);
dev->dev_blocked = BST_NOT_BLOCKED;
if (dev->num_waiting > 0) {
pthread_cond_broadcast(&dev->wait); /* wake them up */
}
}
+
+void _steal_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state)
+{
+ Dmsg4(100, "steal lock. old=%d new=%d from %s:%d\n", dev->dev_blocked, state,
+ file, line);
+ hold->dev_blocked = dev->dev_blocked;
+ hold->no_wait_id = dev->no_wait_id;
+ dev->dev_blocked = state;
+ dev->no_wait_id = pthread_self();
+ V(dev->mutex);
+}
+
+void _return_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
+{
+ Dmsg4(100, "return lock. old=%d new=%d from %s:%d\n",
+ dev->dev_blocked, hold->dev_blocked, file, line);
+ P(dev->mutex);
+ dev->dev_blocked = hold->dev_blocked;
+ dev->no_wait_id = hold->no_wait_id;
+}
+
+
+
+/* ==================================================================
+ * New device locking code. It is not currently used.
+ * ==================================================================
+ */
+
+/*
+ * New device locking scheme
+ */
+void _new_lock_device(char *file, int line, DEVICE *dev)
+{
+#ifdef NEW_LOCK
+ int errstat;
+ if ((errstat=rwl_writelock(&dev->lock)) != 0) {
+ e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
+ strerror(errstat));
+ }
+#endif
+}
+
+void _new_lock_device(char *file, int line, DEVICE *dev, int state)
+{
+#ifdef NEW_LOCK
+ int errstat;
+ if ((errstat=rwl_writelock(&dev->lock)) != 0) {
+ e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
+ strerror(errstat));
+ }
+ dev->dev_blocked = state;
+#endif
+}
+
+void _new_unlock_device(char *file, int line, DEVICE *dev)
+{
+#ifdef NEW_LOCK
+ int errstat;
+ if (dev->lock.w_active == 1) {
+ dev->dev_blocked = BST_NOT_BLOCKED;
+ }
+ if ((errstat=rwl_writeunlock(&dev->lock)) != 0) {
+ e_msg(file, line, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n",
+ strerror(errstat));
+ }
+#endif
+}
+
+void new_steal_device_lock(DEVICE *dev, brwsteal_t *hold, int state)
+{
+#ifdef NEW_LOCK
+ hold->state = dev->dev_blocked;
+ hold->writer_id = dev->lock.writer_id;
+ dev->dev_blocked = state;
+ dev->lock.writer_id = pthread_self();
+ V(dev->lock.mutex);
+#endif
+}
+
+void new_return_device_lock(DEVICE *dev, brwsteal_t *hold)
+{
+#ifdef NEW_LOCK
+ P(dev->lock.mutex);
+ dev->dev_blocked = hold->state;
+ dev->lock.writer_id = hold->writer_id;
+#endif
+}