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

   1 /*
   2  *
   3  *  Higher Level Device routines.
   4  *  Knows about Bacula tape labels and such
   5  *
   6  *  NOTE! In general, subroutines that have the word
   7  *        "device" in the name do locking.  Subroutines
   8  *        that have the word "dev" in the name do not
   9  *        do locking.  Thus if xxx_device() calls
  10  *        yyy_dev(), all is OK, but if xxx_device()
  11  *        calls yyy_device(), everything will hang.
  12  *        Obviously, no zzz_dev() is allowed to call
  13  *        a www_device() or everything falls apart.
  14  *
  15  * Concerning the routines lock_device() and block_device()
  16  *  see the end of this module for details.  In general,
  17  *  blocking a device leaves it in a state where all threads
  18  *  other than the current thread block when they attempt to
  19  *  lock the device. They remain suspended (blocked) until the device
  20  *  is unblocked. So, a device is blocked during an operation
  21  *  that takes a long time (initialization, mounting a new
  22  *  volume, ...) locking a device is done for an operation
  23  *  that takes a short time such as writing data to the
  24  *  device.
  25  *
  26  *
  27  *   Kern Sibbald, MM, MMI
  28  *
  29  *   Version $Id$
  30  */
  31 /*
  32    Bacula® - The Network Backup Solution
  33
  34    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
  35
  36    The main author of Bacula is Kern Sibbald, with contributions from
  37    many others, a complete list can be found in the file AUTHORS.
  38    This program is Free Software; you can redistribute it and/or
  39    modify it under the terms of version two of the GNU General Public
  40    License as published by the Free Software Foundation plus additions
  41    that are listed in the file LICENSE.
  42
  43    This program is distributed in the hope that it will be useful, but
  44    WITHOUT ANY WARRANTY; without even the implied warranty of
  45    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  46    General Public License for more details.
  47
  48    You should have received a copy of the GNU General Public License
  49    along with this program; if not, write to the Free Software
  50    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  51    02110-1301, USA.
  52
  53    Bacula® is a registered trademark of John Walker.
  54    The licensor of Bacula is the Free Software Foundation Europe
  55    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  56    Switzerland, email:ftf@fsfeurope.org.
  57 */
  58
  59 #include "bacula.h"                   /* pull in global headers */
  60 #include "stored.h"                   /* pull in Storage Deamon headers */
  61
  62 /* Forward referenced functions */
  63
  64 /*
  65  * This is the dreaded moment. We either have an end of
  66  * medium condition or worse, and error condition.
  67  * Attempt to "recover" by obtaining a new Volume.
  68  *
  69  * Here are a few things to know:
  70  *  dcr->VolCatInfo contains the info on the "current" tape for this job.
  71  *  dev->VolCatInfo contains the info on the tape in the drive.
  72  *    The tape in the drive could have changed several times since
  73  *    the last time the job used it (jcr->VolCatInfo).
  74  *  dcr->VolumeName is the name of the current/desired tape in the drive.
  75  *
  76  * We enter with device locked, and
  77  *     exit with device locked.
  78  *
  79  * Note, we are called only from one place in block.c for the daemons.
  80  *     The btape utility calls it from btape.c.
  81  *
  82  *  Returns: true  on success
  83  *           false on failure
  84  */
  85 bool fixup_device_block_write_error(DCR *dcr)
  86 {
  87    char PrevVolName[MAX_NAME_LENGTH];
  88    DEV_BLOCK *label_blk;
  89    DEV_BLOCK *block = dcr->block;
  90    char b1[30], b2[30];
  91    time_t wait_time;
  92    char dt[MAX_TIME_LENGTH];
  93    JCR *jcr = dcr->jcr;
  94    DEVICE *dev = dcr->dev;
  95
  96    wait_time = time(NULL);
  97
  98    Dmsg0(100, "Enter fixup_device_block_write_error\n");
  99
 100    block_device(dev, BST_DOING_ACQUIRE);
 101    /* Unlock, but leave BLOCKED */
 102    unlock_device(dev);
 103
 104    bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName));
 105    bstrncpy(dev->VolHdr.PrevVolumeName, PrevVolName, sizeof(dev->VolHdr.PrevVolumeName));
 106
 107    label_blk = new_block(dev);
 108    dcr->block = label_blk;
 109
 110    /* Inform User about end of medium */
 111    Jmsg(jcr, M_INFO, 0, _("End of medium on Volume \"%s\" Bytes=%s Blocks=%s at %s.\n"),
 112         PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
 113         edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
 114         bstrftime(dt, sizeof(dt), time(NULL)));
 115
 116    if (!mount_next_write_volume(dcr, 1)) {
 117       free_block(label_blk);
 118       dcr->block = block;
 119       P(dev->mutex);
 120       unblock_device(dev);
 121       return false;                /* device locked */
 122    }
 123    P(dev->mutex);                  /* lock again */
 124
 125    Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
 126       dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
 127
 128    /*
 129     * If this is a new tape, the label_blk will contain the
 130     *  label, so write it now. If this is a previously
 131     *  used tape, mount_next_write_volume() will return an
 132     *  empty label_blk, and nothing will be written.
 133     */
 134    Dmsg0(190, "write label block to dev\n");
 135    if (!write_block_to_dev(dcr)) {
 136       berrno be;
 137       Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
 138         be.strerror(dev->dev_errno));
 139       free_block(label_blk);
 140       dcr->block = block;
 141       unblock_device(dev);
 142       return false;                /* device locked */
 143    }
 144    free_block(label_blk);
 145    dcr->block = block;
 146
 147    /*
 148     * Walk through all attached jcrs indicating the volume has changed
 149     */
 150    Dmsg1(100, "Walk attached dcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
 151    DCR *mdcr;
 152    foreach_dlist(mdcr, dev->attached_dcrs) {
 153       JCR *mjcr = mdcr->jcr;
 154       if (mjcr->JobId == 0) {
 155          continue;                 /* ignore console */
 156       }
 157       mdcr->NewVol = true;
 158       if (jcr != mjcr) {
 159          bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName));
 160       }
 161    }
 162
 163    /* Clear NewVol now because dir_get_volume_info() already done */
 164    jcr->dcr->NewVol = false;
 165    set_new_volume_parameters(dcr);
 166
 167    jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
 168
 169    /* Write overflow block to device */
 170    Dmsg0(190, "Write overflow block to dev\n");
 171    if (!write_block_to_dev(dcr)) {
 172       berrno be;
 173       Pmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
 174         be.strerror(dev->dev_errno));
 175       unblock_device(dev);
 176       return false;                /* device locked */
 177    }
 178
 179    unblock_device(dev);
 180    return true;                             /* device locked */
 181 }
 182
 183 /*
 184  * We have a new Volume mounted, so reset the Volume parameters
 185  *  concerning this job.  The global changes were made earlier
 186  *  in the dev structure.
 187  */
 188 void set_new_volume_parameters(DCR *dcr)
 189 {
 190    JCR *jcr = dcr->jcr;
 191    DEVICE *dev = dcr->dev;
 192    if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
 193       Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
 194    }
 195    /* Set new start/end positions */
 196    if (dev->is_tape()) {
 197       dcr->StartBlock = dev->block_num;
 198       dcr->StartFile = dev->file;
 199    } else {
 200       dcr->StartBlock = (uint32_t)dev->file_addr;
 201       dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
 202    }
 203    /* Reset indicies */
 204    dcr->VolFirstIndex = 0;
 205    dcr->VolLastIndex = 0;
 206    jcr->NumWriteVolumes++;
 207    dcr->NewVol = false;
 208    dcr->WroteVol = false;
 209 }
 210
 211 /*
 212  * We are now in a new Volume file, so reset the Volume parameters
 213  *  concerning this job.  The global changes were made earlier
 214  *  in the dev structure.
 215  */
 216 void set_new_file_parameters(DCR *dcr)
 217 {
 218    DEVICE *dev = dcr->dev;
 219
 220    /* Set new start/end positions */
 221    if (dev->is_tape()) {
 222       dcr->StartBlock = dev->block_num;
 223       dcr->StartFile = dev->file;
 224    } else {
 225       dcr->StartBlock = (uint32_t)dev->file_addr;
 226       dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
 227    }
 228    /* Reset indicies */
 229    dcr->VolFirstIndex = 0;
 230    dcr->VolLastIndex = 0;
 231    dcr->NewFile = false;
 232    dcr->WroteVol = false;
 233 }
 234
 235
 236
 237 /*
 238  *   First Open of the device. Expect dev to already be initialized.
 239  *
 240  *   This routine is used only when the Storage daemon starts
 241  *   and always_open is set, and in the stand-alone utility
 242  *   routines such as bextract.
 243  *
 244  *   Note, opening of a normal file is deferred to later so
 245  *    that we can get the filename; the device_name for
 246  *    a file is the directory only.
 247  *
 248  *   Returns: false on failure
 249  *            true  on success
 250  */
 251 bool first_open_device(DCR *dcr)
 252 {
 253    DEVICE *dev = dcr->dev;
 254    bool ok = true;
 255
 256    Dmsg0(120, "start open_output_device()\n");
 257    if (!dev) {
 258       return false;
 259    }
 260
 261    lock_device(dev);
 262
 263    /* Defer opening files */
 264    if (!dev->is_tape()) {
 265       Dmsg0(129, "Device is file, deferring open.\n");
 266       goto bail_out;
 267    }
 268
 269     int mode;
 270     if (dev->has_cap(CAP_STREAM)) {
 271        mode = OPEN_WRITE_ONLY;
 272     } else {
 273        mode = OPEN_READ_ONLY;
 274     }
 275    Dmsg0(129, "Opening device.\n");
 276    if (dev->open(dcr, mode) < 0) {
 277       Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
 278       ok = false;
 279       goto bail_out;
 280    }
 281    Dmsg1(129, "open dev %s OK\n", dev->print_name());
 282
 283 bail_out:
 284    unlock_device(dev);
 285    return ok;
 286 }
 287
 288 /*
 289  * Make sure device is open, if not do so
 290  */
 291 bool open_device(DCR *dcr)
 292 {
 293    DEVICE *dev = dcr->dev;
 294    /* Open device */
 295    int mode;
 296    if (dev->has_cap(CAP_STREAM)) {
 297       mode = OPEN_WRITE_ONLY;
 298    } else {
 299       mode = OPEN_READ_WRITE;
 300    }
 301    if (dev->open(dcr, mode) < 0) {
 302       /* If polling, ignore the error */
 303       /* If DVD, also ignore the error, very often you cannot open the device
 304        * (when there is no DVD, or when the one inserted is a wrong one) */
 305       if (!dev->poll && !dev->is_dvd() && !dev->is_removable()) {
 306          Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
 307             dev->print_name(), dev->bstrerror());
 308          Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"),
 309             dev->print_name(), dev->bstrerror());
 310       }
 311       return false;
 312    }
 313    return true;
 314 }
 315
 316
 317
 318 void dev_lock(DEVICE *dev)
 319 {
 320    int errstat;
 321    if ((errstat=rwl_writelock(&dev->lock))) {
 322       Emsg1(M_ABORT, 0, _("Device write lock failure. ERR=%s\n"), strerror(errstat));
 323    }
 324 }
 325
 326 void dev_unlock(DEVICE *dev)
 327 {
 328    int errstat;
 329    if ((errstat=rwl_writeunlock(&dev->lock))) {
 330       Emsg1(M_ABORT, 0, _("Device write unlock failure. ERR=%s\n"), strerror(errstat));
 331    }
 332 }
 333
 334 /*
 335  * When dev_blocked is set, all threads EXCEPT thread with id no_wait_id
 336  * must wait. The no_wait_id thread is out obtaining a new volume
 337  * and preparing the label.
 338  */
 339 void _lock_device(const char *file, int line, DEVICE *dev)
 340 {
 341    int stat;
 342    Dmsg3(500, "lock %d from %s:%d\n", dev->dev_blocked, file, line);
 343    P(dev->mutex);
 344    if (dev->dev_blocked && !pthread_equal(dev->no_wait_id, pthread_self())) {
 345       dev->num_waiting++;             /* indicate that I am waiting */
 346       while (dev->dev_blocked) {
 347          if ((stat = pthread_cond_wait(&dev->wait, &dev->mutex)) != 0) {
 348             V(dev->mutex);
 349             Emsg1(M_ABORT, 0, _("pthread_cond_wait failure. ERR=%s\n"),
 350                strerror(stat));
 351          }
 352       }
 353       dev->num_waiting--;             /* no longer waiting */
 354    }
 355 }
 356
 357 /*
 358  * Check if the device is blocked or not
 359  */
 360 bool is_device_unmounted(DEVICE *dev)
 361 {
 362    bool stat;
 363    int blocked = dev->dev_blocked;
 364    stat = (blocked == BST_UNMOUNTED) ||
 365           (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
 366    return stat;
 367 }
 368
 369 void _unlock_device(const char *file, int line, DEVICE *dev)
 370 {
 371    Dmsg2(500, "unlock from %s:%d\n", file, line);
 372    V(dev->mutex);
 373 }
 374
 375 /*
 376  * Block all other threads from using the device
 377  *  Device must already be locked.  After this call,
 378  *  the device is blocked to any thread calling lock_device(),
 379  *  but the device is not locked (i.e. no P on device).  Also,
 380  *  the current thread can do slip through the lock_device()
 381  *  calls without blocking.
 382  */
 383 void _block_device(const char *file, int line, DEVICE *dev, int state)
 384 {
 385    Dmsg3(500, "block set %d from %s:%d\n", state, file, line);
 386    ASSERT(dev->get_blocked() == BST_NOT_BLOCKED);
 387    dev->set_blocked(state);           /* make other threads wait */
 388    dev->no_wait_id = pthread_self();  /* allow us to continue */
 389 }
 390
 391
 392
 393 /*
 394  * Unblock the device, and wake up anyone who went to sleep.
 395  */
 396 void _unblock_device(const char *file, int line, DEVICE *dev)
 397 {
 398    Dmsg3(500, "unblock %s from %s:%d\n", dev->print_blocked(), file, line);
 399    ASSERT(dev->dev_blocked);
 400    dev->set_blocked(BST_NOT_BLOCKED);
 401    dev->no_wait_id = 0;
 402    if (dev->num_waiting > 0) {
 403       pthread_cond_broadcast(&dev->wait); /* wake them up */
 404    }
 405 }
 406
 407 /*
 408  * Enter with device locked and blocked
 409  * Exit with device unlocked and blocked by us.
 410  */
 411 void _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state)
 412 {
 413
 414    Dmsg3(400, "steal lock. old=%s from %s:%d\n", dev->print_blocked(),
 415       file, line);
 416    hold->dev_blocked = dev->get_blocked();
 417    hold->dev_prev_blocked = dev->dev_prev_blocked;
 418    hold->no_wait_id = dev->no_wait_id;
 419    dev->set_blocked(state);
 420    Dmsg1(400, "steal lock. new=%s\n", dev->print_blocked());
 421    dev->no_wait_id = pthread_self();
 422    V(dev->mutex);
 423 }
 424
 425 /*
 426  * Enter with device blocked by us but not locked
 427  * Exit with device locked, and blocked by previous owner
 428  */
 429 void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
 430 {
 431    Dmsg3(400, "return lock. old=%s from %s:%d\n",
 432       dev->print_blocked(), file, line);
 433    P(dev->mutex);
 434    dev->dev_blocked = hold->dev_blocked;
 435    dev->dev_prev_blocked = hold->dev_prev_blocked;
 436    dev->no_wait_id = hold->no_wait_id;
 437    Dmsg1(400, "return lock. new=%s\n", dev->print_blocked());
 438    if (dev->num_waiting > 0) {
 439       pthread_cond_broadcast(&dev->wait); /* wake them up */
 440    }
 441 }