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

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