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