X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fdevice.c;h=679a158a5f028d6adc57bfe73c766e0b56fdad6f;hb=36b40d5c7f3ff90565ab73ac75f0dc4f6660ff37;hp=7215c35cfcfc626c90f15de8dc443fa9507bf92a;hpb=568b00cd536edc659ef13ddf625222d4523d0f25;p=bacula%2Fbacula

diff --git a/bacula/src/stored/device.c b/bacula/src/stored/device.c
index 7215c35cfc..679a158a5f 100644
--- a/bacula/src/stored/device.c
+++ b/bacula/src/stored/device.c
@@ -1,14 +1,14 @@
 /*
    Bacula® - The Network Backup Solution
 
-   Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
+   Copyright (C) 2000-2008 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
-   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
@@ -20,7 +20,7 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 
-   Bacula® is a registered trademark of John Walker.
+   Bacula® is a registered trademark of Kern Sibbald.
    The licensor of Bacula is the Free Software Foundation Europe
    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
    Switzerland, email:ftf@fsfeurope.org.
@@ -59,13 +59,6 @@
 #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 */
 
 /*
@@ -99,13 +92,22 @@ bool fixup_device_block_write_error(DCR *dcr)
    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));
@@ -120,17 +122,19 @@ bool fixup_device_block_write_error(DCR *dcr)
         edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
         bstrftime(dt, sizeof(dt), time(NULL)));
 
-   if (!mount_next_write_volume(dcr, 1)) {
+   Dmsg0(050, "set_unload\n");
+   dev->set_unload();
+   if (!dcr->mount_next_write_volume()) {
       free_block(label_blk);
       dcr->block = block;
       dev->dlock();  
-      unblock_device(dev);
-      return false;                /* device locked */
+      goto bail_out;
    }
+   Dmsg1(050, "must_unload=%d\n", dev->must_unload());
    dev->dlock();                    /* lock again */
 
    dev->VolCatInfo.VolCatJobs++;              /* increment number of jobs on vol */
-   dir_update_volume_info(dcr, false);        /* send Volume info to Director */
+   dir_update_volume_info(dcr, false, false); /* send Volume info to Director */
 
    Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
       dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
@@ -145,11 +149,10 @@ bool fixup_device_block_write_error(DCR *dcr)
    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;
@@ -157,7 +160,7 @@ bool fixup_device_block_write_error(DCR *dcr)
    /*
     * Walk through all attached jcrs indicating the volume has changed
     */
-   Dmsg1(100, "Walk attached dcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
+   Dmsg1(100, "Notify vol change. Volume=%s\n", dev->VolCatInfo.VolCatName);
    DCR *mdcr;
    foreach_dlist(mdcr, dev->attached_dcrs) {
       JCR *mjcr = mdcr->jcr;
@@ -181,13 +184,35 @@ bool fixup_device_block_write_error(DCR *dcr)
    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 */
+}
+
+void set_start_vol_position(DCR *dcr)
+{
+   DEVICE *dev = dcr->dev;
+   /* Set new start position */
+   if (dev->is_tape()) {
+      dcr->StartBlock = dev->block_num;
+      dcr->StartFile = dev->file;
+   } else {
+      dcr->StartBlock = (uint32_t)dev->file_addr;
+      dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
+   }
 }
 
 /*
@@ -198,24 +223,12 @@ bool fixup_device_block_write_error(DCR *dcr)
 void set_new_volume_parameters(DCR *dcr)
 {
    JCR *jcr = dcr->jcr;
-   DEVICE *dev = dcr->dev;
    if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
       Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
    }
-   /* Set new start/end positions */
-   if (dev->is_tape()) {
-      dcr->StartBlock = dev->block_num;
-      dcr->StartFile = dev->file;
-   } else {
-      dcr->StartBlock = (uint32_t)dev->file_addr;
-      dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
-   }
-   /* Reset indicies */
-   dcr->VolFirstIndex = 0;
-   dcr->VolLastIndex = 0;
+   set_new_file_parameters(dcr);
    jcr->NumWriteVolumes++;
    dcr->NewVol = false;
-   dcr->WroteVol = false;
 }
 
 /*
@@ -225,16 +238,8 @@ void set_new_volume_parameters(DCR *dcr)
  */
 void set_new_file_parameters(DCR *dcr)
 {
-   DEVICE *dev = dcr->dev;
+   set_start_vol_position(dcr);
 
-   /* Set new start/end positions */
-   if (dev->is_tape()) {
-      dcr->StartBlock = dev->block_num;
-      dcr->StartFile = dev->file;
-   } else {
-      dcr->StartBlock = (uint32_t)dev->file_addr;
-      dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
-   }
    /* Reset indicies */
    dcr->VolFirstIndex = 0;
    dcr->VolLastIndex = 0;
@@ -322,174 +327,3 @@ bool open_device(DCR *dcr)
    }
    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;
-}
-
-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);   
-}
-
-#ifdef SD_DEBUG_LOCK
-void DEVICE::_r_dunlock(const char *file, int line)
-{
-   this->_dunlock(file, line);
-}
-#else
-void DEVICE::r_dunlock()
-{
-   this->dunlock();
-}
-#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 */
-   }
-}