/*
Bacula® - The Network Backup Solution
- Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
+ Copyright (C) 2000-2010 Free Software Foundation Europe e.V.
The main author of Bacula is Kern Sibbald, with contributions from
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
+ modify it under the terms of version three of the GNU Affero General Public
License as published by the Free Software Foundation and included
in the file LICENSE.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU Affero General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
*
* Kern Sibbald, 2000-2007. June 2007
*
- * Version $Id$
*/
#include "bacula.h" /* pull in global headers */
* 2. dlock() simple mutex that locks the device structure. A dlock
* can be acquired while a device is blocked if it is not
* locked.
- * 3. r_dlock "recursive" dlock, when means that a dlock (mutex)
+ * 3. r_dlock(locked) "recursive" dlock, when means that a dlock (mutex)
* will be acquired on the device if it is not blocked
* by some other thread. If the device was blocked by
* the current thread, it will acquire the lock.
* If some other thread has set a block on the device,
* this call will wait until the device is unblocked.
+ * Can be called with locked true, which means the
+ * dlock is already set
*
* A lock is normally set when modifying the device structure.
* A r_lock is normally acquired when you want to block the device
* DEVICE::dlock() does P(m_mutex) (in dev.h)
* DEVICE::dunlock() does V(m_mutex)
*
- * DEVICE::r_dlock() allows locking the device when this thread
- already has the device blocked.
- * dlock()
+ * DEVICE::r_dlock(locked) allows locking the device when this thread
+ * already has the device blocked.
+ * if (!locked)
+ * dlock()
* if blocked and not same thread that locked
* pthread_cond_wait
* leaves device locked
* and preparing the label.
*/
#ifdef SD_DEBUG_LOCK
-void DEVICE::_r_dlock(const char *file, int line)
+void DEVICE::_r_dlock(const char *file, int line, bool locked)
{
Dmsg3(sd_dbglvl+1, "r_dlock blked=%s from %s:%d\n", this->print_blocked(),
file, line);
#else
-void DEVICE::r_dlock()
+void DEVICE::r_dlock(bool locked)
{
#endif
int stat;
- P(m_mutex); /* this->dlock(); */
- m_count++; /* this->dlock() */
+ if (!locked) {
+ P(m_mutex); /* this->dlock(); */
+ m_count++; /* this->dlock() */
+ }
if (this->blocked() && !pthread_equal(this->no_wait_id, pthread_self())) {
this->num_waiting++; /* indicate that I am waiting */
while (this->blocked()) {
*/
void _block_device(const char *file, int line, DEVICE *dev, int state)
{
+// ASSERT(lmgr_mutex_is_locked(&dev->m_mutex) == 1);
ASSERT(dev->blocked() == BST_NOT_BLOCKED);
dev->set_blocked(state); /* make other threads wait */
dev->no_wait_id = pthread_self(); /* allow us to continue */
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(lmgr_mutex_is_locked(&dev->m_mutex) == 1);
ASSERT(dev->blocked());
dev->set_blocked(BST_NOT_BLOCKED);
clear_thread_id(dev->no_wait_id);
return "BST_MOUNT";
case BST_DESPOOLING:
return "BST_DESPOOLING";
+ case BST_RELEASING:
+ return "BST_RELEASING";
default:
return _("unknown blocked code");
}
/*
* Check if the device is blocked or not
*/
-bool is_device_unmounted(DEVICE *dev)
+bool DEVICE::is_device_unmounted()
{
bool stat;
- int blocked = dev->blocked();
- stat = (blocked == BST_UNMOUNTED) ||
- (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
+ int blk = blocked();
+ stat = (blk == BST_UNMOUNTED) ||
+ (blk == BST_UNMOUNTED_WAITING_FOR_SYSOP);
return stat;
}