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

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