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

diff --git a/bacula/src/stored/device.c b/bacula/src/stored/device.c
index 5a59c94688..679a158a5f 100644
--- a/bacula/src/stored/device.c
+++ b/bacula/src/stored/device.c
@@ -1,3 +1,30 @@
+/*
+   Bacula® - The Network Backup Solution
+
+   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 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
+   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
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.
+
+   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.
+*/
 /*
  *
  *  Higher Level Device routines.
@@ -12,7 +39,7 @@
  *        Obviously, no zzz_dev() is allowed to call
  *        a www_device() or everything falls apart.
  *
- * Concerning the routines lock_device() and block_device()
+ * Concerning the routines dev->r_lock()() and block_device()
  *  see the end of this module for details.  In general,
  *  blocking a device leaves it in a state where all threads
  *  other than the current thread block when they attempt to
@@ -28,29 +55,12 @@
  *
  *   Version $Id$
  */
-/*
-   Copyright (C) 2000-2005 Kern Sibbald
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License
-   version 2 as amended with additional clauses defined in the
-   file LICENSE in the main source directory.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
-   the file LICENSE for additional details.
-
- */
 
 #include "bacula.h"                   /* pull in global headers */
 #include "stored.h"                   /* pull in Storage Deamon headers */
 
 /* Forward referenced functions */
 
-extern char my_name[];
-extern int debug_level;
-
 /*
  * This is the dreaded moment. We either have an end of
  * medium condition or worse, and error condition.
@@ -66,14 +76,14 @@ extern int debug_level;
  * We enter with device locked, and
  *     exit with device locked.
  *
- * Note, we are called only from one place in block.c
+ * Note, we are called only from one place in block.c for the daemons.  
+ *     The btape utility calls it from btape.c.
  *
  *  Returns: true  on success
  *           false on failure
  */
 bool fixup_device_block_write_error(DCR *dcr)
 {
-   uint32_t stat;
    char PrevVolName[MAX_NAME_LENGTH];
    DEV_BLOCK *label_blk;
    DEV_BLOCK *block = dcr->block;
@@ -82,18 +92,23 @@ 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);
-   stat = status_dev(dev);
-   if (!(stat & BMT_EOD)) {
-      return false;                    /* this really shouldn't happen */
-   }
 
-   Dmsg0(100, "======= Got EOD ========\n");
+   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 */
-   unlock_device(dev);
+
+   /* Continue unlocked, but leave BLOCKED */
+   dev->dunlock();
 
    bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName));
    bstrncpy(dev->VolHdr.PrevVolumeName, PrevVolName, sizeof(dev->VolHdr.PrevVolumeName));
@@ -107,14 +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;
-      P(dev->mutex);
-      unblock_device(dev);
-      return false;                /* device locked */
+      dev->dlock();  
+      goto bail_out;
    }
-   P(dev->mutex);                  /* lock again */
+   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, 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)));
@@ -129,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;
@@ -141,8 +160,7 @@ bool fixup_device_block_write_error(DCR *dcr)
    /*
     * 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)); ) {
+   Dmsg1(100, "Notify vol change. Volume=%s\n", dev->VolCatInfo.VolCatName);
    DCR *mdcr;
    foreach_dlist(mdcr, dev->attached_dcrs) {
       JCR *mjcr = mdcr->jcr;
@@ -166,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);
+   }
 }
 
 /*
@@ -183,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;
-   jcr->NumVolumes++;
+   set_new_file_parameters(dcr);
+   jcr->NumWriteVolumes++;
    dcr->NewVol = false;
-   dcr->WroteVol = false;
 }
 
 /*
@@ -210,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;
@@ -246,39 +266,38 @@ void set_new_file_parameters(DCR *dcr)
 bool first_open_device(DCR *dcr)
 {
    DEVICE *dev = dcr->dev;
+   bool ok = true;
 
    Dmsg0(120, "start open_output_device()\n");
    if (!dev) {
       return false;
    }
 
-   lock_device(dev);
+   dev->r_dlock();
 
    /* Defer opening files */
    if (!dev->is_tape()) {
       Dmsg0(129, "Device is file, deferring open.\n");
-      unlock_device(dev);
-      return true;
+      goto bail_out;
    }
 
     int mode;
-    if (dev_cap(dev, CAP_STREAM)) {
+    if (dev->has_cap(CAP_STREAM)) {
        mode = OPEN_WRITE_ONLY;
     } else {
        mode = OPEN_READ_ONLY;
     }
    Dmsg0(129, "Opening device.\n");
-   dev->open_nowait = true;
    if (dev->open(dcr, mode) < 0) {
       Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
-      dev->open_nowait = false;
-      unlock_device(dev);
-      return false;
+      ok = false;
+      goto bail_out;
    }
    Dmsg1(129, "open dev %s OK\n", dev->print_name());
-   dev->open_nowait = false;
-   unlock_device(dev);
-   return true;
+
+bail_out:
+   dev->dunlock();
+   return ok;
 }
 
 /*
@@ -289,7 +308,7 @@ bool open_device(DCR *dcr)
    DEVICE *dev = dcr->dev;
    /* Open device */
    int mode;
-   if (dev_cap(dev, CAP_STREAM)) {
+   if (dev->has_cap(CAP_STREAM)) {
       mode = OPEN_WRITE_ONLY;
    } else {
       mode = OPEN_READ_WRITE;
@@ -298,169 +317,13 @@ bool open_device(DCR *dcr)
       /* If polling, ignore the error */
       /* If DVD, also ignore the error, very often you cannot open the device
        * (when there is no DVD, or when the one inserted is a wrong one) */
-      if ((!dev->poll) && (!dev->is_dvd())) {
+      if (!dev->poll && !dev->is_dvd() && !dev->is_removable()) {
          Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
-            dev->print_name(), strerror_dev(dev));
+            dev->print_name(), dev->bstrerror());
          Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"), 
-            dev->print_name(), strerror_dev(dev));
+            dev->print_name(), dev->bstrerror());
       }
       return false;
    }
    return true;
 }
-
-/*
- * Release any Volume attached to this device 
- *  then close the device.
- */
-void close_device(DEVICE *dev)
-{
-   free_volume(dev);
-   dev->close();
-}
-
-/*
- * Used when unmounting the device, ignore use_count
- */
-void force_close_device(DEVICE *dev)
-{
-   if (!dev) {
-      Mmsg0(dev->errmsg, _("Bad call to force_close_dev. Device not open\n"));
-      Emsg0(M_FATAL, 0, dev->errmsg);
-      return;
-   }
-   Dmsg1(29, "Force close_dev %s\n", dev->print_name());
-   dev->use_count = 1;
-   dev->close();
-
-#ifdef FULL_DEBUG
-   ASSERT(dev->use_count >= 0);
-#endif
-}
-
-
-void dev_lock(DEVICE *dev)
-{
-   int errstat;
-   if ((errstat=rwl_writelock(&dev->lock))) {
-      Emsg1(M_ABORT, 0, _("Device write lock failure. ERR=%s\n"), strerror(errstat));
-   }
-}
-
-void dev_unlock(DEVICE *dev)
-{
-   int errstat;
-   if ((errstat=rwl_writeunlock(&dev->lock))) {
-      Emsg1(M_ABORT, 0, _("Device write unlock failure. ERR=%s\n"), strerror(errstat));
-   }
-}
-
-/*
- * 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(const char *file, int line, DEVICE *dev)
-{
-   int stat;
-   Dmsg3(500, "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 */
-      while (dev->dev_blocked) {
-         if ((stat = pthread_cond_wait(&dev->wait, &dev->mutex)) != 0) {
-            V(dev->mutex);
-            Emsg1(M_ABORT, 0, _("pthread_cond_wait failure. ERR=%s\n"),
-               strerror(stat));
-         }
-      }
-      dev->num_waiting--;             /* no longer waiting */
-   }
-}
-
-/*
- * Check if the device is blocked or not
- */
-bool is_device_unmounted(DEVICE *dev)
-{
-   bool stat;
-   int blocked = dev->dev_blocked;
-   stat = (blocked == BST_UNMOUNTED) ||
-          (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
-   return stat;
-}
-
-void _unlock_device(const char *file, int line, DEVICE *dev)
-{
-   Dmsg2(500, "unlock from %s:%d\n", file, line);
-   V(dev->mutex);
-}
-
-/*
- * Block all other threads from using the device
- *  Device must already be locked.  After this call,
- *  the device is blocked to any thread calling lock_device(),
- *  but the device is not locked (i.e. no P on device).  Also,
- *  the current thread can do slip through the lock_device()
- *  calls without blocking.
- */
-void _block_device(const char *file, int line, DEVICE *dev, int state)
-{
-   Dmsg3(500, "block set %d from %s:%d\n", state, file, line);
-   ASSERT(dev->get_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.
- */
-void _unblock_device(const char *file, int line, DEVICE *dev)
-{
-   Dmsg3(500, "unblock %s from %s:%d\n", dev->print_blocked(), file, line);
-   ASSERT(dev->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(400, "steal lock. old=%s from %s:%d\n", dev->print_blocked(),
-      file, line);
-   hold->dev_blocked = dev->get_blocked();
-   hold->dev_prev_blocked = dev->dev_prev_blocked;
-   hold->no_wait_id = dev->no_wait_id;
-   dev->set_blocked(state);
-   Dmsg1(400, "steal lock. new=%s\n", dev->print_blocked());
-   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(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
-{
-   Dmsg3(400, "return lock. old=%s from %s:%d\n",
-      dev->print_blocked(), file, line);
-   P(dev->mutex);
-   dev->dev_blocked = hold->dev_blocked;
-   dev->dev_prev_blocked = hold->dev_prev_blocked;
-   dev->no_wait_id = hold->no_wait_id;
-   Dmsg1(400, "return lock. new=%s\n", dev->print_blocked());
-   if (dev->num_waiting > 0) {
-      Dmsg0(400, "Broadcast\n");
-      pthread_cond_broadcast(&dev->wait); /* wake them up */
-   }
-}