git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/wait.c

   1 /*
   2  *  Subroutines to handle waiting for operator intervention
   3  *   or waiting for a Device to be released
   4  *
   5  *  Code for wait_for_sysop() pulled from askdir.c
   6  *
   7  *   Kern Sibbald, March 2005
   8  *
   9  *   Version $Id$
  10  */
  11 /*
  12    Bacula® - The Network Backup Solution
  13
  14    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
  15
  16    The main author of Bacula is Kern Sibbald, with contributions from
  17    many others, a complete list can be found in the file AUTHORS.
  18    This program is Free Software; you can redistribute it and/or
  19    modify it under the terms of version two of the GNU General Public
  20    License as published by the Free Software Foundation plus additions
  21    that are listed in the file LICENSE.
  22
  23    This program is distributed in the hope that it will be useful, but
  24    WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  26    General Public License for more details.
  27
  28    You should have received a copy of the GNU General Public License
  29    along with this program; if not, write to the Free Software
  30    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  31    02110-1301, USA.
  32
  33    Bacula® is a registered trademark of John Walker.
  34    The licensor of Bacula is the Free Software Foundation Europe
  35    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  36    Switzerland, email:ftf@fsfeurope.org.
  37 */
  38
  39
  40 #include "bacula.h"                   /* pull in global headers */
  41 #include "stored.h"                   /* pull in Storage Deamon headers */
  42
  43 //static bool double_jcr_wait_time(JCR *jcr);
  44
  45
  46 /*
  47  * Wait for SysOp to mount a tape on a specific device
  48  *
  49  *   Returns: W_ERROR, W_TIMEOUT, W_POLL, W_MOUNT, or W_WAKE
  50  */
  51 int wait_for_sysop(DCR *dcr)
  52 {
  53    struct timeval tv;
  54    struct timezone tz;
  55    struct timespec timeout;
  56    time_t last_heartbeat = 0;
  57    time_t first_start = time(NULL);
  58    int stat = 0;
  59    int add_wait;
  60    bool unmounted;
  61    DEVICE *dev = dcr->dev;
  62    JCR *jcr = dcr->jcr;
  63
  64    P(dev->mutex);
  65    Dmsg1(100, "Enter blocked=%s\n", dev->print_blocked());
  66    unmounted = is_device_unmounted(dev);
  67
  68    dev->poll = false;
  69    /*
  70     * Wait requested time (dev->rem_wait_sec).  However, we also wake up every
  71     *    HB_TIME seconds and send a heartbeat to the FD and the Director
  72     *    to keep stateful firewalls from closing them down while waiting
  73     *    for the operator.
  74     */
  75    add_wait = dev->rem_wait_sec;
  76    if (me->heartbeat_interval && add_wait > me->heartbeat_interval) {
  77       add_wait = me->heartbeat_interval;
  78    }
  79    /* If the user did not unmount the tape and we are polling, ensure
  80     *  that we poll at the correct interval.
  81     */
  82    if (!unmounted && dev->vol_poll_interval && add_wait > dev->vol_poll_interval) {
  83       add_wait = dev->vol_poll_interval;
  84    }
  85
  86    if (!unmounted) {
  87       Dmsg1(400, "blocked=%s\n", dev->print_blocked());
  88       dev->dev_prev_blocked = dev->dev_blocked;
  89       dev->set_blocked(BST_WAITING_FOR_SYSOP); /* indicate waiting for mount */
  90    }
  91
  92    for ( ; !job_canceled(jcr); ) {
  93       time_t now, start;
  94
  95       gettimeofday(&tv, &tz);
  96       timeout.tv_nsec = tv.tv_usec * 1000;
  97       timeout.tv_sec = tv.tv_sec + add_wait;
  98
  99       Dmsg4(400, "I'm going to sleep on device %s. HB=%d wait=%d add_wait=%d\n",
 100          dev->print_name(), (int)me->heartbeat_interval, dev->wait_sec, add_wait);
 101       start = time(NULL);
 102       /* Wait required time */
 103       stat = pthread_cond_timedwait(&dev->wait_next_vol, &dev->mutex, &timeout);
 104       Dmsg2(400, "Wokeup from sleep on device stat=%d blocked=%s\n", stat,
 105          dev->print_blocked());
 106
 107       now = time(NULL);
 108       dev->rem_wait_sec -= (now - start);
 109
 110       /* Note, this always triggers the first time. We want that. */
 111       if (me->heartbeat_interval) {
 112          if (now - last_heartbeat >= me->heartbeat_interval) {
 113             /* send heartbeats */
 114             if (jcr->file_bsock) {
 115                bnet_sig(jcr->file_bsock, BNET_HEARTBEAT);
 116                Dmsg0(400, "Send heartbeat to FD.\n");
 117             }
 118             if (jcr->dir_bsock) {
 119                bnet_sig(jcr->dir_bsock, BNET_HEARTBEAT);
 120             }
 121             last_heartbeat = now;
 122          }
 123       }
 124
 125       if (stat == EINVAL) {
 126          berrno be;
 127          Dmsg1(000, "pthread stat=%d\n", stat);
 128          Jmsg1(jcr, M_FATAL, 0, _("pthread timedwait error. ERR=%s\n"), be.strerror(stat));
 129          stat = W_ERROR;               /* error */
 130          break;
 131       }
 132
 133
 134       if (dev->rem_wait_sec <= 0) {  /* on exceeding wait time return */
 135          Dmsg0(400, "Exceed wait time.\n");
 136          stat = W_TIMEOUT;
 137          break;
 138       }
 139
 140       /*
 141        * Check if user unmounted the device while we were waiting
 142        */
 143       unmounted = is_device_unmounted(dev);
 144
 145       if (!unmounted && dev->vol_poll_interval &&
 146           (now - first_start >= dev->vol_poll_interval)) {
 147          Dmsg1(400, "In wait blocked=%s\n", dev->print_blocked());
 148          dev->poll = true;            /* returning a poll event */
 149          stat = W_POLL;
 150          break;
 151       }
 152       /*
 153        * Check if user mounted the device while we were waiting
 154        */
 155       if (dev->get_blocked() == BST_MOUNT) {   /* mount request ? */
 156          stat = W_MOUNT;
 157          break;
 158       }
 159
 160       /*
 161        * If we did not timeout, then some event happened, so
 162        *   return to check if state changed.
 163        */
 164       if (stat != 0) {
 165          stat = W_WAKE;          /* someone woke us */
 166          break;
 167       }
 168
 169       /*
 170        * At this point, we know we woke up because of a timeout,
 171        *   that was due to a heartbeat, so we just update
 172        *   the wait counters and continue.
 173        */
 174       add_wait = dev->wait_sec - (now - start);
 175       if (add_wait < 0) {
 176          add_wait = 0;
 177       }
 178       if (me->heartbeat_interval && add_wait > me->heartbeat_interval) {
 179          add_wait = me->heartbeat_interval;
 180       }
 181    }
 182
 183    if (!unmounted) {
 184       dev->set_blocked(dev->dev_prev_blocked);    /* restore entry state */
 185       Dmsg1(400, "set %s\n", dev->print_blocked());
 186    }
 187    Dmsg1(400, "Exit blocked=%s\n", dev->print_blocked());
 188    V(dev->mutex);
 189    return stat;
 190 }
 191
 192
 193 /*
 194  * Wait for any device to be released, then we return, so
 195  *  higher level code can rescan possible devices.
 196  *
 197  * Returns: true  if a device has changed state
 198  *          false if the total wait time has expired.
 199  */
 200 bool wait_for_device(JCR *jcr, bool first)
 201 {
 202    struct timeval tv;
 203    struct timezone tz;
 204    struct timespec timeout;
 205    int stat = 0;
 206    bool ok = true;
 207    const int wait_time = 5 * 60;       /* wait 5 minutes */
 208
 209    Dmsg0(100, "Enter wait_for_device\n");
 210    P(device_release_mutex);
 211
 212    if (first) {
 213       Jmsg(jcr, M_MOUNT, 0, _("Job %s waiting to reserve a device.\n"), jcr->Job);
 214    }
 215
 216    gettimeofday(&tv, &tz);
 217    timeout.tv_nsec = tv.tv_usec * 1000;
 218    timeout.tv_sec = tv.tv_sec + wait_time;
 219
 220    Dmsg0(100, "I'm going to wait for a device.\n");
 221
 222    /* Wait required time */
 223    stat = pthread_cond_timedwait(&wait_device_release, &device_release_mutex, &timeout);
 224    Dmsg1(100, "Wokeup from sleep on device stat=%d\n", stat);
 225
 226
 227    V(device_release_mutex);
 228    Dmsg1(100, "Return from wait_device ok=%d\n", ok);
 229    return ok;
 230 }
 231
 232 #ifdef xxx
 233 /*
 234  * The jcr timers are used for waiting on any device *
 235  * Returns: true if time doubled
 236  *          false if max time expired
 237  */
 238 static bool double_jcr_wait_time(JCR *jcr)
 239 {
 240    jcr->wait_sec *= 2;               /* double wait time */
 241    if (jcr->wait_sec > jcr->max_wait) {   /* but not longer than maxtime */
 242       jcr->wait_sec = jcr->max_wait;
 243    }
 244    jcr->num_wait++;
 245    jcr->rem_wait_sec = jcr->wait_sec;
 246    if (jcr->num_wait >= jcr->max_num_wait) {
 247       return false;
 248    }
 249    return true;
 250 }
 251 #endif