- Added argument to berrno::strerror() to pass errno.

- Cleaned up a few more old strerror() calls and eliminated a
  few of the now unnecessary set_errno() calls.
- Fixed a bug in the polling code that prevented more than 100
  label reads (insanity check disabled if polling).
- Ignore bad return from open_device() if polling.
- Short circuit code if fatal error return from read_label() in
  mount.c

git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@1578 91ce42f0-d328-0410-95d8-f526ca767f89

diff --git a/bacula/src/dird/fd_cmds.c b/bacula/src/dird/fd_cmds.c
index e6e2853a3c87a2be3f935b1725505521f2100095..cb0175610c429096e7526aaa09e48ae5da140606 100644 (file)
--- a/bacula/src/dird/fd_cmds.c
+++ b/bacula/src/dird/fd_cmds.c
@@ -277,9 +277,8 @@ static int send_list(JCR *jcr, int list)
            }
            if ((stat=close_bpipe(bpipe)) != 0) {
               berrno be;
-              be.set_errno(stat);
                Jmsg(jcr, M_FATAL, 0, _("Error running program %p: ERR=%s\n"),
-                 p, be.strerror());
+                 p, be.strerror(stat));
               goto bail_out;
            }
            break;
@@ -407,8 +406,9 @@ static int send_fileset(JCR *jcr)
                fd->msg = edit_job_codes(jcr, fd->msg, p, "");
                bpipe = open_bpipe(fd->msg, 0, "r");
               if (!bpipe) {
+                 berrno be;
                   Jmsg(jcr, M_FATAL, 0, _("Cannot run program: %s. ERR=%s\n"),
-                    p, strerror(errno));
+                    p, be.strerror());
                  goto bail_out;
               }
                bstrncpy(buf, "F ", sizeof(buf));
@@ -424,17 +424,17 @@ static int send_fileset(JCR *jcr)
               }
               if ((stat=close_bpipe(bpipe)) != 0) {
                  berrno be;
-                 be.set_errno(stat);
                   Jmsg(jcr, M_FATAL, 0, _("Error running program: %s. ERR=%s\n"),
-                    p, be.strerror());
+                    p, be.strerror(stat));
                  goto bail_out;
               }
               break;
             case '<':
               p++;                      /* skip over < */
                if ((ffd = fopen(p, "r")) == NULL) {
+                 berrno be;
                   Jmsg(jcr, M_FATAL, 0, _("Cannot open included file: %s. ERR=%s\n"),
-                    p, strerror(errno));
+                    p, be.strerror());
                  goto bail_out;
               }
                bstrncpy(buf, "F ", sizeof(buf));
@@ -531,8 +531,9 @@ int send_bootstrap_file(JCR *jcr)
    }
    bs = fopen(jcr->RestoreBootstrap, "r");
    if (!bs) {
+      berrno be;
       Jmsg(jcr, M_FATAL, 0, _("Could not open bootstrap file %s: ERR=%s\n"), 
-        jcr->RestoreBootstrap, strerror(errno));
+        jcr->RestoreBootstrap, be.strerror());
       set_jcr_job_status(jcr, JS_ErrorTerminated);
       return 0;
    }

diff --git a/bacula/src/dird/job.c b/bacula/src/dird/job.c
index 61987e12e9277c2f1ac0873ef4efb59fc655fe27..75c00d66015700c57666b6b274300f01ada7cc54 100644 (file)
--- a/bacula/src/dird/job.c
+++ b/bacula/src/dird/job.c
@@ -58,8 +58,7 @@ void init_job_server(int max_workers)
    
    if ((stat = jobq_init(&job_queue, max_workers, job_thread)) != 0) {
       berrno be;
-      be.set_errno(stat);
-      Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), be.strerror());
+      Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), be.strerror(stat));
    }
    if ((wd = new_watchdog()) == NULL) {
       Emsg0(M_ABORT, 0, _("Could not init job monitor watchdogs\n"));
@@ -77,8 +76,7 @@ void term_job_server()
    int stat;
    if ((stat=jobq_destroy(&job_queue)) != 0) {
       berrno be;
-      be.set_errno(stat);
-      Emsg1(M_INFO, 0, _("Could not term job queue: ERR=%s\n"), be.strerror());
+      Emsg1(M_INFO, 0, _("Could not term job queue: ERR=%s\n"), be.strerror(stat));
    }
 }
 
@@ -102,8 +100,7 @@ JobId_t run_job(JCR *jcr)
    /* Initialize termination condition variable */
    if ((errstat = pthread_cond_init(&jcr->term_wait, NULL)) != 0) {
       berrno be;
-      be.set_errno(errstat);
-      Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.strerror());
+      Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.strerror(errstat));
       goto bail_out;
    }
    jcr->term_wait_inited = true;
@@ -144,8 +141,7 @@ JobId_t run_job(JCR *jcr)
    /* Queue the job to be run */
    if ((stat = jobq_add(&job_queue, jcr)) != 0) {
       berrno be;
-      be.set_errno(stat);
-      Jmsg(jcr, M_FATAL, 0, _("Could not add job queue: ERR=%s\n"), be.strerror());
+      Jmsg(jcr, M_FATAL, 0, _("Could not add job queue: ERR=%s\n"), be.strerror(stat));
       JobId = 0;
       goto bail_out;
    }
@@ -206,8 +202,7 @@ static void *job_thread(void *arg)
            status = close_bpipe(bpipe);
            if (status != 0) {
               berrno be;
-              be.set_errno(status);
-               Jmsg(jcr, M_FATAL, 0, _("RunBeforeJob error: ERR=%s\n"), be.strerror());
+               Jmsg(jcr, M_FATAL, 0, _("RunBeforeJob error: ERR=%s\n"), be.strerror(status));
               set_jcr_job_status(jcr, JS_FatalError);
               update_job_end_record(jcr);
               goto bail_out;
@@ -266,11 +261,10 @@ static void *job_thread(void *arg)
             */
            if (status != 0) {
               berrno be;
-              be.set_errno(status);
               if (jcr->JobStatus == JS_Terminated) {
-                  Jmsg(jcr, M_WARNING, 0, _("RunAfterJob error: ERR=%s\n"), be.strerror());
+                  Jmsg(jcr, M_WARNING, 0, _("RunAfterJob error: ERR=%s\n"), be.strerror(status));
               } else {
-                  Jmsg(jcr, M_FATAL, 0, _("RunAfterFailedJob error: ERR=%s\n"), be.strerror());
+                  Jmsg(jcr, M_FATAL, 0, _("RunAfterFailedJob error: ERR=%s\n"), be.strerror(status));
               }
            }
         }

diff --git a/bacula/src/lib/berrno.h b/bacula/src/lib/berrno.h
index ccdc01791b64e754681acd9200b7b208ad995269..1879ded31ab475d1bb688564ac118293cbe76163 100644 (file)
--- a/bacula/src/lib/berrno.h
+++ b/bacula/src/lib/berrno.h
@@ -49,6 +49,7 @@ public:
    berrno(int pool=PM_EMSG);
    ~berrno();
    const char *strerror();
+   const char *strerror(int errnum);
    void set_errno(int errnum);
 };
 
@@ -64,6 +65,13 @@ inline berrno::~berrno()
    free_pool_memory(buf_);
 }
 
+inline const char *berrno::strerror(int errnum)
+{
+   berrno_ = errnum;
+   return berrno::strerror();
+}
+
+
 inline void berrno::set_errno(int errnum)
 {
    berrno_ = errnum;

diff --git a/bacula/src/stored/askdir.c b/bacula/src/stored/askdir.c
index 418342faad8000b048ea89d89099a3aa99c05cc9..4080802edbf1f9bc7c73c4c72ed356dffd1c8af9 100644 (file)
--- a/bacula/src/stored/askdir.c
+++ b/bacula/src/stored/askdir.c
@@ -336,7 +336,7 @@ bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
    DEVICE *dev = dcr->dev;
    JCR *jcr = dcr->jcr;
 
-   Dmsg0(130, "enter dir_ask_sysop_to_create_appendable_volume\n");
+   Dmsg0(200, "enter dir_ask_sysop_to_create_appendable_volume\n");
    ASSERT(dev->dev_blocked);
    for ( ;; ) {
       if (job_canceled(jcr)) {
@@ -359,7 +359,7 @@ bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
         if (!unmounted && ((jcr->VolumeName[0] && !dev_cap(dev, CAP_REM) && 
                dev_cap(dev, CAP_LABEL)) ||
                 (jcr->VolumeName[0] && jcr->VolCatInfo.Slot))) {
-            Dmsg0(100, "Return 1 from mount without wait.\n");
+            Dmsg0(200, "Return 1 from mount without wait.\n");
            return true;
         }
         jstat = JS_WaitMount;
@@ -368,7 +368,7 @@ bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
 "Please mount Volume \"%s\" on Storage Device \"%s\" for Job %s\n"
 "Use \"mount\" command to release Job.\n"),
              jcr->VolumeName, jcr->dev_name, jcr->Job);
-            Dmsg3(190, "Mount %s on %s for Job %s\n",
+            Dmsg3(200, "Mount %s on %s for Job %s\n",
                  jcr->VolumeName, jcr->dev_name, jcr->Job);
         }
       } else {
@@ -399,25 +399,27 @@ Please use the \"label\"  command to create a new Volume for:\n\
 
       if (stat == ETIMEDOUT) {
         if (!double_dev_wait_time(dev)) {
-            Mmsg(dev->errmsg, _("Gave up waiting to mount Storage Device \"%s\" for Job %s\n"), 
+            Mmsg(dev->errmsg, _("Max time exceeded waiting to mount Storage Device \"%s\" for Job %s\n"), 
               dev_name(dev), jcr->Job);
             Jmsg(jcr, M_FATAL, 0, "%s", dev->errmsg);
-            Dmsg1(190, "Gave up waiting on device %s\n", dev_name(dev));
+            Dmsg1(200, "Gave up waiting on device %s\n", dev_name(dev));
            return false;             /* exceeded maximum waits */
         }
         continue;
       }
       if (stat == EINVAL) {
+        berrno be;
          Mmsg2(dev->errmsg, _("pthread error in mount_next_volume stat=%d ERR=%s\n"),
-              stat, strerror(stat));
+              stat, be.strerror(stat));
          Jmsg(jcr, M_FATAL, 0, "%s", dev->errmsg);
         return false;
       }
       if (stat != 0) {
+        berrno be;
          Jmsg(jcr, M_WARNING, 0, _("pthread error in mount_next_volume stat=%d ERR=%s\n"), stat,
-           strerror(stat));
+           be.strerror(stat));
       }
-      Dmsg1(190, "Someone woke me for device %s\n", dev_name(dev));
+      Dmsg1(200, "Someone woke me for device %s\n", dev_name(dev));
 
       /* If no VolumeName, and cannot get one, try again */
       if (jcr->VolumeName[0] == 0 && !job_canceled(jcr) &&
@@ -442,7 +444,7 @@ volumes for Job=%s.\n"), jcr->Job);
    }
    set_jcr_job_status(jcr, JS_Running);
    dir_send_job_status(jcr);
-   Dmsg0(130, "leave dir_ask_sysop_to_mount_create_appendable_volume\n");
+   Dmsg0(200, "leave dir_ask_sysop_to_mount_create_appendable_volume\n");
    return true;
 }
 
@@ -465,7 +467,7 @@ bool dir_ask_sysop_to_mount_volume(DCR *dcr)
    DEVICE *dev = dcr->dev;
    JCR *jcr = dcr->jcr;
 
-   Dmsg0(130, "enter dir_ask_sysop_to_mount_volume\n");
+   Dmsg0(200, "enter dir_ask_sysop_to_mount_volume\n");
    if (!jcr->VolumeName[0]) {
       Mmsg0(dev->errmsg, _("Cannot request another volume: no volume name given.\n"));
       return 0;
@@ -482,7 +484,7 @@ bool dir_ask_sysop_to_mount_volume(DCR *dcr)
          msg = _("Please mount");
          Jmsg(jcr, M_MOUNT, 0, _("%s Volume \"%s\" on Storage Device \"%s\" for Job %s\n"),
              msg, jcr->VolumeName, jcr->dev_name, jcr->Job);
-         Dmsg3(190, "Mount %s on %s for Job %s\n",
+         Dmsg3(200, "Mount %s on %s for Job %s\n",
               jcr->VolumeName, jcr->dev_name, jcr->Job);
       }
 
@@ -492,36 +494,38 @@ bool dir_ask_sysop_to_mount_volume(DCR *dcr)
       stat = wait_for_sysop(dcr);    ;    /* wait on device */
       if (dev->poll) {
          Dmsg1(200, "Poll timeout in mount vol on device %s\n", dev_name(dev));
-         Dmsg1(200, "Blocked=%d\n", dev->dev_blocked);
+         Dmsg1(200, "Blocked=%s\n", edit_blocked_reason(dev));
         return true;
       }
 
       if (stat == ETIMEDOUT) {
         if (!double_dev_wait_time(dev)) {
-            Mmsg(dev->errmsg, _("Gave up waiting to mount Storage Device \"%s\" for Job %s\n"), 
+            Mmsg(dev->errmsg, _("Max time exceeded waiting to mount Storage Device \"%s\" for Job %s\n"), 
               dev_name(dev), jcr->Job);
             Jmsg(jcr, M_FATAL, 0, "%s", dev->errmsg);
-            Dmsg1(190, "Gave up waiting on device %s\n", dev_name(dev));
+            Dmsg1(200, "Gave up waiting on device %s\n", dev_name(dev));
            return false;             /* exceeded maximum waits */
         }
         continue;
       }
       if (stat == EINVAL) {
+        berrno be;
          Mmsg2(dev->errmsg, _("pthread error in mount_volume stat=%d ERR=%s\n"),
-              stat, strerror(stat));
+              stat, be.strerror(stat));
          Jmsg(jcr, M_FATAL, 0, "%s", dev->errmsg);
         return false;
       }
       if (stat != 0) {
+        berrno be;
          Jmsg(jcr, M_ERROR, 0, _("pthread error in mount_next_volume stat=%d ERR=%s\n"), stat,
-           strerror(stat));
+           be.strerror(stat));
       }
-      Dmsg1(190, "Someone woke me for device %s\n", dev_name(dev));
+      Dmsg1(200, "Someone woke me for device %s\n", dev_name(dev));
       break;
    }
    set_jcr_job_status(jcr, JS_Running);
    dir_send_job_status(jcr);
-   Dmsg0(130, "leave dir_ask_sysop_to_mount_volume\n");
+   Dmsg0(200, "leave dir_ask_sysop_to_mount_volume\n");
    return true;
 }
 
@@ -556,6 +560,9 @@ static int wait_for_sysop(DCR *dcr)
    if (me->heartbeat_interval && add_wait > me->heartbeat_interval) {
       add_wait = me->heartbeat_interval;
    }
+   /* If the user did not unmount the tape and we are polling, ensure
+    *  that we poll at the correct interval. 
+    */
    if (!unmounted && dev->vol_poll_interval && add_wait > dev->vol_poll_interval) {
       add_wait = dev->vol_poll_interval;
    }
@@ -571,11 +578,12 @@ static int wait_for_sysop(DCR *dcr)
    for ( ; !job_canceled(jcr); ) {
       time_t now, start;
 
-      Dmsg3(100, "I'm going to sleep on device %s. HB=%d wait=%d\n", dev_name(dev),
+      Dmsg3(200, "I'm going to sleep on device %s. HB=%d wait=%d\n", dev_name(dev),
         (int)me->heartbeat_interval, dev->wait_sec);
       start = time(NULL);
+      /* Wait required time */
       stat = pthread_cond_timedwait(&dev->wait_next_vol, &dev->mutex, &timeout);
-      Dmsg1(100, "Wokeup from sleep on device stat=%d\n", stat);
+      Dmsg1(200, "Wokeup from sleep on device stat=%d\n", stat);
 
       now = time(NULL);
       dev->rem_wait_sec -= (now - start);
@@ -586,7 +594,7 @@ static int wait_for_sysop(DCR *dcr)
            /* send heartbeats */
            if (jcr->file_bsock) {
               bnet_sig(jcr->file_bsock, BNET_HEARTBEAT);
-               Dmsg0(100, "Send heartbeat to FD.\n");
+               Dmsg0(200, "Send heartbeat to FD.\n");
            }
            if (jcr->dir_bsock) {
               bnet_sig(jcr->dir_bsock, BNET_HEARTBEAT);
@@ -605,14 +613,14 @@ static int wait_for_sysop(DCR *dcr)
         break;                    /* on error return */
       }
       if (dev->rem_wait_sec <= 0) {  /* on exceeding wait time return */
-         Dmsg0(100, "Exceed wait time.\n");
+         Dmsg0(200, "Exceed wait time.\n");
         break;
       }
       
       if (!unmounted && dev->vol_poll_interval &&      
          (now - first_start >= dev->vol_poll_interval)) {
-         Dmsg1(200, "In wait blocked=%d\n", dev->dev_blocked);
-        dev->poll = true;
+         Dmsg1(200, "In wait blocked=%s\n", edit_blocked_reason(dev));
+        dev->poll = true;            /* returning a poll event */
         break;
       }
       /*
@@ -633,7 +641,7 @@ static int wait_for_sysop(DCR *dcr)
       gettimeofday(&tv, &tz);
       timeout.tv_nsec = tv.tv_usec * 1000;
       timeout.tv_sec = tv.tv_sec + add_wait; /* additional wait */
-      Dmsg1(100, "Additional wait %d sec.\n", add_wait);
+      Dmsg1(200, "Additional wait %d sec.\n", add_wait);
    }
 
    if (!unmounted) {

diff --git a/bacula/src/stored/device.c b/bacula/src/stored/device.c
index 75c419405f3b559cde9d351f82eb3fecdf33b8b3..795119542226a9c6e617817d6336f351f8f27b9a 100644 (file)
--- a/bacula/src/stored/device.c
+++ b/bacula/src/stored/device.c
@@ -363,16 +363,37 @@ void _lock_device(const char *file, int line, DEVICE *dev)
 /*
  * Check if the device is blocked or not
  */
-int device_is_unmounted(DEVICE *dev)
+bool device_is_unmounted(DEVICE *dev)
 {
-   int stat;
-   P(dev->mutex);
-   stat = (dev->dev_blocked == BST_UNMOUNTED) ||
-         (dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
-   V(dev->mutex);
+   bool stat;
+   int blocked = dev->dev_blocked;
+   stat = (blocked == BST_UNMOUNTED) ||
+         (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
    return stat;
 }
 
+const char *edit_blocked_reason(DEVICE *dev)
+{
+   switch (dev->dev_blocked) {
+   case BST_NOT_BLOCKED:
+      return "not blocked";
+   case BST_UNMOUNTED:
+      return "user unmounted device";
+   case BST_WAITING_FOR_SYSOP:
+      return "waiting for operator action";      
+   case BST_DOING_ACQUIRE:
+      return "opening, validating, or positioning tape";
+   case BST_WRITING_LABEL:
+      return "labeling tape";
+   case BST_UNMOUNTED_WAITING_FOR_SYSOP:
+      return "closed by user during mount request";
+   case BST_MOUNT:
+      return "mount request";
+   default:
+      return "unknown blocked code";
+   }
+}
+
 void _unlock_device(const char *file, int line, DEVICE *dev) 
 {
    Dmsg2(500, "unlock from %s:%d\n", file, line);

diff --git a/bacula/src/stored/label.c b/bacula/src/stored/label.c
index a7d1b768aae0b330906eb47b538cf87954c7206e..c4a431b0c8066d71f33cf290b42309f88c3c6f59 100644 (file)
--- a/bacula/src/stored/label.c
+++ b/bacula/src/stored/label.c
@@ -76,8 +76,8 @@ int read_dev_volume_label(DCR *dcr, DEV_BLOCK *block)
          * Cancel Job if too many label errors
          *  => we are in a loop
          */
-        if (jcr->label_errors++ > 100) {
-            Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);
+        if (!dev->poll && jcr->label_errors++ > 100) {
+            Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg);
         }
         return jcr->label_status = VOL_NAME_ERROR;
       }
@@ -159,8 +159,8 @@ int read_dev_volume_label(DCR *dcr, DEV_BLOCK *block)
        * Cancel Job if too many label errors
        *  => we are in a loop
        */
-      if (jcr->label_errors++ > 100) {
-         Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);
+      if (!dev->poll && jcr->label_errors++ > 100) {
+         Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg);
       }
       return jcr->label_status = VOL_NAME_ERROR;
    }

diff --git a/bacula/src/stored/mount.c b/bacula/src/stored/mount.c
index e41724439ede81c48aff1c42a34459948f6983de..f03f9e68925e9f777c7e3be8ab284d5e71799f35 100644 (file)
--- a/bacula/src/stored/mount.c
+++ b/bacula/src/stored/mount.c
@@ -156,7 +156,11 @@ mount_next_vol:
 
    /* Ensure the device is open */
    if (!open_device(jcr, dev)) {
-      return false;
+      if (dev->poll) {
+        goto mount_next_vol;
+      } else {
+        return false;
+      }
    }
 
    /*
@@ -174,6 +178,9 @@ read_volume:
    } else {
       vol_label_status = read_dev_volume_label(jcr->dcr, block);
    }
+   if (job_canceled(jcr)) {
+      return false;
+   }
 
    Dmsg2(100, "dirVol=%s dirStat=%s\n", jcr->VolumeName,
       jcr->VolCatInfo.VolCatStatus);

diff --git a/bacula/src/stored/protos.h b/bacula/src/stored/protos.h
index f003e87493ac3fc9c6180fe55e35c09664b66bf3..e8aacfd71464e22d995bd85dc2fe478a8f7d0c42 100644 (file)
--- a/bacula/src/stored/protos.h
+++ b/bacula/src/stored/protos.h
@@ -28,174 +28,175 @@
 uint32_t new_VolSessionId();
 
 /* From acquire.c */
-DCR    *acquire_device_for_append(JCR *jcr);
-DCR    *acquire_device_for_read(JCR *jcr);
-bool    release_device(JCR *jcr);
-DCR    *new_dcr(JCR *jcr, DEVICE *dev);
-void    free_dcr(DCR *dcr);
+DCR     *acquire_device_for_append(JCR *jcr);
+DCR     *acquire_device_for_read(JCR *jcr);
+bool     release_device(JCR *jcr);
+DCR     *new_dcr(JCR *jcr, DEVICE *dev);
+void     free_dcr(DCR *dcr);
 
 /* From askdir.c */
 enum get_vol_info_rw {
    GET_VOL_INFO_FOR_WRITE,
    GET_VOL_INFO_FOR_READ
 };
-bool   dir_get_volume_info(DCR *dcr, enum get_vol_info_rw);
-bool   dir_find_next_appendable_volume(DCR *dcr);
-bool   dir_update_volume_info(DCR *dcr, bool label);
-bool   dir_ask_sysop_to_create_appendable_volume(DCR *dcr);
-bool   dir_ask_sysop_to_mount_volume(DCR *dcr);
-bool   dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec);
-bool   dir_send_job_status(JCR *jcr);
-bool   dir_create_jobmedia_record(DCR *dcr);
+bool    dir_get_volume_info(DCR *dcr, enum get_vol_info_rw);
+bool    dir_find_next_appendable_volume(DCR *dcr);
+bool    dir_update_volume_info(DCR *dcr, bool label);
+bool    dir_ask_sysop_to_create_appendable_volume(DCR *dcr);
+bool    dir_ask_sysop_to_mount_volume(DCR *dcr);
+bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec);
+bool    dir_send_job_status(JCR *jcr);
+bool    dir_create_jobmedia_record(DCR *dcr);
 
 /* authenticate.c */
-int    authenticate_director(JCR *jcr);
-int    authenticate_filed(JCR *jcr);
+int     authenticate_director(JCR *jcr);
+int     authenticate_filed(JCR *jcr);
 
 /* From block.c */
-void   dump_block(DEV_BLOCK *b, const char *msg);
+void    dump_block(DEV_BLOCK *b, const char *msg);
 DEV_BLOCK *new_block(DEVICE *dev);
 DEV_BLOCK *dup_block(DEV_BLOCK *eblock);
-void   init_block_write(DEV_BLOCK *block);
-void   empty_block(DEV_BLOCK *block);
-void   free_block(DEV_BLOCK *block);
-bool   write_block_to_device(DCR *dcr, DEV_BLOCK *block);
-bool   write_block_to_dev(DCR *dcr, DEV_BLOCK *block);
-void   print_block_read_errors(JCR *jcr, DEV_BLOCK *block);
-void   ser_block_header(DEV_BLOCK *block);
+void    init_block_write(DEV_BLOCK *block);
+void    empty_block(DEV_BLOCK *block);
+void    free_block(DEV_BLOCK *block);
+bool    write_block_to_device(DCR *dcr, DEV_BLOCK *block);
+bool    write_block_to_dev(DCR *dcr, DEV_BLOCK *block);
+void    print_block_read_errors(JCR *jcr, DEV_BLOCK *block);
+void    ser_block_header(DEV_BLOCK *block);
 
 #define CHECK_BLOCK_NUMBERS    true
 #define NO_BLOCK_NUMBER_CHECK  false
-bool   read_block_from_device(DCR *dcr, DEV_BLOCK *block, bool check_block_numbers);
-bool   read_block_from_dev(DCR *dcr, DEV_BLOCK *block, bool check_block_numbers);
+bool    read_block_from_device(DCR *dcr, DEV_BLOCK *block, bool check_block_numbers);
+bool    read_block_from_dev(DCR *dcr, DEV_BLOCK *block, bool check_block_numbers);
 
 /* From butil.c -- utilities for SD tool programs */
-void   print_ls_output(const char *fname, const char *link, int type, struct stat *statp);
+void    print_ls_output(const char *fname, const char *link, int type, struct stat *statp);
 JCR    *setup_jcr(const char *name, const char * device, BSR *bsr, const char *VolumeName);
 DEVICE *setup_to_access_device(JCR *jcr, int read_access);
-void   display_tape_error_status(JCR *jcr, DEVICE *dev);
+void    display_tape_error_status(JCR *jcr, DEVICE *dev);
 DEVRES *find_device_res(char *device_name, int read_access);
 
 
 /* From dev.c */
-DEVICE *init_dev(DEVICE *dev, DEVRES *device);
-int     open_dev(DEVICE *dev, char *VolName, int mode);
-void    close_dev(DEVICE *dev);
-void    force_close_dev(DEVICE *dev);
-bool    truncate_dev(DEVICE *dev);
-void    term_dev(DEVICE *dev);
-char *  strerror_dev(DEVICE *dev);
-void    clrerror_dev(DEVICE *dev, int func);
-bool    update_pos_dev(DEVICE *dev);
-int     rewind_dev(DEVICE *dev);
-bool    load_dev(DEVICE *dev);
-bool    offline_dev(DEVICE *dev);
-int     flush_dev(DEVICE *dev);
-int     weof_dev(DEVICE *dev, int num);
-int     write_block(DEVICE *dev);
-int     write_dev(DEVICE *dev, char *buf, size_t len);
-int     read_dev(DEVICE *dev, char *buf, size_t len);
+DEVICE  *init_dev(DEVICE *dev, DEVRES *device);
+int      open_dev(DEVICE *dev, char *VolName, int mode);
+void     close_dev(DEVICE *dev);
+void     force_close_dev(DEVICE *dev);
+bool     truncate_dev(DEVICE *dev);
+void     term_dev(DEVICE *dev);
+char *   strerror_dev(DEVICE *dev);
+void     clrerror_dev(DEVICE *dev, int func);
+bool     update_pos_dev(DEVICE *dev);
+int      rewind_dev(DEVICE *dev);
+bool     load_dev(DEVICE *dev);
+bool     offline_dev(DEVICE *dev);
+int      flush_dev(DEVICE *dev);
+int      weof_dev(DEVICE *dev, int num);
+int      write_block(DEVICE *dev);
+int      write_dev(DEVICE *dev, char *buf, size_t len);
+int      read_dev(DEVICE *dev, char *buf, size_t len);
 uint32_t status_dev(DEVICE *dev);
-int     eod_dev(DEVICE *dev);
-bool    fsf_dev(DEVICE *dev, int num);
-bool    fsr_dev(DEVICE *dev, int num);
-bool    bsf_dev(DEVICE *dev, int num);
-bool    bsr_dev(DEVICE *dev, int num);
-void    attach_jcr_to_device(DEVICE *dev, JCR *jcr);
-void    detach_jcr_from_device(DEVICE *dev, JCR *jcr);
-JCR    *next_attached_jcr(DEVICE *dev, JCR *jcr);
-bool    dev_can_write(DEVICE *dev);
-int     offline_or_rewind_dev(DEVICE *dev);
-bool    reposition_dev(DEVICE *dev, uint32_t file, uint32_t block);
-void    init_dev_wait_timers(DEVICE *dev);
-bool    double_dev_wait_time(DEVICE *dev);
+int      eod_dev(DEVICE *dev);
+bool     fsf_dev(DEVICE *dev, int num);
+bool     fsr_dev(DEVICE *dev, int num);
+bool     bsf_dev(DEVICE *dev, int num);
+bool     bsr_dev(DEVICE *dev, int num);
+void     attach_jcr_to_device(DEVICE *dev, JCR *jcr);
+void     detach_jcr_from_device(DEVICE *dev, JCR *jcr);
+JCR     *next_attached_jcr(DEVICE *dev, JCR *jcr);
+bool     dev_can_write(DEVICE *dev);
+int      offline_or_rewind_dev(DEVICE *dev);
+bool     reposition_dev(DEVICE *dev, uint32_t file, uint32_t block);
+void     init_dev_wait_timers(DEVICE *dev);
+bool     double_dev_wait_time(DEVICE *dev);
 
 
 /* Get info about device */
-char *  dev_name(DEVICE *dev);
-char *  dev_vol_name(DEVICE *dev);
+char *   dev_name(DEVICE *dev);
+char *   dev_vol_name(DEVICE *dev);
 uint32_t dev_block(DEVICE *dev);
 uint32_t dev_file(DEVICE *dev);
-bool    dev_is_tape(DEVICE *dev);
+bool     dev_is_tape(DEVICE *dev);
 
 /* From device.c */
-int     open_device(JCR *jcr, DEVICE *dev);
-int     first_open_device(DEVICE *dev);
-bool    fixup_device_block_write_error(DCR *dcr, DEV_BLOCK *block);
-void    _lock_device(const char *file, int line, DEVICE *dev);
-void    _unlock_device(const char *file, int line, DEVICE *dev);
-void    _block_device(const char *file, int line, DEVICE *dev, int state);
-void    _unblock_device(const char *file, int line, DEVICE *dev);
-void    _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state);
-void    _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold);
-void    set_new_volume_parameters(DCR *dcr);
-void    set_new_file_parameters(DCR *dcr);
-int     device_is_unmounted(DEVICE *dev);
-void    dev_lock(DEVICE *dev);
-void    dev_unlock(DEVICE *dev);
+int      open_device(JCR *jcr, DEVICE *dev);
+int      first_open_device(DEVICE *dev);
+bool     fixup_device_block_write_error(DCR *dcr, DEV_BLOCK *block);
+void     _lock_device(const char *file, int line, DEVICE *dev);
+void     _unlock_device(const char *file, int line, DEVICE *dev);
+void     _block_device(const char *file, int line, DEVICE *dev, int state);
+void     _unblock_device(const char *file, int line, DEVICE *dev);
+void     _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state);
+void     _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold);
+void     set_new_volume_parameters(DCR *dcr);
+void     set_new_file_parameters(DCR *dcr);
+bool     device_is_unmounted(DEVICE *dev);
+void     dev_lock(DEVICE *dev);
+void     dev_unlock(DEVICE *dev);
+const char *edit_blocked_reason(DEVICE *dev);
 
 /* From dircmd.c */
-void    *handle_connection_request(void *arg); 
+void     *handle_connection_request(void *arg); 
 
 
 /* From fd_cmds.c */
-void    run_job(JCR *jcr);
+void     run_job(JCR *jcr);
 
 /* From job.c */
-void    stored_free_jcr(JCR *jcr);
-void    connection_from_filed(void *arg);     
-void    handle_filed_connection(BSOCK *fd, char *job_name);
+void     stored_free_jcr(JCR *jcr);
+void     connection_from_filed(void *arg);     
+void     handle_filed_connection(BSOCK *fd, char *job_name);
 
 /* From label.c */
-int     read_dev_volume_label(DCR *dcr, DEV_BLOCK *block);
-void    create_session_label(DCR *dcr, DEV_RECORD *rec, int label);
-void    create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName);
-bool    write_new_volume_label_to_dev(DCR *dcr, const char *VolName, const char *PoolName);
-bool    write_session_label(DCR *dcr, DEV_BLOCK *block, int label);
-bool    write_volume_label_to_block(DCR *dcr, DEV_BLOCK *block);
-void    dump_volume_label(DEVICE *dev);
-void    dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose);
-bool    unser_volume_label(DEVICE *dev, DEV_RECORD *rec);
-bool    unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec);
+int      read_dev_volume_label(DCR *dcr, DEV_BLOCK *block);
+void     create_session_label(DCR *dcr, DEV_RECORD *rec, int label);
+void     create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName);
+bool     write_new_volume_label_to_dev(DCR *dcr, const char *VolName, const char *PoolName);
+bool     write_session_label(DCR *dcr, DEV_BLOCK *block, int label);
+bool     write_volume_label_to_block(DCR *dcr, DEV_BLOCK *block);
+void     dump_volume_label(DEVICE *dev);
+void     dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose);
+bool     unser_volume_label(DEVICE *dev, DEV_RECORD *rec);
+bool     unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec);
 
 /* From match_bsr.c */
-int     match_bsr(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec, 
-             SESSION_LABEL *sesrec);
-int     match_bsr_block(BSR *bsr, DEV_BLOCK *block);
-void    position_bsr_block(BSR *bsr, DEV_BLOCK *block);
-BSR    *find_next_bsr(BSR *root_bsr, DEVICE *dev);
-bool    match_set_eof(BSR *bsr, DEV_RECORD *rec);
+int      match_bsr(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec, 
+              SESSION_LABEL *sesrec);
+int      match_bsr_block(BSR *bsr, DEV_BLOCK *block);
+void     position_bsr_block(BSR *bsr, DEV_BLOCK *block);
+BSR     *find_next_bsr(BSR *root_bsr, DEVICE *dev);
+bool     match_set_eof(BSR *bsr, DEV_RECORD *rec);
 
 /* From mount.c */
-bool    mount_next_write_volume(DCR *dcr, DEV_BLOCK *block, bool release);
-bool    mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-void    release_volume(JCR *jcr, DEVICE *dev);
-void    mark_volume_in_error(JCR *jcr, DEVICE *dev);
+bool     mount_next_write_volume(DCR *dcr, DEV_BLOCK *block, bool release);
+bool     mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+void     release_volume(JCR *jcr, DEVICE *dev);
+void     mark_volume_in_error(JCR *jcr, DEVICE *dev);
 
 /* From autochanger.c */
-int     autoload_device(DCR *dcr, int writing, BSOCK *dir);
-bool    autochanger_list(DCR *dcr, BSOCK *dir);
-void    invalidate_slot_in_catalog(DCR *dcr);
-char   *edit_device_codes(JCR *jcr, char *omsg, const char *imsg, const char *cmd);
+int      autoload_device(DCR *dcr, int writing, BSOCK *dir);
+bool     autochanger_list(DCR *dcr, BSOCK *dir);
+void     invalidate_slot_in_catalog(DCR *dcr);
+char    *edit_device_codes(JCR *jcr, char *omsg, const char *imsg, const char *cmd);
 
 
 /* From parse_bsr.c */
-BSR    *parse_bsr(JCR *jcr, char *lf);
-void    dump_bsr(BSR *bsr, bool recurse);
-void    free_bsr(BSR *bsr);
+BSR     *parse_bsr(JCR *jcr, char *lf);
+void     dump_bsr(BSR *bsr, bool recurse);
+void     free_bsr(BSR *bsr);
 VOL_LIST *new_vol();
-int     add_vol(JCR *jcr, VOL_LIST *vol);
-void    free_vol_list(JCR *jcr);
-void    create_vol_list(JCR *jcr);
+int      add_vol(JCR *jcr, VOL_LIST *vol);
+void     free_vol_list(JCR *jcr);
+void     create_vol_list(JCR *jcr);
 
 /* From record.c */
 const char *FI_to_ascii(int fi);
 const char *stream_to_ascii(int stream, int fi);
-int     write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
-int     can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
-int     read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec); 
+int      write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
+int      can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
+int      read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec); 
 DEV_RECORD *new_record();
-void    free_record(DEV_RECORD *rec);
+void     free_record(DEV_RECORD *rec);
 
 /* From read_record.c */
 bool read_records(DCR *dcr,
@@ -203,12 +204,12 @@ bool read_records(DCR *dcr,
        bool mount_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block));
 
 /* From spool.c */
-bool   begin_data_spool          (JCR *jcr);
-bool   discard_data_spool        (JCR *jcr);
-bool   commit_data_spool         (JCR *jcr);
-bool   are_attributes_spooled    (JCR *jcr);
-bool   begin_attribute_spool     (JCR *jcr);
-bool   discard_attribute_spool   (JCR *jcr);
-bool   commit_attribute_spool    (JCR *jcr);
-bool   write_block_to_spool_file (DCR *dcr, DEV_BLOCK *block);
-void   list_spool_stats          (BSOCK *bs);
+bool    begin_data_spool          (JCR *jcr);
+bool    discard_data_spool        (JCR *jcr);
+bool    commit_data_spool         (JCR *jcr);
+bool    are_attributes_spooled    (JCR *jcr);
+bool    begin_attribute_spool     (JCR *jcr);
+bool    discard_attribute_spool   (JCR *jcr);
+bool    commit_attribute_spool    (JCR *jcr);
+bool    write_block_to_spool_file (DCR *dcr, DEV_BLOCK *block);
+void    list_spool_stats          (BSOCK *bs);

diff --git a/bacula/src/stored/spool.c b/bacula/src/stored/spool.c
index b10360febfd4429988547855ede41d77527f451d..5af270180ba6a58cbc9e1f91f9a2412a74e3637a 100644 (file)
--- a/bacula/src/stored/spool.c
+++ b/bacula/src/stored/spool.c
@@ -119,7 +119,7 @@ bool commit_data_spool(JCR *jcr)
       Dmsg0(100, "Committing spooled data\n");
       stat = despool_data(jcr->dcr, true /*commit*/);
       if (!stat) {
-         Dmsg1(000, "Bad return from despool WroteVol=%d\n", jcr->dcr->WroteVol);
+         Pmsg1(000, "Bad return from despool WroteVol=%d\n", jcr->dcr->WroteVol);
         close_data_spool_file(jcr);
         return false;
       }
@@ -249,7 +249,7 @@ static bool despool_data(DCR *dcr, bool commit)
       berrno be;
       Jmsg(dcr->jcr, M_FATAL, 0, _("Ftruncate spool file failed: ERR=%s\n"), 
         be.strerror());
-      Dmsg1(000, "Bad return from ftruncate. ERR=%s\n", be.strerror());
+      Pmsg1(000, "Bad return from ftruncate. ERR=%s\n", be.strerror());
       ok = false;
    }
 
@@ -300,20 +300,20 @@ static int read_block_from_spool_file(DCR *dcr, DEV_BLOCK *block)
          Jmsg(dcr->jcr, M_FATAL, 0, _("Spool header read error. ERR=%s\n"), 
              be.strerror());
       } else {
-         Dmsg2(000, "Spool read error. Wanted %u bytes, got %u\n", rlen, stat);
+         Pmsg2(000, "Spool read error. Wanted %u bytes, got %u\n", rlen, stat);
          Jmsg2(dcr->jcr, M_FATAL, 0, _("Spool header read error. Wanted %u bytes, got %u\n"), rlen, stat);
       }
       return RB_ERROR;
    }
    rlen = hdr.len;
    if (rlen > block->buf_len) {
-      Dmsg2(000, "Spool block too big. Max %u bytes, got %u\n", block->buf_len, rlen);
+      Pmsg2(000, "Spool block too big. Max %u bytes, got %u\n", block->buf_len, rlen);
       Jmsg2(dcr->jcr, M_FATAL, 0, _("Spool block too big. Max %u bytes, got %u\n"), block->buf_len, rlen);
       return RB_ERROR;
    }
    stat = read(dcr->spool_fd, (char *)block->buf, (size_t)rlen);
    if (stat != (ssize_t)rlen) {
-      Dmsg2(000, "Spool data read error. Wanted %u bytes, got %u\n", rlen, stat);
+      Pmsg2(000, "Spool data read error. Wanted %u bytes, got %u\n", rlen, stat);
       Jmsg2(dcr->jcr, M_FATAL, 0, _("Spool data read error. Wanted %u bytes, got %u\n"), rlen, stat);
       return RB_ERROR;
    }
@@ -372,7 +372,7 @@ bool write_block_to_spool_file(DCR *dcr, DEV_BLOCK *block)
 #endif
       Jmsg(dcr->jcr, M_INFO, 0, _("User specified spool size reached.\n"));
       if (!despool_data(dcr, false)) {
-         Dmsg0(000, "Bad return from despool in write_block.\n");
+         Pmsg0(000, "Bad return from despool in write_block.\n");
         return false;
       }
       /* Despooling cleared these variables so reset them */