* Version $Id$
*/
/*
- Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
+ Copyright (C) 2000-2003 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
* medium condition or worse, and error condition.
* Attempt to "recover" by obtaining a new Volume.
*
+ * Here are a few things to know:
+ * jcr->VolCatInfo contains the info on the "current" tape for this job.
+ * dev->VolCatInfo contains the info on the tape in the drive.
+ * The tape in the drive could have changed several times since
+ * the last time the job used it (jcr->VolCatInfo).
+ * jcr->VolumeName is the name of the current/desired tape in the drive.
+ *
* We enter with device locked, and
* exit with device locked.
*
{
uint32_t stat = 0;
char PrevVolName[MAX_NAME_LENGTH];
- DEV_BLOCK *label_blk = NULL;
+ DEV_BLOCK *label_blk;
char b1[30], b2[30];
time_t wait_time;
+ char dt[MAX_TIME_LENGTH];
wait_time = time(NULL);
status_dev(dev, &stat);
- if (stat & MT_EOD) {
- Dmsg0(190, "======= Got EOD ========\n");
-
- block_device(dev, BST_DOING_ACQUIRE);
-
- /*
- * 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 (!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);
- return 0;
- }
- }
+ if (!(stat & BMT_EOD)) {
+ return 0; /* this really shouldn't happen */
+ }
- strcpy(dev->VolCatInfo.VolCatStatus, "Full");
- Dmsg2(100, "Call update_vol_info Stat=%s Vol=%s\n",
- dev->VolCatInfo.VolCatStatus, dev->VolCatInfo.VolCatName);
- 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);
- return 0; /* device locked */
- }
- Dmsg0(190, "Back from update_vol_info\n");
+ Dmsg0(100, "======= Got EOD ========\n");
- strcpy(PrevVolName, dev->VolCatInfo.VolCatName);
- strcpy(dev->VolHdr.PrevVolName, PrevVolName);
+ block_device(dev, BST_DOING_ACQUIRE);
+ /* Unlock, but leave BLOCKED */
+ unlock_device(dev);
- label_blk = new_block(dev);
+ /* Create a jobmedia record for this job */
+ if (!dir_create_jobmedia_record(jcr)) {
+ Jmsg(jcr, M_ERROR, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
+ jcr->VolCatInfo.VolCatName, jcr->Job);
+ P(dev->mutex);
+ unblock_device(dev);
+ return 0;
+ }
- /* Inform User about end of media */
- Jmsg(jcr, M_INFO, 0, _("End of media on Volume %s Bytes=%s Blocks=%s.\n"),
- PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
- edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2));
+ strcpy(dev->VolCatInfo.VolCatStatus, "Full");
+ Dmsg2(200, "Call update_vol_info Stat=%s Vol=%s\n",
+ dev->VolCatInfo.VolCatStatus, dev->VolCatInfo.VolCatName);
+ dev->VolCatInfo.VolCatFiles = dev->file; /* set number of files */
+ /* *****FIXME**** this needs to be done elsewhere */
+ dev->VolCatInfo.VolCatJobs++; /* increment number of jobs */
+ if (!dir_update_volume_info(jcr, &dev->VolCatInfo, 0)) { /* send Volume info to Director */
+ P(dev->mutex);
+ unblock_device(dev);
+ return 0; /* device locked */
+ }
+ Dmsg0(100, "Back from update_vol_info\n");
- /* 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 */
- }
+ bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName));
+ bstrncpy(dev->VolHdr.PrevVolName, PrevVolName, sizeof(dev->VolHdr.PrevVolName));
- P(dev->mutex); /* lock again */
-
- Jmsg(jcr, M_INFO, 0, _("New volume %s mounted on device %s\n"),
- jcr->VolumeName, dev_name(dev));
-
- /*
- * If this is a new tape, the label_blk will contain the
- * label, so write it now. If this is a previously
- * used tape, mount_next_write_volume() will return an
- * empty label_blk, and nothing will be written.
- */
- Dmsg0(190, "write label block to dev\n");
- if (!write_block_to_dev(dev, label_blk)) {
- Pmsg1(0, "write_block_to_device Volume label failed. ERR=%s",
- strerror_dev(dev));
- free_block(label_blk);
- unblock_device(dev);
- return 0; /* device locked */
- }
+ label_blk = new_block(dev);
- /* Write overflow block to tape */
- Dmsg0(190, "Write overflow block to dev\n");
- if (!write_block_to_dev(dev, block)) {
- Pmsg1(0, "write_block_to_device overflow block failed. ERR=%s",
- strerror_dev(dev));
- free_block(label_blk);
- unblock_device(dev);
- return 0; /* device locked */
- }
+ /* Inform User about end of medium */
+ Jmsg(jcr, M_INFO, 0, _("End of medium on Volume \"%s\" Bytes=%s Blocks=%s at %s.\n"),
+ PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
+ edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
+ bstrftime(dt, sizeof(dt), time(NULL)));
- jcr->NumVolumes++;
- Dmsg0(190, "Wake up any waiting threads.\n");
+ if (!mount_next_write_volume(jcr, dev, label_blk, 1)) {
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;
- mjcr->VolFirstFile = mjcr->JobFiles;
- mjcr->run_time += time(NULL) - wait_time; /* correct run time */
- }
+ P(dev->mutex);
unblock_device(dev);
- return 1; /* device locked */
+ return 0; /* device locked */
}
- if (label_blk) {
+ P(dev->mutex); /* lock again */
+
+ Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
+ jcr->VolumeName, dev_name(dev), bstrftime(dt, sizeof(dt), time(NULL)));
+
+ /*
+ * If this is a new tape, the label_blk will contain the
+ * label, so write it now. If this is a previously
+ * used tape, mount_next_write_volume() will return an
+ * empty label_blk, and nothing will be written.
+ */
+ Dmsg0(190, "write label block to dev\n");
+ 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);
+ unblock_device(dev);
+ return 0; /* device locked */
+ }
+ free_block(label_blk);
+
+ /*
+ * Walk through all attached jcrs indicating the volume has changed
+ */
+ Dmsg1(100, "Walk attached jcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
+ for (JCR *mjcr=NULL; (mjcr=next_attached_jcr(dev, mjcr)); ) {
+ if (mjcr->JobId == 0) {
+ continue; /* ignore console */
+ }
+ mjcr->NewVol = true;
+ if (jcr != mjcr) {
+ pm_strcpy(&mjcr->VolumeName, jcr->VolumeName); /* get a copy of the new volume */
+ }
}
- return 0; /* device locked */
+
+ /* Clear NewVol now because dir_get_volume_info() already done */
+ jcr->NewVol = false;
+ set_new_volume_parameters(jcr, dev);
+
+ jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
+
+ /* Write overflow block to device */
+ Dmsg0(190, "Write overflow block to dev\n");
+ if (!write_block_to_dev(jcr, dev, block)) {
+ Pmsg1(0, "write_block_to_device overflow block failed. ERR=%s",
+ strerror_dev(dev));
+ unblock_device(dev);
+ return 0; /* device locked */
+ }
+
+ unblock_device(dev);
+ return 1; /* device locked */
+}
+
+/*
+ * We have a new Volume mounted, so reset the Volume parameters
+ * concerning this job. The global changes were made earlier
+ * in the dev structure.
+ */
+void set_new_volume_parameters(JCR *jcr, DEVICE *dev)
+{
+ if (jcr->NewVol && !dir_get_volume_info(jcr, GET_VOL_INFO_FOR_WRITE)) {
+ Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
+ }
+ /* Set new start/end positions */
+ if (dev->state & ST_TAPE) {
+ jcr->StartBlock = dev->block_num;
+ jcr->StartFile = dev->file;
+ } else {
+ jcr->StartBlock = (uint32_t)dev->file_addr;
+ jcr->StartFile = (uint32_t)(dev->file_addr >> 32);
+ }
+ /* Reset indicies */
+ jcr->VolFirstIndex = 0;
+ jcr->VolLastIndex = 0;
+ jcr->NumVolumes++;
+ jcr->NewVol = false;
+ jcr->WroteVol = false;
}
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;
+ dev->no_wait_id = 0;
if (dev->num_waiting > 0) {
pthread_cond_broadcast(&dev->wait); /* wake them up */
}
}
+
+/*
+ * Enter with device locked and blocked
+ * Exit with device unlocked and blocked by us.
+ */
+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);
+}
+
+/*
+ * Enter with device blocked by us but not locked
+ * Exit with device locked, and blocked by previous owner
+ */
+void _give_back_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;
+}
projects / bacula / bacula / blobdiff