many others, a complete list can be found in the file AUTHORS.
This program is Free Software; you can redistribute it and/or
modify it under the terms of version two of the GNU General Public
- License as published by the Free Software Foundation plus additions
- that are listed in the file LICENSE.
+ License as published by the Free Software Foundation and included
+ in the file LICENSE.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
#include "bacula.h" /* pull in global headers */
#include "stored.h" /* pull in Storage Deamon headers */
-#ifdef SD_DEBUG_LOCK
-const int dbglvl = 0;
-#else
-const int dbglvl = 500;
-#endif
-
-
/* Forward referenced functions */
/*
char dt[MAX_TIME_LENGTH];
JCR *jcr = dcr->jcr;
DEVICE *dev = dcr->dev;
+ int blocked = dev->blocked(); /* save any previous blocked status */
+ bool ok = false;
wait_time = time(NULL);
Dmsg0(100, "Enter fixup_device_block_write_error\n");
+ /*
+ * If we are blocked at entry, unblock it, and set our own block status
+ */
+ if (blocked != BST_NOT_BLOCKED) {
+ unblock_device(dev);
+ }
block_device(dev, BST_DOING_ACQUIRE);
- /* Unlock, but leave BLOCKED */
+
+ /* Continue unlocked, but leave BLOCKED */
dev->dunlock();
bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName));
edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
bstrftime(dt, sizeof(dt), time(NULL)));
- if (!mount_next_write_volume(dcr, 1)) {
+ /* Called with have_vol=false, release=true */
+ if (!mount_next_write_volume(dcr, false, true)) {
free_block(label_blk);
dcr->block = block;
dev->dlock();
- unblock_device(dev);
- return false; /* device locked */
+ goto bail_out;
}
dev->dlock(); /* lock again */
if (!write_block_to_dev(dcr)) {
berrno be;
Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
- be.strerror(dev->dev_errno));
+ be.bstrerror(dev->dev_errno));
free_block(label_blk);
dcr->block = block;
- unblock_device(dev);
- return false; /* device locked */
+ goto bail_out;
}
free_block(label_blk);
dcr->block = block;
if (!write_block_to_dev(dcr)) {
berrno be;
Pmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
- be.strerror(dev->dev_errno));
- unblock_device(dev);
- return false; /* device locked */
+ be.bstrerror(dev->dev_errno));
+ goto bail_out;
}
+ ok = true;
+bail_out:
+ /*
+ * At this point, the device is locked and blocked.
+ * Unblock the device, restore any entry blocked condition, then
+ * return leaving the device locked (as it was on entry).
+ */
unblock_device(dev);
- return true; /* device locked */
+ if (blocked != BST_NOT_BLOCKED) {
+ block_device(dev, blocked);
+ }
+ return ok; /* device locked */
}
/*
}
return true;
}
-
-/*
- * Find which JobId corresponds to the current thread
- */
-uint32_t get_jobid_from_tid()
-{
- JCR *jcr;
- uint32_t JobId = 0;
- foreach_jcr(jcr) {
- if (pthread_equal(jcr->my_thread_id, pthread_self())) {
- JobId = (uint32_t)jcr->JobId;
- break;
- }
- }
- endeach_jcr(jcr);
- return JobId;
-}
-
-/*
- * Check if the device is blocked or not
- */
-bool is_device_unmounted(DEVICE *dev)
-{
- bool stat;
- int blocked = dev->blocked();
- stat = (blocked == BST_UNMOUNTED) ||
- (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
- return stat;
-}
-
-#ifdef SD_DEBUG_LOCK
-void DEVICE::_dlock(const char *file, int line)
-{
- Dmsg4(sd_dbglvl, "dlock from %s:%d precnt=%d JobId=%u\n", file, line,
- m_count, get_jobid_from_tid());
- /* Note, this *really* should be protected by a mutex, but
- * since it is only debug code we don't worry too much.
- */
- if (m_count > 0 && pthread_equal(m_pid, pthread_self())) {
- Dmsg2(sd_dbglvl, "DEADLOCK !!!!!!!!!! from %s:%d\n", file, line);
- }
- P(m_mutex);
- m_pid = pthread_self();
- m_count++;
-}
-
-void DEVICE::_dunlock(const char *file, int line)
-{
- m_count--;
- Dmsg4(sd_dbglvl, "dunlock from %s:%d postcnt=%d JobId=%u\n", file, line,
- m_count, get_jobid_from_tid());
- V(m_mutex);
-}
-
-void DEVICE::_r_dunlock(const char *file, int line)
-{
- this->_dunlock(file, line);
-}
-
-#endif
-
-
-/*
- * This is a recursive lock that checks if the device is blocked.
- *
- * When 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.
- */
-#ifdef SD_DEBUG_LOCK
-void DEVICE::_r_dlock(const char *file, int line)
-#else
-void DEVICE::r_dlock()
-#endif
-{
- int stat;
-#ifdef SD_DEBUG_LOCK
- Dmsg4(sd_dbglvl, "r_dlock blked=%s from %s:%d JobId=%u\n", this->print_blocked(),
- file, line, get_jobid_from_tid());
-#else
- Dmsg1(sd_dbglvl, "reclock blked=%s\n", this->print_blocked());
-#endif
- this->dlock();
- if (this->blocked() && !pthread_equal(this->no_wait_id, pthread_self())) {
- this->num_waiting++; /* indicate that I am waiting */
- while (this->blocked()) {
- Dmsg3(sd_dbglvl, "r_dlock blked=%s no_wait=%p me=%p\n", this->print_blocked(),
- this->no_wait_id, pthread_self());
- if ((stat = pthread_cond_wait(&this->wait, &m_mutex)) != 0) {
- berrno be;
- this->dunlock();
- Emsg1(M_ABORT, 0, _("pthread_cond_wait failure. ERR=%s\n"),
- be.strerror(stat));
- }
- }
- this->num_waiting--; /* no longer waiting */
- }
-}
-
-/*
- * Block all other threads from using the device
- * Device must already be locked. After this call,
- * the device is blocked to any thread calling dev->r_lock(),
- * but the device is not locked (i.e. no P on device). Also,
- * the current thread can do slip through the dev->r_lock()
- * calls without blocking.
- */
-void _block_device(const char *file, int line, DEVICE *dev, int state)
-{
- Dmsg3(sd_dbglvl, "block set %d from %s:%d\n", state, file, line);
-
- ASSERT(dev->blocked() == BST_NOT_BLOCKED);
- dev->set_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.
- * Enter: device locked
- * Exit: device locked
- */
-void _unblock_device(const char *file, int line, DEVICE *dev)
-{
- Dmsg3(sd_dbglvl, "unblock %s from %s:%d\n", dev->print_blocked(), file, line);
- ASSERT(dev->blocked());
- dev->set_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(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state)
-{
-
- Dmsg3(sd_dbglvl, "steal lock. old=%s from %s:%d\n", dev->print_blocked(),
- file, line);
- hold->dev_blocked = dev->blocked();
- hold->dev_prev_blocked = dev->dev_prev_blocked;
- hold->no_wait_id = dev->no_wait_id;
- dev->set_blocked(state);
- Dmsg1(sd_dbglvl, "steal lock. new=%s\n", dev->print_blocked());
- dev->no_wait_id = pthread_self();
- dev->dunlock();
-}
-
-/*
- * Enter with device blocked by us but not locked
- * Exit with device locked, and blocked by previous owner
- */
-void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
-{
- Dmsg3(sd_dbglvl, "return lock. old=%s from %s:%d\n",
- dev->print_blocked(), file, line);
- dev->dlock();
- dev->set_blocked(hold->dev_blocked);
- dev->dev_prev_blocked = hold->dev_prev_blocked;
- dev->no_wait_id = hold->no_wait_id;
- Dmsg1(sd_dbglvl, "return lock. new=%s\n", dev->print_blocked());
- if (dev->num_waiting > 0) {
- pthread_cond_broadcast(&dev->wait); /* wake them up */
- }
-}
projects / bacula / bacula / blobdiff