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