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    dev->VolCatInfo.VolCatJobs++;              /* increment number of jobs on vol */
 126    dir_update_volume_info(dcr, false);        /* send Volume info to Director */
 127
 128    Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
 129       dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
 130
 131    /*
 132     * If this is a new tape, the label_blk will contain the
 133     *  label, so write it now. If this is a previously
 134     *  used tape, mount_next_write_volume() will return an
 135     *  empty label_blk, and nothing will be written.
 136     */
 137    Dmsg0(190, "write label block to dev\n");
 138    if (!write_block_to_dev(dcr)) {
 139       berrno be;
 140       Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
 141         be.strerror(dev->dev_errno));
 142       free_block(label_blk);
 143       dcr->block = block;
 144       unblock_device(dev);
 145       return false;                /* device locked */
 146    }
 147    free_block(label_blk);
 148    dcr->block = block;
 149
 150    /*
 151     * Walk through all attached jcrs indicating the volume has changed
 152     */
 153    Dmsg1(100, "Walk attached dcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
 154    DCR *mdcr;
 155    foreach_dlist(mdcr, dev->attached_dcrs) {
 156       JCR *mjcr = mdcr->jcr;
 157       if (mjcr->JobId == 0) {
 158          continue;                 /* ignore console */
 159       }
 160       mdcr->NewVol = true;
 161       if (jcr != mjcr) {
 162          bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName));
 163       }
 164    }
 165
 166    /* Clear NewVol now because dir_get_volume_info() already done */
 167    jcr->dcr->NewVol = false;
 168    set_new_volume_parameters(dcr);
 169
 170    jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
 171
 172    /* Write overflow block to device */
 173    Dmsg0(190, "Write overflow block to dev\n");
 174    if (!write_block_to_dev(dcr)) {
 175       berrno be;
 176       Pmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
 177         be.strerror(dev->dev_errno));
 178       unblock_device(dev);
 179       return false;                /* device locked */
 180    }
 181
 182    unblock_device(dev);
 183    return true;                             /* device locked */
 184 }
 185
 186 /*
 187  * We have a new Volume mounted, so reset the Volume parameters
 188  *  concerning this job.  The global changes were made earlier
 189  *  in the dev structure.
 190  */
 191 void set_new_volume_parameters(DCR *dcr)
 192 {
 193    JCR *jcr = dcr->jcr;
 194    DEVICE *dev = dcr->dev;
 195    if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
 196       Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
 197    }
 198    /* Set new start/end positions */
 199    if (dev->is_tape()) {
 200       dcr->StartBlock = dev->block_num;
 201       dcr->StartFile = dev->file;
 202    } else {
 203       dcr->StartBlock = (uint32_t)dev->file_addr;
 204       dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
 205    }
 206    /* Reset indicies */
 207    dcr->VolFirstIndex = 0;
 208    dcr->VolLastIndex = 0;
 209    jcr->NumWriteVolumes++;
 210    dcr->NewVol = false;
 211    dcr->WroteVol = false;
 212 }
 213
 214 /*
 215  * We are now in a new Volume file, so reset the Volume parameters
 216  *  concerning this job.  The global changes were made earlier
 217  *  in the dev structure.
 218  */
 219 void set_new_file_parameters(DCR *dcr)
 220 {
 221    DEVICE *dev = dcr->dev;
 222
 223    /* Set new start/end positions */
 224    if (dev->is_tape()) {
 225       dcr->StartBlock = dev->block_num;
 226       dcr->StartFile = dev->file;
 227    } else {
 228       dcr->StartBlock = (uint32_t)dev->file_addr;
 229       dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
 230    }
 231    /* Reset indicies */
 232    dcr->VolFirstIndex = 0;
 233    dcr->VolLastIndex = 0;
 234    dcr->NewFile = false;
 235    dcr->WroteVol = false;
 236 }
 237
 238
 239
 240 /*
 241  *   First Open of the device. Expect dev to already be initialized.
 242  *
 243  *   This routine is used only when the Storage daemon starts
 244  *   and always_open is set, and in the stand-alone utility
 245  *   routines such as bextract.
 246  *
 247  *   Note, opening of a normal file is deferred to later so
 248  *    that we can get the filename; the device_name for
 249  *    a file is the directory only.
 250  *
 251  *   Returns: false on failure
 252  *            true  on success
 253  */
 254 bool first_open_device(DCR *dcr)
 255 {
 256    DEVICE *dev = dcr->dev;
 257    bool ok = true;
 258
 259    Dmsg0(120, "start open_output_device()\n");
 260    if (!dev) {
 261       return false;
 262    }
 263
 264    lock_device(dev);
 265
 266    /* Defer opening files */
 267    if (!dev->is_tape()) {
 268       Dmsg0(129, "Device is file, deferring open.\n");
 269       goto bail_out;
 270    }
 271
 272     int mode;
 273     if (dev->has_cap(CAP_STREAM)) {
 274        mode = OPEN_WRITE_ONLY;
 275     } else {
 276        mode = OPEN_READ_ONLY;
 277     }
 278    Dmsg0(129, "Opening device.\n");
 279    if (dev->open(dcr, mode) < 0) {
 280       Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
 281       ok = false;
 282       goto bail_out;
 283    }
 284    Dmsg1(129, "open dev %s OK\n", dev->print_name());
 285
 286 bail_out:
 287    unlock_device(dev);
 288    return ok;
 289 }
 290
 291 /*
 292  * Make sure device is open, if not do so
 293  */
 294 bool open_device(DCR *dcr)
 295 {
 296    DEVICE *dev = dcr->dev;
 297    /* Open device */
 298    int mode;
 299    if (dev->has_cap(CAP_STREAM)) {
 300       mode = OPEN_WRITE_ONLY;
 301    } else {
 302       mode = OPEN_READ_WRITE;
 303    }
 304    if (dev->open(dcr, mode) < 0) {
 305       /* If polling, ignore the error */
 306       /* If DVD, also ignore the error, very often you cannot open the device
 307        * (when there is no DVD, or when the one inserted is a wrong one) */
 308       if (!dev->poll && !dev->is_dvd() && !dev->is_removable()) {
 309          Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
 310             dev->print_name(), dev->bstrerror());
 311          Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"),
 312             dev->print_name(), dev->bstrerror());
 313       }
 314       return false;
 315    }
 316    return true;
 317 }
 318
 319
 320
 321 void dev_lock(DEVICE *dev)
 322 {
 323    int errstat;
 324    if ((errstat=rwl_writelock(&dev->lock))) {
 325       Emsg1(M_ABORT, 0, _("Device write lock failure. ERR=%s\n"), strerror(errstat));
 326    }
 327 }
 328
 329 void dev_unlock(DEVICE *dev)
 330 {
 331    int errstat;
 332    if ((errstat=rwl_writeunlock(&dev->lock))) {
 333       Emsg1(M_ABORT, 0, _("Device write unlock failure. ERR=%s\n"), strerror(errstat));
 334    }
 335 }
 336
 337 /*
 338  * When dev_blocked is set, all threads EXCEPT thread with id no_wait_id
 339  * must wait. The no_wait_id thread is out obtaining a new volume
 340  * and preparing the label.
 341  */
 342 void _lock_device(const char *file, int line, DEVICE *dev)
 343 {
 344    int stat;
 345    Dmsg3(500, "lock %d from %s:%d\n", dev->dev_blocked, file, line);
 346    P(dev->mutex);
 347    if (dev->dev_blocked && !pthread_equal(dev->no_wait_id, pthread_self())) {
 348       dev->num_waiting++;             /* indicate that I am waiting */
 349       while (dev->dev_blocked) {
 350          if ((stat = pthread_cond_wait(&dev->wait, &dev->mutex)) != 0) {
 351             V(dev->mutex);
 352             Emsg1(M_ABORT, 0, _("pthread_cond_wait failure. ERR=%s\n"),
 353                strerror(stat));
 354          }
 355       }
 356       dev->num_waiting--;             /* no longer waiting */
 357    }
 358 }
 359
 360 /*
 361  * Check if the device is blocked or not
 362  */
 363 bool is_device_unmounted(DEVICE *dev)
 364 {
 365    bool stat;
 366    int blocked = dev->dev_blocked;
 367    stat = (blocked == BST_UNMOUNTED) ||
 368           (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
 369    return stat;
 370 }
 371
 372 void _unlock_device(const char *file, int line, DEVICE *dev)
 373 {
 374    Dmsg2(500, "unlock from %s:%d\n", file, line);
 375    V(dev->mutex);
 376 }
 377
 378 /*
 379  * Block all other threads from using the device
 380  *  Device must already be locked.  After this call,
 381  *  the device is blocked to any thread calling lock_device(),
 382  *  but the device is not locked (i.e. no P on device).  Also,
 383  *  the current thread can do slip through the lock_device()
 384  *  calls without blocking.
 385  */
 386 void _block_device(const char *file, int line, DEVICE *dev, int state)
 387 {
 388    Dmsg3(500, "block set %d from %s:%d\n", state, file, line);
 389    ASSERT(dev->get_blocked() == BST_NOT_BLOCKED);
 390    dev->set_blocked(state);           /* make other threads wait */
 391    dev->no_wait_id = pthread_self();  /* allow us to continue */
 392 }
 393
 394
 395
 396 /*
 397  * Unblock the device, and wake up anyone who went to sleep.
 398  */
 399 void _unblock_device(const char *file, int line, DEVICE *dev)
 400 {
 401    Dmsg3(500, "unblock %s from %s:%d\n", dev->print_blocked(), file, line);
 402    ASSERT(dev->dev_blocked);
 403    dev->set_blocked(BST_NOT_BLOCKED);
 404    dev->no_wait_id = 0;
 405    if (dev->num_waiting > 0) {
 406       pthread_cond_broadcast(&dev->wait); /* wake them up */
 407    }
 408 }
 409
 410 /*
 411  * Enter with device locked and blocked
 412  * Exit with device unlocked and blocked by us.
 413  */
 414 void _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state)
 415 {
 416
 417    Dmsg3(400, "steal lock. old=%s from %s:%d\n", dev->print_blocked(),
 418       file, line);
 419    hold->dev_blocked = dev->get_blocked();
 420    hold->dev_prev_blocked = dev->dev_prev_blocked;
 421    hold->no_wait_id = dev->no_wait_id;
 422    dev->set_blocked(state);
 423    Dmsg1(400, "steal lock. new=%s\n", dev->print_blocked());
 424    dev->no_wait_id = pthread_self();
 425    V(dev->mutex);
 426 }
 427
 428 /*
 429  * Enter with device blocked by us but not locked
 430  * Exit with device locked, and blocked by previous owner
 431  */
 432 void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
 433 {
 434    Dmsg3(400, "return lock. old=%s from %s:%d\n",
 435       dev->print_blocked(), file, line);
 436    P(dev->mutex);
 437    dev->dev_blocked = hold->dev_blocked;
 438    dev->dev_prev_blocked = hold->dev_prev_blocked;
 439    dev->no_wait_id = hold->no_wait_id;
 440    Dmsg1(400, "return lock. new=%s\n", dev->print_blocked());
 441    if (dev->num_waiting > 0) {
 442       pthread_cond_broadcast(&dev->wait); /* wake them up */
 443    }
 444 }