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

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