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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2002-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *
  30  *  Routines for handling mounting tapes for reading and for
  31  *    writing.
  32  *
  33  *   Kern Sibbald, August MMII
  34  *
  35  *   Version $Id$
  36  */
  37
  38 #include "bacula.h"                   /* pull in global headers */
  39 #include "stored.h"                   /* pull in Storage Deamon headers */
  40
  41
  42 enum {
  43    try_next_vol = 1,
  44    try_read_vol,
  45    try_error,
  46    try_default
  47 };
  48
  49 enum {
  50    check_next_vol = 1,
  51    check_ok,
  52    check_read_vol,
  53    check_error
  54 };
  55
  56 /*
  57  * If release is set, we rewind the current volume,
  58  * which we no longer want, and ask the user (console)
  59  * to mount the next volume.
  60  *
  61  *  Continue trying until we get it, and then ensure
  62  *  that we can write on it.
  63  *
  64  * This routine returns a 0 only if it is REALLY
  65  *  impossible to get the requested Volume.
  66  *
  67  */
  68 bool DCR::mount_next_write_volume()
  69 {
  70    int retry = 0;
  71    bool ask = false, recycle, autochanger;
  72    int mode;
  73    DCR *dcr = this;
  74
  75    Dmsg2(150, "Enter mount_next_volume(release=%d) dev=%s\n", dev->must_unload(),
  76       dev->print_name());
  77
  78    init_device_wait_timers(dcr);
  79    lock_volumes();
  80
  81    /*
  82     * Attempt to mount the next volume. If something non-fatal goes
  83     *  wrong, we come back here to re-try (new op messages, re-read
  84     *  Volume, ...)
  85     */
  86 mount_next_vol:
  87    Dmsg1(150, "mount_next_vol retry=%d\n", retry);
  88    /* Ignore retry if this is poll request */
  89    if (!dev->poll && retry++ > 4) {
  90       /* Last ditch effort before giving up, force operator to respond */
  91       VolCatInfo.Slot = 0;
  92       unlock_volumes();
  93       if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
  94          Jmsg(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s.\n"),
  95               dev->print_name());
  96          goto no_lock_bail_out;
  97       }
  98       lock_volumes();
  99       Dmsg1(150, "Continue after dir_ask_sysop_to_mount. must_load=%d\n", dev->must_load());
 100    }
 101    if (job_canceled(jcr)) {
 102       Jmsg(jcr, M_FATAL, 0, _("Job %d canceled.\n"), jcr->JobId);
 103       goto bail_out;
 104    }
 105    recycle = false;
 106
 107    if (dev->must_unload()) {
 108       ask = true;                     /* ask operator to mount tape */
 109    }
 110    do_swapping(true /*writing*/);
 111
 112    if (retry < 2 && !find_a_volume()) {
 113       goto no_lock_bail_out;
 114    }
 115
 116    if (job_canceled(jcr)) {
 117       goto bail_out;
 118    }
 119    Dmsg3(150, "After find_next_append. Vol=%s Slot=%d Parts=%d\n",
 120          VolCatInfo.VolCatName, VolCatInfo.Slot, VolCatInfo.VolCatParts);
 121
 122    /*
 123     * Get next volume and ready it for append
 124     * This code ensures that the device is ready for
 125     * writing. We start from the assumption that there
 126     * may not be a tape mounted.
 127     *
 128     * If the device is a file, we create the output
 129     * file. If it is a tape, we check the volume name
 130     * and move the tape to the end of data.
 131     *
 132     */
 133    if (autoload_device(dcr, true/*writing*/, NULL) > 0) {
 134       autochanger = true;
 135       ask = false;
 136    } else {
 137       autochanger = false;
 138       VolCatInfo.Slot = 0;
 139       ask = true;
 140    }
 141    Dmsg1(150, "autoload_dev returns %d\n", autochanger);
 142    /*
 143     * If we autochanged to correct Volume or (we have not just
 144     *   released the Volume AND we can automount) we go ahead
 145     *   and read the label. If there is no tape in the drive,
 146     *   we will fail, recurse and ask the operator the next time.
 147     */
 148    if (!dev->must_unload() && dev->is_tape() && dev->has_cap(CAP_AUTOMOUNT)) {
 149       Dmsg0(250, "(1)Ask=0\n");
 150       ask = false;                 /* don't ask SYSOP this time */
 151    }
 152    /* Don't ask if not removable */
 153    if (!dev->is_removable()) {
 154       Dmsg0(250, "(2)Ask=0\n");
 155       ask = false;
 156    }
 157    Dmsg2(250, "Ask=%d autochanger=%d\n", ask, autochanger);
 158
 159    if (ask) {
 160       unlock_volumes();
 161       if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
 162          Dmsg0(150, "Error return ask_sysop ...\n");
 163          goto no_lock_bail_out;
 164       }
 165       lock_volumes();
 166    }
 167    if (job_canceled(jcr)) {
 168       goto bail_out;
 169    }
 170    Dmsg3(150, "want vol=%s devvol=%s dev=%s\n", VolumeName,
 171       dev->VolHdr.VolumeName, dev->print_name());
 172
 173    if (dev->poll && dev->has_cap(CAP_CLOSEONPOLL)) {
 174       dev->close();
 175    }
 176
 177    /* Ensure the device is open */
 178    if (dev->has_cap(CAP_STREAM)) {
 179       mode = OPEN_WRITE_ONLY;
 180    } else {
 181       mode = OPEN_READ_WRITE;
 182    }
 183    /* Try autolabel if enabled */
 184    if (dev->open(dcr, mode) < 0) {
 185       try_autolabel(false);      /* try to create a new volume label */
 186    }
 187    while (dev->open(dcr, mode) < 0) {
 188       Dmsg1(150, "open_device failed: ERR=%s\n", dev->bstrerror());
 189       if ((dev->is_file() && dev->is_removable()) || dev->is_dvd()) {
 190          bool ok = true;
 191          Dmsg0(150, "call scan_dir_for_vol\n");
 192          if (dev->is_dvd()) {
 193             if (!dev->mount(0)) {
 194                ok = false;
 195             }
 196          }
 197          if (ok && dev->scan_dir_for_volume(dcr)) {
 198             if (dev->open(dcr, mode) >= 0) {
 199                break;                    /* got a valid volume */
 200             }
 201          }
 202          if (ok && dev->is_dvd()) {
 203             dev->unmount(0);
 204          }
 205       }
 206       if (try_autolabel(false) == try_read_vol) {
 207          break;                       /* created a new volume label */
 208       }
 209       Dmsg0(50, "set_unload\n");
 210       dev->set_unload();              /* force ask sysop */
 211       ask = true;
 212       Dmsg0(150, "goto mount_next_vol\n");
 213       goto mount_next_vol;
 214    }
 215
 216    /*
 217     * Now check the volume label to make sure we have the right tape mounted
 218     */
 219 read_volume:
 220    switch (check_volume_label(ask, autochanger)) {
 221    case check_next_vol:
 222       Dmsg0(50, "set_unload\n");
 223       dev->set_unload();                 /* want a different Volume */
 224       Dmsg0(150, "goto mount_next_vol\n");
 225       goto mount_next_vol;
 226    case check_read_vol:
 227       goto read_volume;
 228    case check_error:
 229       goto bail_out;
 230    case check_ok:
 231       break;
 232    }
 233
 234    /*
 235     * See if we have a fresh tape or a tape with data.
 236     *
 237     * Note, if the LabelType is PRE_LABEL, it was labeled
 238     *  but never written. If so, rewrite the label but set as
 239     *  VOL_LABEL.  We rewind and return the label (reconstructed)
 240     *  in the block so that in the case of a new tape, data can
 241     *  be appended just after the block label.  If we are writing
 242     *  a second volume, the calling routine will write the label
 243     *  before writing the overflow block.
 244     *
 245     *  If the tape is marked as Recycle, we rewrite the label.
 246     */
 247    recycle = strcmp(dev->VolCatInfo.VolCatStatus, "Recycle") == 0;
 248    if (dev->VolHdr.LabelType == PRE_LABEL || recycle) {
 249       if (!rewrite_volume_label(dcr, recycle)) {
 250          mark_volume_in_error();
 251          goto mount_next_vol;
 252       }
 253    } else {
 254       /*
 255        * OK, at this point, we have a valid Bacula label, but
 256        * we need to position to the end of the volume, since we are
 257        * just now putting it into append mode.
 258        */
 259       Dmsg0(200, "Device previously written, moving to end of data\n");
 260       Jmsg(jcr, M_INFO, 0, _("Volume \"%s\" previously written, moving to end of data.\n"),
 261          VolumeName);
 262
 263       if (!dev->eod(dcr)) {
 264          Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data on device %s: ERR=%s\n"),
 265             dev->print_name(), dev->bstrerror());
 266          mark_volume_in_error();
 267          goto mount_next_vol;
 268       }
 269       if (!is_eod_valid()) {
 270          Dmsg0(150, "goto mount_next_vol\n");
 271          goto mount_next_vol;
 272       }
 273
 274       dev->VolCatInfo.VolCatMounts++;      /* Update mounts */
 275       Dmsg1(150, "update volinfo mounts=%d\n", dev->VolCatInfo.VolCatMounts);
 276       if (!dir_update_volume_info(dcr, false, false)) {
 277          goto bail_out;
 278       }
 279
 280       /* Return an empty block */
 281       empty_block(block);             /* we used it for reading so set for write */
 282    }
 283    dev->set_append();
 284    Dmsg1(150, "set APPEND, normal return from mount_next_write_volume. dev=%s\n",
 285       dev->print_name());
 286
 287    unlock_volumes();
 288    return true;
 289
 290 bail_out:
 291    unlock_volumes();
 292
 293 no_lock_bail_out:
 294    return false;
 295 }
 296
 297 /*
 298  * This routine is meant to be called once the first pass
 299  *   to ensure that we have a candidate volume to mount.
 300  *   Otherwise, we ask the sysop to created one.
 301  */
 302 bool DCR::find_a_volume()
 303 {
 304    DCR *dcr = this;
 305    if (!is_suitable_volume_mounted()) {
 306       bool have_vol = false;
 307       /* Do we have a candidate volume? */
 308       if (dev->vol) {
 309          bstrncpy(VolumeName, dev->vol->vol_name, sizeof(VolumeName));
 310          have_vol = dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE);
 311       }
 312       /*
 313        * Get Director's idea of what tape we should have mounted.
 314        *    in dcr->VolCatInfo
 315        */
 316       if (!have_vol) {
 317          Dmsg0(200, "Before dir_find_next_appendable_volume.\n");
 318          while (!dir_find_next_appendable_volume(dcr)) {
 319             Dmsg0(200, "not dir_find_next\n");
 320             if (job_canceled(jcr)) {
 321                unlock_volumes();
 322                return false;
 323             }
 324             unlock_volumes();
 325             if (!dir_ask_sysop_to_create_appendable_volume(dcr)) {
 326                return false;
 327              }
 328              lock_volumes();
 329              Dmsg0(150, "Again dir_find_next_append...\n");
 330          }
 331       }
 332    }
 333    return true;
 334 }
 335
 336 int DCR::check_volume_label(bool &ask, bool &autochanger)
 337 {
 338    int vol_label_status;
 339    /*
 340     * If we are writing to a stream device, ASSUME the volume label
 341     *  is correct.
 342     */
 343    if (dev->has_cap(CAP_STREAM)) {
 344       vol_label_status = VOL_OK;
 345       create_volume_label(dev, VolumeName, "Default", false /* not DVD */);
 346       dev->VolHdr.LabelType = PRE_LABEL;
 347    } else {
 348       vol_label_status = read_dev_volume_label(this);
 349    }
 350    if (job_canceled(jcr)) {
 351       goto check_bail_out;
 352    }
 353
 354    Dmsg2(150, "Want dirVol=%s dirStat=%s\n", VolumeName,
 355       VolCatInfo.VolCatStatus);
 356    /*
 357     * At this point, dev->VolCatInfo has what is in the drive, if anything,
 358     *          and   dcr->VolCatInfo has what the Director wants.
 359     */
 360    switch (vol_label_status) {
 361    case VOL_OK:
 362       Dmsg1(150, "Vol OK name=%s\n", dev->VolHdr.VolumeName);
 363       dev->VolCatInfo = VolCatInfo;       /* structure assignment */
 364       break;                    /* got a Volume */
 365    case VOL_NAME_ERROR:
 366       VOLUME_CAT_INFO dcrVolCatInfo, devVolCatInfo;
 367       char saveVolumeName[MAX_NAME_LENGTH];
 368
 369       Dmsg1(150, "Vol NAME Error Name=%s\n", VolumeName);
 370       if (dev->is_volume_to_unload()) {
 371          ask = true;
 372          goto check_next_volume;
 373       }
 374
 375       /* If not removable, Volume is broken */
 376       if (!dev->is_removable()) {
 377          Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
 378             VolumeName, dev->print_name());
 379          mark_volume_in_error();
 380          goto check_next_volume;
 381       }
 382
 383       /*
 384        * OK, we got a different volume mounted. First save the
 385        *  requested Volume info (dcr) structure, then query if
 386        *  this volume is really OK. If not, put back the desired
 387        *  volume name, mark it not in changer and continue.
 388        */
 389       dcrVolCatInfo = VolCatInfo;      /* structure assignment */
 390       devVolCatInfo = dev->VolCatInfo;      /* structure assignment */
 391       /* Check if this is a valid Volume in the pool */
 392       bstrncpy(saveVolumeName, VolumeName, sizeof(saveVolumeName));
 393       bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
 394       if (!dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE)) {
 395          POOL_MEM vol_info_msg;
 396          pm_strcpy(vol_info_msg, jcr->dir_bsock->msg);  /* save error message */
 397          /* Restore desired volume name, note device info out of sync */
 398          /* This gets the info regardless of the Pool */
 399          bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
 400          if (autochanger && !dir_get_volume_info(this, GET_VOL_INFO_FOR_READ)) {
 401             /*
 402              * If we get here, we know we cannot write on the Volume,
 403              *  and we know that we cannot read it either, so it
 404              *  is not in the autochanger.
 405              */
 406             mark_volume_not_inchanger();
 407          }
 408          dev->VolCatInfo = devVolCatInfo;    /* structure assignment */
 409          dev->set_unload();                  /* unload this volume */
 410          Jmsg(jcr, M_WARNING, 0, _("Director wanted Volume \"%s\".\n"
 411               "    Current Volume \"%s\" not acceptable because:\n"
 412               "    %s"),
 413              dcrVolCatInfo.VolCatName, dev->VolHdr.VolumeName,
 414              vol_info_msg.c_str());
 415          ask = true;
 416          /* Restore saved DCR before continuing */
 417          bstrncpy(VolumeName, saveVolumeName, sizeof(VolumeName));
 418          VolCatInfo = dcrVolCatInfo;  /* structure assignment */
 419          goto check_next_volume;
 420       }
 421       /*
 422        * This was not the volume we expected, but it is OK with
 423        * the Director, so use it.
 424        */
 425       Dmsg1(150, "Got new Volume name=%s\n", VolumeName);
 426       dev->VolCatInfo = VolCatInfo;   /* structure assignment */
 427       Dmsg1(100, "Call reserve_volume=%s\n", dev->VolHdr.VolumeName);
 428       if (reserve_volume(this, dev->VolHdr.VolumeName) == NULL) {
 429          Jmsg2(jcr, M_WARNING, 0, _("Could not reserve volume %s on %s\n"),
 430             dev->VolHdr.VolumeName, dev->print_name());
 431          ask = true;
 432          goto check_next_volume;
 433       }
 434       break;                /* got a Volume */
 435    /*
 436     * At this point, we assume we have a blank tape mounted.
 437     */
 438    case VOL_IO_ERROR:
 439       if (dev->is_dvd()) {
 440          Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);
 441          mark_volume_in_error();
 442          goto check_bail_out;       /* we could not write on DVD */
 443       }
 444       /* Fall through wanted */
 445    case VOL_NO_LABEL:
 446       switch (try_autolabel(true)) {
 447       case try_next_vol:
 448          goto check_next_volume;
 449       case try_read_vol:
 450          goto check_read_volume;
 451       case try_error:
 452          goto check_bail_out;
 453       case try_default:
 454          break;
 455       }
 456
 457       /* NOTE! Fall-through wanted. */
 458    case VOL_NO_MEDIA:
 459    default:
 460       Dmsg0(200, "VOL_NO_MEDIA or default.\n");
 461       /* Send error message */
 462       if (!dev->poll) {
 463       } else {
 464          Dmsg1(200, "Msg suppressed by poll: %s\n", jcr->errmsg);
 465       }
 466       ask = true;
 467       /* Needed, so the medium can be changed */
 468       if (dev->requires_mount()) {
 469          dev->close();
 470       }
 471       goto check_next_volume;
 472    }
 473    return check_ok;
 474
 475 check_next_volume:
 476    return check_next_vol;
 477
 478 check_bail_out:
 479    return check_error;
 480
 481 check_read_volume:
 482    return check_read_vol;
 483
 484 }
 485
 486
 487 bool DCR::is_suitable_volume_mounted()
 488 {
 489
 490    /* Volume mounted? */
 491    if (dev->VolHdr.VolumeName[0] == 0 || dev->swap_dev || dev->must_unload()) {
 492       return false;                      /* no */
 493    }
 494    bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
 495    return dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE);
 496 }
 497
 498 void DCR::do_swapping(bool is_writing)
 499 {
 500    if (dev->must_unload()) {
 501       Dmsg1(100, "must_unload release %s\n", dev->print_name());
 502       release_volume();
 503    }
 504    /*
 505     * See if we are asked to swap the Volume from another device
 506     *  if so, unload the other device here, and attach the
 507     *  volume to our drive.
 508     */
 509    if (dev->swap_dev) {
 510       if (dev->swap_dev->must_unload()) {
 511          if (dev->vol) {
 512             dev->swap_dev->set_slot(dev->vol->get_slot());
 513          }
 514          Dmsg2(100, "Swap unloading slot=%d %s\n", dev->swap_dev->get_slot(),
 515                dev->swap_dev->print_name());
 516          unload_dev(this, dev->swap_dev);
 517       }
 518       if (dev->vol) {
 519          dev->vol->clear_swapping();
 520          dev->vol->set_in_use();
 521          dev->VolHdr.VolumeName[0] = 0;  /* don't yet have right Volume */
 522       }
 523       dev->swap_dev = NULL;
 524    }
 525    if (dev->must_load()) {
 526       Dmsg1(100, "Must load %s\n", dev->print_name());
 527       if (autoload_device(this, is_writing, NULL) > 0) {
 528          dev->clear_load();
 529       }
 530    }
 531 }
 532
 533
 534 /*
 535  * Check if the current position on the volume corresponds to
 536  *  what is in the catalog.
 537  */
 538 bool DCR::is_eod_valid()
 539 {
 540    if (dev->is_dvd()) {
 541       char ed1[50], ed2[50];
 542       if (dev->VolCatInfo.VolCatBytes == dev->part_start + dev->part_size) {
 543          Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
 544               " part=%d size=%s\n"), VolumeName,
 545               dev->part, edit_uint64(dev->VolCatInfo.VolCatBytes,ed1));
 546       } else {
 547          Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on DVD Volume \"%s\" because: "
 548               "The sizes do not match! Volume=%s Catalog=%s\n"),
 549               VolumeName,
 550               edit_uint64(dev->part_start + dev->part_size, ed1),
 551               edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
 552          mark_volume_in_error();
 553          return false;
 554       }
 555    } else if (dev->is_tape()) {
 556       /*
 557        * Check if we are positioned on the tape at the same place
 558        * that the database says we should be.
 559        */
 560       if (dev->VolCatInfo.VolCatFiles == dev->get_file()) {
 561          Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\" at file=%d.\n"),
 562               VolumeName, dev->get_file());
 563       } else {
 564          Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on tape Volume \"%s\" because:\n"
 565               "The number of files mismatch! Volume=%u Catalog=%u\n"),
 566               VolumeName, dev->get_file(), dev->VolCatInfo.VolCatFiles);
 567          mark_volume_in_error();
 568          return false;
 569       }
 570    } else if (dev->is_file()) {
 571       char ed1[50], ed2[50];
 572       boffset_t pos;
 573       pos = dev->lseek(this, (boffset_t)0, SEEK_END);
 574       if (dev->VolCatInfo.VolCatBytes == (uint64_t)pos) {
 575          Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
 576               " size=%s\n"), VolumeName,
 577               edit_uint64(dev->VolCatInfo.VolCatBytes, ed1));
 578       } else {
 579          Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on disk Volume \"%s\" because: "
 580               "The sizes do not match! Volume=%s Catalog=%s\n"),
 581               VolumeName,
 582               edit_uint64(pos, ed1),
 583               edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
 584          mark_volume_in_error();
 585          return false;
 586       }
 587    }
 588    return true;
 589 }
 590
 591
 592 /*
 593  * If permitted, we label the device, make sure we can do
 594  *   it by checking that the VolCatBytes is zero => not labeled,
 595  *   once the Volume is labeled we don't want to label another
 596  *   blank tape with the same name.  For disk, we go ahead and
 597  *   label it anyway, because the OS insures that there is only
 598  *   one Volume with that name.
 599  * As noted above, at this point dcr->VolCatInfo has what
 600  *   the Director wants and dev->VolCatInfo has info on the
 601  *   previous tape (or nothing).
 602  *
 603  * Return codes are:
 604  *   try_next_vol        label failed, look for another volume
 605  *   try_read_vol        labeled volume, now re-read the label
 606  *   try_error           hard error (catalog update)
 607  *   try_default         I couldn't do anything
 608  */
 609 int DCR::try_autolabel(bool opened)
 610 {
 611    DCR *dcr = this;
 612
 613    if (dev->poll && !dev->is_tape()) {
 614       return try_default;       /* if polling, don't try to create new labels */
 615    }
 616    /* For a tape require it to be opened and read before labeling */
 617    if (!opened && dev->is_tape()) {
 618       return try_default;
 619    }
 620    if (dev->has_cap(CAP_LABEL) && (VolCatInfo.VolCatBytes == 0 ||
 621          (!dev->is_tape() && strcmp(VolCatInfo.VolCatStatus,
 622                                 "Recycle") == 0))) {
 623       Dmsg0(150, "Create volume label\n");
 624       /* Create a new Volume label and write it to the device */
 625       if (!write_new_volume_label_to_dev(dcr, VolumeName,
 626              pool_name, false, /* no relabel */ false /* defer DVD label */)) {
 627          Dmsg0(150, "!write_vol_label\n");
 628          if (opened) {
 629             mark_volume_in_error();
 630          }
 631          return try_next_vol;
 632       }
 633       Dmsg0(150, "dir_update_vol_info. Set Append\n");
 634       /* Copy Director's info into the device info */
 635       dev->VolCatInfo = VolCatInfo;    /* structure assignment */
 636       if (!dir_update_volume_info(dcr, true, true)) {  /* indicate tape labeled */
 637          return try_error;
 638       }
 639       Jmsg(dcr->jcr, M_INFO, 0, _("Labeled new Volume \"%s\" on device %s.\n"),
 640          VolumeName, dev->print_name());
 641       return try_read_vol;   /* read label we just wrote */
 642    }
 643    if (!dev->has_cap(CAP_LABEL) && VolCatInfo.VolCatBytes == 0) {
 644       Jmsg(jcr, M_WARNING, 0, _("Device %s not configured to autolabel Volumes.\n"),
 645          dev->print_name());
 646    }
 647    /* If not removable, Volume is broken */
 648    if (!dev->is_removable()) {
 649       Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
 650          VolumeName, dev->print_name());
 651       mark_volume_in_error();
 652       return try_next_vol;
 653    }
 654    return try_default;
 655 }
 656
 657
 658 /*
 659  * Mark volume in error in catalog
 660  */
 661 void DCR::mark_volume_in_error()
 662 {
 663    Jmsg(jcr, M_INFO, 0, _("Marking Volume \"%s\" in Error in Catalog.\n"),
 664         VolumeName);
 665    dev->VolCatInfo = VolCatInfo;       /* structure assignment */
 666    bstrncpy(dev->VolCatInfo.VolCatStatus, "Error", sizeof(dev->VolCatInfo.VolCatStatus));
 667    Dmsg0(150, "dir_update_vol_info. Set Error.\n");
 668    dir_update_volume_info(this, false, false);
 669    volume_unused(this);
 670    Dmsg0(50, "set_unload\n");
 671    dev->set_unload();                 /* must get a new volume */
 672 }
 673
 674 /*
 675  * The Volume is not in the correct slot, so mark this
 676  *   Volume as not being in the Changer.
 677  */
 678 void DCR::mark_volume_not_inchanger()
 679 {
 680    Jmsg(jcr, M_ERROR, 0, _("Autochanger Volume \"%s\" not found in slot %d.\n"
 681 "    Setting InChanger to zero in catalog.\n"),
 682         VolCatInfo.VolCatName, VolCatInfo.Slot);
 683    dev->VolCatInfo = VolCatInfo;    /* structure assignment */
 684    VolCatInfo.InChanger = false;
 685    dev->VolCatInfo.InChanger = false;
 686    Dmsg0(400, "update vol info in mount\n");
 687    dir_update_volume_info(this, true, false);  /* set new status */
 688 }
 689
 690 /*
 691  * Either because we are going to hang a new volume, or because
 692  *  of explicit user request, we release the current volume.
 693  */
 694 void DCR::release_volume()
 695 {
 696    unload_autochanger(this, -1);
 697
 698    if (WroteVol) {
 699       Jmsg0(jcr, M_ERROR, 0, _("Hey!!!!! WroteVol non-zero !!!!!\n"));
 700       Dmsg0(190, "Hey!!!!! WroteVol non-zero !!!!!\n");
 701    }
 702    /*
 703     * First erase all memory of the current volume
 704     */
 705    free_volume(dev);
 706    dev->block_num = dev->file = 0;
 707    dev->EndBlock = dev->EndFile = 0;
 708    memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
 709    dev->clear_volhdr();
 710    /* Force re-read of label */
 711    dev->clear_labeled();
 712    dev->clear_read();
 713    dev->clear_append();
 714    dev->label_type = B_BACULA_LABEL;
 715    VolumeName[0] = 0;
 716
 717    if (dev->is_open() && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
 718       dev->close();
 719    }
 720
 721    /* If we have not closed the device, then at least rewind the tape */
 722    if (dev->is_open()) {
 723       dev->offline_or_rewind();
 724    }
 725 // Dmsg0(50, "set_unload\n");
 726 // dev->set_unload();
 727    Dmsg0(190, "release_volume\n");
 728 }
 729
 730 /*
 731  *      Insanity check
 732  *
 733  * Check to see if the tape position as defined by the OS is
 734  *  the same as our concept.  If it is not,
 735  *  it means the user has probably manually rewound the tape.
 736  * Note, we check only if num_writers == 0, but this code will
 737  *  also work fine for any number of writers. If num_writers > 0,
 738  *  we probably should cancel all jobs using this device, or
 739  *  perhaps even abort the SD, or at a minimum, mark the tape
 740  *  in error.  Another strategy with num_writers == 0, would be
 741  *  to rewind the tape and do a new eod() request.
 742  */
 743 bool DCR::is_tape_position_ok()
 744 {
 745    if (dev->is_tape() && dev->num_writers == 0) {
 746       int32_t file = dev->get_os_tape_file();
 747       if (file >= 0 && file != (int32_t)dev->get_file()) {
 748          Jmsg(jcr, M_ERROR, 0, _("Invalid tape position on volume \"%s\""
 749               " on device %s. Expected %d, got %d\n"),
 750               dev->VolHdr.VolumeName, dev->print_name(), dev->get_file(), file);
 751          /*
 752           * If the current file is greater than zero, it means we probably
 753           *  have some bad count of EOF marks, so mark tape in error.  Otherwise
 754           *  the operator might have moved the tape, so we just release it
 755           *  and try again.
 756           */
 757          if (file > 0) {
 758             mark_volume_in_error();
 759          }
 760          release_volume();
 761          return false;
 762       }
 763    }
 764    return true;
 765 }
 766
 767
 768 /*
 769  * If we are reading, we come here at the end of the tape
 770  *  and see if there are more volumes to be mounted.
 771  */
 772 bool mount_next_read_volume(DCR *dcr)
 773 {
 774    DEVICE *dev = dcr->dev;
 775    JCR *jcr = dcr->jcr;
 776    Dmsg2(90, "NumReadVolumes=%d CurReadVolume=%d\n", jcr->NumReadVolumes, jcr->CurReadVolume);
 777
 778    volume_unused(dcr);                /* release current volume */
 779    /*
 780     * End Of Tape -- mount next Volume (if another specified)
 781     */
 782    if (jcr->NumReadVolumes > 1 && jcr->CurReadVolume < jcr->NumReadVolumes) {
 783       dev->close();
 784       if (!acquire_device_for_read(dcr)) {
 785          Jmsg2(jcr, M_FATAL, 0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(),
 786                dcr->VolumeName);
 787          return false;
 788       }
 789       return true;                    /* next volume mounted */
 790    }
 791    Dmsg0(90, "End of Device reached.\n");
 792    return false;
 793 }