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