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

   1 /*
   2  *
   3  *   dev.c  -- low level operations on device (storage device)
   4  *
   5  *              Kern Sibbald, MM
   6  *
   7  *     NOTE!!!! None of these routines are reentrant. You must
   8  *        use lock_device() and unlock_device() at a higher level,
   9  *        or use the xxx_device() equivalents.  By moving the
  10  *        thread synchronization to a higher level, we permit
  11  *        the higher level routines to "seize" the device and
  12  *        to carry out operations without worrying about who
  13  *        set what lock (i.e. race conditions).
  14  *
  15  *     Note, this is the device dependent code, and may have
  16  *           to be modified for each system, but is meant to
  17  *           be as "generic" as possible.
  18  *
  19  *     The purpose of this code is to develop a SIMPLE Storage
  20  *     daemon. More complicated coding (double buffering, writer
  21  *     thread, ...) is left for a later version.
  22  *
  23  *     Unfortunately, I have had to add more and more complication
  24  *     to this code. This was not foreseen as noted above, and as
  25  *     a consequence has lead to something more contorted than is
  26  *     really necessary -- KES.  Note, this contortion has been
  27  *     corrected to a large extent by a rewrite (Apr MMI).
  28  *
  29  *   Version $Id$
  30  */
  31 /*
  32    Copyright (C) 2000-2006 Kern Sibbald
  33
  34    This program is free software; you can redistribute it and/or
  35    modify it under the terms of the GNU General Public License
  36    version 2 as amended with additional clauses defined in the
  37    file LICENSE in the main source directory.
  38
  39    This program is distributed in the hope that it will be useful,
  40    but WITHOUT ANY WARRANTY; without even the implied warranty of
  41    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  42    the file LICENSE for additional details.
  43
  44  */
  45
  46 /*
  47  * Handling I/O errors and end of tape conditions are a bit tricky.
  48  * This is how it is currently done when writting.
  49  * On either an I/O error or end of tape,
  50  * we will stop writing on the physical device (no I/O recovery is
  51  * attempted at least in this daemon). The state flag will be sent
  52  * to include ST_EOT, which is ephimeral, and ST_WEOT, which is
  53  * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
  54  * cleared only when the problem goes away.  Now when ST_WEOT
  55  * is set all calls to write_block_to_device() call the fix_up
  56  * routine. In addition, all threads are blocked
  57  * from writing on the tape by calling lock_dev(), and thread other
  58  * than the first thread to hit the EOT will block on a condition
  59  * variable. The first thread to hit the EOT will continue to
  60  * be able to read and write the tape (he sort of tunnels through
  61  * the locking mechanism -- see lock_dev() for details).
  62  *
  63  * Now presumably somewhere higher in the chain of command
  64  * (device.c), someone will notice the EOT condition and
  65  * get a new tape up, get the tape label read, and mark
  66  * the label for rewriting. Then this higher level routine
  67  * will write the unwritten buffer to the new volume.
  68  * Finally, he will release
  69  * any blocked threads by doing a broadcast on the condition
  70  * variable.  At that point, we should be totally back in
  71  * business with no lost data.
  72  */
  73
  74
  75 #include "bacula.h"
  76 #include "stored.h"
  77
  78 #ifndef O_NONBLOCK
  79 #define O_NONBLOCK 0
  80 #endif
  81
  82 /* Forward referenced functions */
  83 void set_os_device_parameters(DEVICE *dev);
  84 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
  85 static char *mode_to_str(int mode);
  86
  87 /*
  88  * Allocate and initialize the DEVICE structure
  89  * Note, if dev is non-NULL, it is already allocated,
  90  * thus we neither allocate it nor free it. This allows
  91  * the caller to put the packet in shared memory.
  92  *
  93  *  Note, for a tape, the device->device_name is the device name
  94  *     (e.g. /dev/nst0), and for a file, the device name
  95  *     is the directory in which the file will be placed.
  96  *
  97  */
  98 DEVICE *
  99 init_dev(JCR *jcr, DEVRES *device)
 100 {
 101    struct stat statp;
 102    int errstat;
 103    DCR *dcr = NULL;
 104    DEVICE *dev;
 105
 106
 107    /* If no device type specified, try to guess */
 108    if (!device->dev_type) {
 109       /* Check that device is available */
 110       if (stat(device->device_name, &statp) < 0) {
 111          berrno be;
 112          Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
 113             device->device_name, be.strerror());
 114          return NULL;
 115       }
 116       if (S_ISDIR(statp.st_mode)) {
 117          device->dev_type = B_FILE_DEV;
 118       } else if (S_ISCHR(statp.st_mode)) {
 119          device->dev_type = B_TAPE_DEV;
 120       } else if (S_ISFIFO(statp.st_mode)) {
 121          device->dev_type = B_FILE_DEV;
 122       } else if (!(device->cap_bits & CAP_REQMOUNT)) {
 123          Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
 124                " or have RequiresMount=yes for DVD. st_mode=%x\n"),
 125             device->device_name, statp.st_mode);
 126          return NULL;
 127       } else {
 128          device->dev_type = B_DVD_DEV;
 129       }
 130    }
 131
 132    dev = (DEVICE *)malloc(sizeof(DEVICE));
 133    memset(dev, 0, sizeof(DEVICE));
 134    dev->Slot = -1;       /* unknown */
 135
 136    /* Copy user supplied device parameters from Resource */
 137    dev->dev_name = get_memory(strlen(device->device_name)+1);
 138    pm_strcpy(dev->dev_name, device->device_name);
 139    dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
 140    /* We edit "Resource-name" (physical-name) */
 141    Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
 142    Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
 143    dev->capabilities = device->cap_bits;
 144    dev->min_block_size = device->min_block_size;
 145    dev->max_block_size = device->max_block_size;
 146    dev->max_volume_size = device->max_volume_size;
 147    dev->max_file_size = device->max_file_size;
 148    dev->volume_capacity = device->volume_capacity;
 149    dev->max_rewind_wait = device->max_rewind_wait;
 150    dev->max_open_wait = device->max_open_wait;
 151    dev->max_open_vols = device->max_open_vols;
 152    dev->vol_poll_interval = device->vol_poll_interval;
 153    dev->max_spool_size = device->max_spool_size;
 154    dev->drive_index = device->drive_index;
 155    dev->autoselect = device->autoselect;
 156    dev->dev_type = device->dev_type;
 157    if (dev->is_tape()) { /* No parts on tapes */
 158       dev->max_part_size = 0;
 159    } else {
 160       dev->max_part_size = device->max_part_size;
 161    }
 162    /* Sanity check */
 163    if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
 164       dev->vol_poll_interval = 60;
 165    }
 166    /* Link the dev and device structures together */
 167    dev->device = device;
 168    device->dev = dev;
 169
 170    if (dev->is_fifo()) {
 171       dev->capabilities |= CAP_STREAM; /* set stream device */
 172    }
 173
 174    /* If the device requires mount :
 175     * - Check that the mount point is available
 176     * - Check that (un)mount commands are defined
 177     */
 178    if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
 179       if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
 180          berrno be;
 181          dev->dev_errno = errno;
 182          Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
 183             device->mount_point, be.strerror());
 184          return NULL;
 185       }
 186    }
 187    if (dev->is_dvd()) {
 188       if (!device->mount_command || !device->unmount_command) {
 189          Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
 190       }
 191       if (!device->write_part_command) {
 192          Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
 193       }
 194    }
 195
 196    if (dev->max_block_size > 1000000) {
 197       Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
 198          dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
 199       dev->max_block_size = 0;
 200    }
 201    if (dev->max_block_size % TAPE_BSIZE != 0) {
 202       Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
 203          dev->max_block_size, dev->print_name());
 204    }
 205
 206    dev->errmsg = get_pool_memory(PM_EMSG);
 207    *dev->errmsg = 0;
 208
 209    if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
 210       berrno be;
 211       dev->dev_errno = errstat;
 212       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 213       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 214    }
 215    if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
 216       berrno be;
 217       dev->dev_errno = errstat;
 218       Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
 219       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 220    }
 221    if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
 222       berrno be;
 223       dev->dev_errno = errstat;
 224       Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
 225       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 226    }
 227    if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
 228       berrno be;
 229       dev->dev_errno = errstat;
 230       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 231       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 232    }
 233    if ((errstat = rwl_init(&dev->lock)) != 0) {
 234       berrno be;
 235       dev->dev_errno = errstat;
 236       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 237       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 238    }
 239
 240    dev->clear_opened();
 241    dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
 242    Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
 243
 244    return dev;
 245 }
 246
 247 /*
 248  * Open the device with the operating system and
 249  * initialize buffer pointers.
 250  *
 251  * Returns:  -1  on error
 252  *           fd  on success
 253  *
 254  * Note, for a tape, the VolName is the name we give to the
 255  *    volume (not really used here), but for a file, the
 256  *    VolName represents the name of the file to be created/opened.
 257  *    In the case of a file, the full name is the device name
 258  *    (archive_name) with the VolName concatenated.
 259  */
 260 int
 261 DEVICE::open(DCR *dcr, int omode)
 262 {
 263    int preserve = 0;
 264    if (is_open()) {
 265       if (openmode == omode) {
 266          return fd;
 267       } else {
 268          if (is_tape()) {
 269             tape_close(fd);
 270          } else {
 271             ::close(fd);
 272          }
 273          clear_opened();
 274          Dmsg0(100, "Close fd for mode change.\n");
 275          preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
 276       }
 277    }
 278    if (dcr) {
 279       bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
 280    }
 281
 282    Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
 283          print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
 284    state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
 285    Slot = -1;          /* unknown slot */
 286    label_type = B_BACULA_LABEL;
 287    if (is_tape() || is_fifo()) {
 288       open_tape_device(dcr, omode);
 289    } else if (is_dvd()) {
 290       Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
 291       open_dvd_device(dcr, omode);
 292    } else {
 293       Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
 294       open_file_device(dcr, omode);
 295    }
 296    state |= preserve;                 /* reset any important state info */
 297    Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, fd);
 298    return fd;
 299 }
 300
 301 void DEVICE::set_mode(int new_mode)
 302 {
 303    switch (new_mode) {
 304    case CREATE_READ_WRITE:
 305       mode = O_CREAT | O_RDWR | O_BINARY;
 306       break;
 307    case OPEN_READ_WRITE:
 308       mode = O_RDWR | O_BINARY;
 309       break;
 310    case OPEN_READ_ONLY:
 311       mode = O_RDONLY | O_BINARY;
 312       break;
 313    case OPEN_WRITE_ONLY:
 314       mode = O_WRONLY | O_BINARY;
 315       break;
 316    default:
 317       Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
 318    }
 319 }
 320
 321 /*
 322  */
 323 void DEVICE::open_tape_device(DCR *dcr, int omode)
 324 {
 325    file_size = 0;
 326    int timeout = max_open_wait;
 327    struct mtop mt_com;
 328    utime_t start_time = time(NULL);
 329    Dmsg0(29, "Open dev: device is tape\n");
 330
 331    get_autochanger_loaded_slot(dcr);
 332
 333    set_mode(omode);
 334    if (timeout < 1) {
 335       timeout = 1;
 336    }
 337    errno = 0;
 338    if (is_fifo() && timeout) {
 339       /* Set open timer */
 340       tid = start_thread_timer(pthread_self(), timeout);
 341    }
 342    /* If busy retry each second for max_open_wait seconds */
 343    Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
 344    /* Use system open() */
 345 #if defined(HAVE_WIN32)
 346    if ((fd = tape_open(dev_name, mode)) < 0) {
 347       dev_errno = errno;
 348    }
 349 #else
 350    for ( ;; ) {
 351       fd = ::open(dev_name, mode);
 352       if (fd < 0) {
 353          berrno be;
 354          dev_errno = errno;
 355          Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
 356               print_name(), omode, mode, errno, be.strerror());
 357       } else {
 358          /* Tape open, now rewind it */
 359          mt_com.mt_op = MTREW;
 360          mt_com.mt_count = 1;
 361          if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
 362             berrno be;
 363             dev_errno = errno;           /* set error status from rewind */
 364             ::close(fd);
 365             clear_opened();
 366             Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
 367                   be.strerror(dev_errno));
 368          } else {
 369             dev_errno = 0;
 370             set_os_device_parameters(this);      /* do system dependent stuff */
 371             break;                    /* Successfully opened and rewound */
 372          }
 373       }
 374       bmicrosleep(5, 0);
 375       /* Exceed wait time ? */
 376       if (time(NULL) - start_time >= max_open_wait) {
 377          break;                       /* yes, get out */
 378       }
 379    }
 380 #endif
 381
 382    if (!is_open()) {
 383       berrno be;
 384       Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
 385             print_name(), be.strerror(dev_errno));
 386       Dmsg1(100, "%s", errmsg);
 387    }
 388
 389    /* Stop any open() timer we started */
 390    if (tid) {
 391       stop_thread_timer(tid);
 392       tid = 0;
 393    }
 394    Dmsg1(29, "open dev: tape %d opened\n", fd);
 395 }
 396
 397
 398 /*
 399  * Open a file device
 400  */
 401 void DEVICE::open_file_device(DCR *dcr, int omode)
 402 {
 403    POOL_MEM archive_name(PM_FNAME);
 404
 405    get_autochanger_loaded_slot(dcr);
 406
 407    /*
 408     * Handle opening of File Archive (not a tape)
 409     */
 410
 411    pm_strcpy(archive_name, dev_name);
 412    /*
 413     * If this is a virtual autochanger (i.e. changer_res != NULL)
 414     *  we simply use the device name, assuming it has been
 415     *  appropriately setup by the "autochanger".
 416     */
 417    if (!device->changer_res) {
 418       if (VolCatInfo.VolCatName[0] == 0) {
 419          Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
 420             print_name());
 421          clear_opened();
 422          return;
 423       }
 424
 425       if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
 426          pm_strcat(archive_name, "/");
 427       }
 428       pm_strcat(archive_name, VolCatInfo.VolCatName);
 429    }
 430
 431    mount(1);                          /* do mount if required */
 432
 433    openmode = omode;
 434    set_mode(omode);
 435    /* If creating file, give 0640 permissions */
 436    Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
 437          archive_name.c_str(), mode);
 438    /* Use system open() */
 439    if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
 440       berrno be;
 441       dev_errno = errno;
 442       Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
 443             be.strerror());
 444       Dmsg1(29, "open failed: %s", errmsg);
 445       Emsg0(M_FATAL, 0, errmsg);
 446    } else {
 447       dev_errno = 0;
 448       file = 0;
 449       file_addr = 0;
 450    }
 451    Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
 452       fd, part, num_dvd_parts, part_size);
 453 }
 454
 455 /*
 456  * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
 457  *  (NB:??? I think it's VolCatInfo.VolCatName that is right)
 458  *  has the desired Volume name, but there is NO assurance that
 459  *  any other field of VolCatInfo is correct.
 460  */
 461 void DEVICE::open_dvd_device(DCR *dcr, int omode)
 462 {
 463    POOL_MEM archive_name(PM_FNAME);
 464    struct stat filestat;
 465
 466    /*
 467     * Handle opening of DVD Volume
 468     */
 469    Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
 470          archive_name.c_str(), mode_to_str(omode));
 471
 472    /*
 473     * For a DVD we must always pull the state info from dcr->VolCatInfo
 474     *  This is a bit ugly, but is necessary because we need to open/close/re-open
 475     *  the dvd file in order to properly mount/unmount and access the
 476     *  DVD. So we store the state of the DVD as far as is known in the
 477     *  catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
 478     *  copy here, when opening.
 479     */
 480    memcpy(&VolCatInfo, &dcr->VolCatInfo, sizeof(VolCatInfo));
 481    Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
 482
 483    if (VolCatInfo.VolCatName[0] == 0) {
 484       Dmsg1(10,  "Could not open file device %s. No Volume name given.\n",
 485          print_name());
 486       Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
 487          print_name());
 488       clear_opened();
 489       return;
 490    }
 491
 492    if (part == 0) {
 493       Dmsg0(100, "Set part=1\n");
 494       part = 1;                       /* count from 1 */
 495       file_size = 0;
 496    }
 497    part_size = 0;
 498    if (num_dvd_parts != VolCatInfo.VolCatParts) {
 499       num_dvd_parts = VolCatInfo.VolCatParts;
 500    }
 501
 502    /*
 503     * If we are not trying to access the last part, set mode to
 504     *   OPEN_READ_ONLY as writing would be an error.
 505     */
 506    Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
 507    if (part <= num_dvd_parts) {
 508       omode = OPEN_READ_ONLY;
 509       make_mounted_dvd_filename(this, archive_name);
 510       set_part_spooled(false);
 511    } else {
 512       omode = OPEN_READ_WRITE;
 513       make_spooled_dvd_filename(this, archive_name);
 514       set_part_spooled(true);
 515    }
 516    set_mode(omode);
 517
 518    // Clear any previous blank_dvd status - we will recalculate it here
 519    blank_dvd = false;
 520
 521    Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
 522       part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
 523
 524    if (mount_dvd(this, 1)) {
 525       Dmsg0(99, "DVD device mounted.\n");
 526       if (num_dvd_parts == 0 && !truncating) {
 527          /*
 528           * If we can mount the device, and we are not truncating the DVD,
 529           * we usually want to abort. There is one exception, if there is
 530           * only one 0-sized file on the DVD, with the right volume name,
 531           * we continue (it's the method used by truncate_dvd to truncate a volume).
 532           */
 533          if (!check_can_write_on_non_blank_dvd(dcr)) {
 534             Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
 535             Emsg0(M_FATAL, 0, errmsg);
 536             unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
 537             clear_opened();
 538             return;
 539          }
 540          blank_dvd = true;
 541       }
 542    } else {
 543       Dmsg0(99, "DVD device mount failed.\n");
 544       /* We cannot mount the device */
 545       if (num_dvd_parts == 0) {
 546          /* Run free space, check there is a media. */
 547          if (!update_free_space_dev(this)) {
 548             Emsg0(M_FATAL, 0, errmsg);
 549             clear_opened();
 550             return;
 551          }
 552          if (have_media()) {
 553             Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
 554          } else {
 555             Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
 556             Emsg0(M_FATAL, 0, errmsg);
 557             clear_opened();
 558             return;
 559          }
 560       }  else {
 561          Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
 562          Emsg0(M_FATAL, 0, errmsg);
 563          clear_opened();
 564          return;
 565       }
 566    }
 567
 568    Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
 569       archive_name.c_str(), mode_to_str(omode),
 570       part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
 571    openmode = omode;
 572    Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
 573
 574
 575    /* If creating file, give 0640 permissions */
 576    Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
 577          archive_name.c_str(), mode);
 578    /* Use system open() */
 579    if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
 580       berrno be;
 581       Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
 582             be.strerror());
 583       // Should this be set if we try the create/open below
 584       dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
 585       Dmsg1(29, "open failed: %s", errmsg);
 586
 587       /* Previous open failed. See if we can recover */
 588       if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
 589           (part > num_dvd_parts)) {
 590          /* If the last part (on spool), doesn't exist when accessing,
 591           * create it. In read/write mode a write will be allowed (higher
 592           * level software thinks that we are extending a pre-existing
 593           * media. Reads for READ_ONLY will report immediately an EOF
 594           * Sometimes it is better to finish with an EOF than with an error. */
 595          Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
 596          omode = CREATE_READ_WRITE;
 597          set_mode(CREATE_READ_WRITE);
 598          fd = ::open(archive_name.c_str(), mode, 0640);
 599          set_mode(omode);
 600       }
 601    }
 602    Dmsg1(100, "after open fd=%d\n", fd);
 603    if (is_open()) {
 604       if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
 605          set_append();
 606       }
 607       /* Get size of file */
 608       if (fstat(fd, &filestat) < 0) {
 609          berrno be;
 610          dev_errno = errno;
 611          Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
 612                be.strerror());
 613          Dmsg1(29, "open failed: %s", errmsg);
 614          /* Use system close() */
 615          ::close(fd);
 616          clear_opened();
 617       } else {
 618          part_size = filestat.st_size;
 619          dev_errno = 0;
 620          update_pos(dcr);                    /* update position */
 621       }
 622    }
 623 }
 624
 625
 626 /*
 627  * Rewind the device.
 628  *  Returns: true  on success
 629  *           false on failure
 630  */
 631 bool DEVICE::rewind(DCR *dcr)
 632 {
 633    struct mtop mt_com;
 634    unsigned int i;
 635    bool first = true;
 636
 637    Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
 638    state &= ~(ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
 639    block_num = file = 0;
 640    file_size = 0;
 641    file_addr = 0;
 642    if (fd < 0) {
 643       if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
 644          dev_errno = EBADF;
 645          Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
 646             print_name());
 647          Emsg0(M_ABORT, 0, errmsg);
 648       }
 649       return false;
 650    }
 651    if (is_tape()) {
 652       mt_com.mt_op = MTREW;
 653       mt_com.mt_count = 1;
 654       /* If we get an I/O error on rewind, it is probably because
 655        * the drive is actually busy. We loop for (about 5 minutes)
 656        * retrying every 5 seconds.
 657        */
 658       for (i=max_rewind_wait; ; i -= 5) {
 659          if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
 660             berrno be;
 661             clrerror(MTREW);
 662             if (i == max_rewind_wait) {
 663                Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
 664             }
 665             /*
 666              * This is a gross hack, because if the user has the
 667              *   device mounted (i.e. open), then uses mtx to load
 668              *   a tape, the current open file descriptor is invalid.
 669              *   So, we close the drive and re-open it.
 670              */
 671             if (first && dcr) {
 672                int open_mode = openmode;
 673                tape_close(fd);
 674                clear_opened();
 675                open(dcr, open_mode);
 676                if (fd < 0) {
 677                   return false;
 678                }
 679                first = false;
 680                continue;
 681             }
 682 #ifdef HAVE_SUN_OS
 683             if (dev_errno == EIO) {
 684                Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
 685                return false;
 686             }
 687 #else
 688             if (dev_errno == EIO && i > 0) {
 689                Dmsg0(200, "Sleeping 5 seconds.\n");
 690                bmicrosleep(5, 0);
 691                continue;
 692             }
 693 #endif
 694             Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
 695                print_name(), be.strerror());
 696             return false;
 697          }
 698          break;
 699       }
 700    } else if (is_file() || is_dvd()) {
 701       if (lseek(dcr, (off_t)0, SEEK_SET) < 0) {
 702          berrno be;
 703          dev_errno = errno;
 704          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
 705             print_name(), be.strerror());
 706          return false;
 707       }
 708    }
 709    return true;
 710 }
 711
 712 void DEVICE::block(int why)
 713 {
 714    lock_device(this);
 715    block_device(this, why);
 716    V(mutex);
 717 }
 718
 719 void DEVICE::unblock()
 720 {
 721    P(mutex);
 722    unblock_device(this);
 723    V(mutex);
 724 }
 725
 726 const char *DEVICE::print_blocked() const
 727 {
 728    switch (dev_blocked) {
 729    case BST_NOT_BLOCKED:
 730       return "BST_NOT_BLOCKED";
 731    case BST_UNMOUNTED:
 732       return "BST_UNMOUNTED";
 733    case BST_WAITING_FOR_SYSOP:
 734       return "BST_WAITING_FOR_SYSOP";
 735    case BST_DOING_ACQUIRE:
 736       return "BST_DOING_ACQUIRE";
 737    case BST_WRITING_LABEL:
 738       return "BST_WRITING_LABEL";
 739    case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 740       return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
 741    case BST_MOUNT:
 742       return "BST_MOUNT";
 743    default:
 744       return _("unknown blocked code");
 745    }
 746 }
 747
 748 /*
 749  * Called to indicate that we have just read an
 750  *  EOF from the device.
 751  */
 752 void DEVICE::set_ateof()
 753 {
 754    set_eof();
 755    if (is_tape()) {
 756       file++;
 757    }
 758    file_addr = 0;
 759    file_size = 0;
 760    block_num = 0;
 761 }
 762
 763 /*
 764  * Called to indicate we are now at the end of the tape, and
 765  *   writing is not possible.
 766  */
 767 void DEVICE::set_ateot()
 768 {
 769    /* Make tape effectively read-only */
 770    state |= (ST_EOF|ST_EOT|ST_WEOT);
 771    clear_append();
 772 }
 773
 774 /*
 775  * Position device to end of medium (end of data)
 776  *  Returns: true  on succes
 777  *           false on error
 778  */
 779 bool DEVICE::eod(DCR *dcr)
 780 {
 781    struct mtop mt_com;
 782    struct mtget mt_stat;
 783    bool ok = true;
 784    off_t pos;
 785
 786    if (fd < 0) {
 787       dev_errno = EBADF;
 788       Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
 789       return false;
 790    }
 791
 792 #if defined (__digital__) && defined (__unix__)
 793    return fsf(VolCatInfo.VolCatFiles);
 794 #endif
 795
 796    Dmsg0(29, "eod\n");
 797    if (at_eot()) {
 798       return true;
 799    }
 800    clear_eof();         /* remove EOF flag */
 801    block_num = file = 0;
 802    file_size = 0;
 803    file_addr = 0;
 804    if (is_fifo() || is_prog()) {
 805       return true;
 806    }
 807    if (!is_tape()) {
 808       pos = lseek(dcr, (off_t)0, SEEK_END);
 809 //    Dmsg1(100, "====== Seek to %lld\n", pos);
 810       if (pos >= 0) {
 811          update_pos(dcr);
 812          set_eot();
 813          return true;
 814       }
 815       dev_errno = errno;
 816       berrno be;
 817       Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
 818              print_name(), be.strerror());
 819       return false;
 820    }
 821 #ifdef MTEOM
 822    if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
 823       Dmsg0(100,"Using FAST FSF for EOM\n");
 824       /* If unknown position, rewind */
 825       if (!dev_get_os_pos(this, &mt_stat)) {
 826         if (!rewind(NULL)) {
 827           return false;
 828         }
 829       }
 830       mt_com.mt_op = MTFSF;
 831       /*
 832        * ***FIXME*** fix code to handle case that INT16_MAX is
 833        *   not large enough.
 834        */
 835       mt_com.mt_count = INT16_MAX;    /* use big positive number */
 836       if (mt_com.mt_count < 0) {
 837          mt_com.mt_count = INT16_MAX; /* brain damaged system */
 838       }
 839    }
 840
 841    if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
 842       if (has_cap(CAP_EOM)) {
 843          Dmsg0(100,"Using EOM for EOM\n");
 844          mt_com.mt_op = MTEOM;
 845          mt_com.mt_count = 1;
 846       }
 847
 848       if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
 849          berrno be;
 850          clrerror(mt_com.mt_op);
 851          Dmsg1(50, "ioctl error: %s\n", be.strerror());
 852          update_pos(dcr);
 853          Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
 854             print_name(), be.strerror());
 855          return false;
 856       }
 857
 858       if (!dev_get_os_pos(this, &mt_stat)) {
 859          berrno be;
 860          clrerror(-1);
 861          Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
 862             print_name(), be.strerror());
 863          return false;
 864       }
 865       Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
 866       set_ateof();
 867       file = mt_stat.mt_fileno;
 868    } else {
 869 #else
 870    {
 871 #endif
 872       /*
 873        * Rewind then use FSF until EOT reached
 874        */
 875       if (!rewind(NULL)) {
 876          return false;
 877       }
 878       /*
 879        * Move file by file to the end of the tape
 880        */
 881       int file_num;
 882       for (file_num=file; !at_eot(); file_num++) {
 883          Dmsg0(200, "eod: doing fsf 1\n");
 884          if (!fsf(1)) {
 885             Dmsg0(200, "fsf error.\n");
 886             return false;
 887          }
 888          /*
 889           * Avoid infinite loop by ensuring we advance.
 890           */
 891          if (file_num == (int)file) {
 892             struct mtget mt_stat;
 893             Dmsg1(100, "fsf did not advance from file %d\n", file_num);
 894             set_ateof();
 895             if (dev_get_os_pos(this, &mt_stat)) {
 896                Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
 897                file = mt_stat.mt_fileno;
 898             }
 899             break;
 900          }
 901       }
 902    }
 903    /*
 904     * Some drivers leave us after second EOF when doing
 905     * MTEOM, so we must backup so that appending overwrites
 906     * the second EOF.
 907     */
 908    if (has_cap(CAP_BSFATEOM)) {
 909       struct mtget mt_stat;
 910       /* Backup over EOF */
 911       ok = bsf(1);
 912       /* If BSF worked and fileno is known (not -1), set file */
 913       if (dev_get_os_pos(this, &mt_stat)) {
 914          Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
 915          file = mt_stat.mt_fileno;
 916       } else {
 917          file++;                       /* wing it -- not correct on all OSes */
 918       }
 919    } else {
 920       update_pos(dcr);                 /* update position */
 921    }
 922    Dmsg1(200, "EOD dev->file=%d\n", file);
 923    return ok;
 924 }
 925
 926 /*
 927  * Set the position of the device -- only for files and DVD
 928  *   For other devices, there is no generic way to do it.
 929  *  Returns: true  on succes
 930  *           false on error
 931  */
 932 bool DEVICE::update_pos(DCR *dcr)
 933 {
 934    off_t pos;
 935    bool ok = true;
 936
 937    if (!is_open()) {
 938       dev_errno = EBADF;
 939       Mmsg0(errmsg, _("Bad device call. Device not open\n"));
 940       Emsg1(M_FATAL, 0, "%s", errmsg);
 941       return false;
 942    }
 943
 944    /* Find out where we are */
 945    if (is_file() || is_dvd()) {
 946       file = 0;
 947       file_addr = 0;
 948       pos = lseek(dcr, (off_t)0, SEEK_CUR);
 949       if (pos < 0) {
 950          berrno be;
 951          dev_errno = errno;
 952          Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
 953          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
 954             print_name(), be.strerror());
 955          ok = false;
 956       } else {
 957          file_addr = pos;
 958          block_num = (uint32_t)pos;
 959          file = (uint32_t)(pos >> 32);
 960       }
 961    }
 962    return ok;
 963 }
 964
 965 /*
 966  * Return the status of the device.  This was meant
 967  * to be a generic routine. Unfortunately, it doesn't
 968  * seem possible (at least I do not know how to do it
 969  * currently), which means that for the moment, this
 970  * routine has very little value.
 971  *
 972  *   Returns: status
 973  */
 974 uint32_t status_dev(DEVICE *dev)
 975 {
 976    struct mtget mt_stat;
 977    uint32_t stat = 0;
 978
 979    if (dev->state & (ST_EOT | ST_WEOT)) {
 980       stat |= BMT_EOD;
 981       Pmsg0(-20, " EOD");
 982    }
 983    if (dev->state & ST_EOF) {
 984       stat |= BMT_EOF;
 985       Pmsg0(-20, " EOF");
 986    }
 987    if (dev->is_tape()) {
 988       stat |= BMT_TAPE;
 989       Pmsg0(-20,_(" Bacula status:"));
 990       Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
 991       if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
 992          berrno be;
 993          dev->dev_errno = errno;
 994          Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
 995             dev->print_name(), be.strerror());
 996          return 0;
 997       }
 998       Pmsg0(-20, _(" Device status:"));
 999
1000 #if defined(HAVE_LINUX_OS)
1001       if (GMT_EOF(mt_stat.mt_gstat)) {
1002          stat |= BMT_EOF;
1003          Pmsg0(-20, " EOF");
1004       }
1005       if (GMT_BOT(mt_stat.mt_gstat)) {
1006          stat |= BMT_BOT;
1007          Pmsg0(-20, " BOT");
1008       }
1009       if (GMT_EOT(mt_stat.mt_gstat)) {
1010          stat |= BMT_EOT;
1011          Pmsg0(-20, " EOT");
1012       }
1013       if (GMT_SM(mt_stat.mt_gstat)) {
1014          stat |= BMT_SM;
1015          Pmsg0(-20, " SM");
1016       }
1017       if (GMT_EOD(mt_stat.mt_gstat)) {
1018          stat |= BMT_EOD;
1019          Pmsg0(-20, " EOD");
1020       }
1021       if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1022          stat |= BMT_WR_PROT;
1023          Pmsg0(-20, " WR_PROT");
1024       }
1025       if (GMT_ONLINE(mt_stat.mt_gstat)) {
1026          stat |= BMT_ONLINE;
1027          Pmsg0(-20, " ONLINE");
1028       }
1029       if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1030          stat |= BMT_DR_OPEN;
1031          Pmsg0(-20, " DR_OPEN");
1032       }
1033       if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1034          stat |= BMT_IM_REP_EN;
1035          Pmsg0(-20, " IM_REP_EN");
1036       }
1037 #elif defined(HAVE_WIN32)
1038       if (GMT_EOF(mt_stat.mt_gstat)) {
1039          stat |= BMT_EOF;
1040          Pmsg0(-20, " EOF");
1041       }
1042       if (GMT_BOT(mt_stat.mt_gstat)) {
1043          stat |= BMT_BOT;
1044          Pmsg0(-20, " BOT");
1045       }
1046       if (GMT_EOT(mt_stat.mt_gstat)) {
1047          stat |= BMT_EOT;
1048          Pmsg0(-20, " EOT");
1049       }
1050       if (GMT_EOD(mt_stat.mt_gstat)) {
1051          stat |= BMT_EOD;
1052          Pmsg0(-20, " EOD");
1053       }
1054       if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1055          stat |= BMT_WR_PROT;
1056          Pmsg0(-20, " WR_PROT");
1057       }
1058       if (GMT_ONLINE(mt_stat.mt_gstat)) {
1059          stat |= BMT_ONLINE;
1060          Pmsg0(-20, " ONLINE");
1061       }
1062       if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1063          stat |= BMT_DR_OPEN;
1064          Pmsg0(-20, " DR_OPEN");
1065       }
1066       if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1067          stat |= BMT_IM_REP_EN;
1068          Pmsg0(-20, " IM_REP_EN");
1069       }
1070
1071 #endif /* !SunOS && !OSF */
1072       if (dev->has_cap(CAP_MTIOCGET)) {
1073          Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1074       } else {
1075          Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1076       }
1077    } else {
1078       stat |= BMT_ONLINE | BMT_BOT;
1079    }
1080    return stat;
1081 }
1082
1083
1084 /*
1085  * Load medium in device
1086  *  Returns: true  on success
1087  *           false on failure
1088  */
1089 bool load_dev(DEVICE *dev)
1090 {
1091 #ifdef MTLOAD
1092    struct mtop mt_com;
1093 #endif
1094
1095    if (dev->fd < 0) {
1096       dev->dev_errno = EBADF;
1097       Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1098       Emsg0(M_FATAL, 0, dev->errmsg);
1099       return false;
1100    }
1101    if (!(dev->is_tape())) {
1102       return true;
1103    }
1104 #ifndef MTLOAD
1105    Dmsg0(200, "stored: MTLOAD command not available\n");
1106    berrno be;
1107    dev->dev_errno = ENOTTY;           /* function not available */
1108    Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1109          dev->print_name(), be.strerror());
1110    return false;
1111 #else
1112
1113    dev->block_num = dev->file = 0;
1114    dev->file_size = 0;
1115    dev->file_addr = 0;
1116    mt_com.mt_op = MTLOAD;
1117    mt_com.mt_count = 1;
1118    if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1119       berrno be;
1120       dev->dev_errno = errno;
1121       Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1122          dev->print_name(), be.strerror());
1123       return false;
1124    }
1125    return true;
1126 #endif
1127 }
1128
1129 /*
1130  * Rewind device and put it offline
1131  *  Returns: true  on success
1132  *           false on failure
1133  */
1134 bool DEVICE::offline()
1135 {
1136    struct mtop mt_com;
1137
1138    if (!is_tape()) {
1139       return true;                    /* device not open */
1140    }
1141
1142    state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
1143    block_num = file = 0;
1144    file_size = 0;
1145    file_addr = 0;
1146 #ifdef MTUNLOCK
1147    mt_com.mt_op = MTUNLOCK;
1148    mt_com.mt_count = 1;
1149    tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1150 #endif
1151    mt_com.mt_op = MTOFFL;
1152    mt_com.mt_count = 1;
1153    if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1154       berrno be;
1155       dev_errno = errno;
1156       Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1157          print_name(), be.strerror());
1158       return false;
1159    }
1160    Dmsg1(100, "Offlined device %s\n", print_name());
1161    return true;
1162 }
1163
1164 bool DEVICE::offline_or_rewind()
1165 {
1166    if (fd < 0) {
1167       return false;
1168    }
1169    if (has_cap(CAP_OFFLINEUNMOUNT)) {
1170       return offline();
1171    } else {
1172    /*
1173     * Note, this rewind probably should not be here (it wasn't
1174     *  in prior versions of Bacula), but on FreeBSD, this is
1175     *  needed in the case the tape was "frozen" due to an error
1176     *  such as backspacing after writing and EOF. If it is not
1177     *  done, all future references to the drive get and I/O error.
1178     */
1179       clrerror(MTREW);
1180       return rewind(NULL);
1181    }
1182 }
1183
1184 /*
1185  * Foward space a file
1186  *   Returns: true  on success
1187  *            false on failure
1188  */
1189 bool DEVICE::fsf(int num)
1190 {
1191    struct mtget mt_stat;
1192    struct mtop mt_com;
1193    int stat = 0;
1194
1195    if (!is_open()) {
1196       dev_errno = EBADF;
1197       Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1198       Emsg0(M_FATAL, 0, errmsg);
1199       return false;
1200    }
1201
1202    if (!is_tape()) {
1203       return true;
1204    }
1205
1206    if (at_eot()) {
1207       dev_errno = 0;
1208       Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1209       return false;
1210    }
1211    if (at_eof()) {
1212       Dmsg0(200, "ST_EOF set on entry to FSF\n");
1213    }
1214
1215    Dmsg0(100, "fsf\n");
1216    block_num = 0;
1217    /*
1218     * If Fast forward space file is set, then we
1219     *  use MTFSF to forward space and MTIOCGET
1220     *  to get the file position. We assume that
1221     *  the SCSI driver will ensure that we do not
1222     *  forward space past the end of the medium.
1223     */
1224    if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1225       mt_com.mt_op = MTFSF;
1226       mt_com.mt_count = num;
1227       stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1228       if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1229          berrno be;
1230          set_eot();
1231          Dmsg0(200, "Set ST_EOT\n");
1232          clrerror(MTFSF);
1233          Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1234             print_name(), be.strerror());
1235          Dmsg1(200, "%s", errmsg);
1236          return false;
1237       }
1238       Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1239       set_ateof();
1240       file = mt_stat.mt_fileno;
1241       return true;
1242
1243    /*
1244     * Here if CAP_FSF is set, and virtually all drives
1245     *  these days support it, we read a record, then forward
1246     *  space one file. Using this procedure, which is slow,
1247     *  is the only way we can be sure that we don't read
1248     *  two consecutive EOF marks, which means End of Data.
1249     */
1250    } else if (has_cap(CAP_FSF)) {
1251       POOLMEM *rbuf;
1252       int rbuf_len;
1253       Dmsg0(200, "FSF has cap_fsf\n");
1254       if (max_block_size == 0) {
1255          rbuf_len = DEFAULT_BLOCK_SIZE;
1256       } else {
1257          rbuf_len = max_block_size;
1258       }
1259       rbuf = get_memory(rbuf_len);
1260       mt_com.mt_op = MTFSF;
1261       mt_com.mt_count = 1;
1262       while (num-- && !at_eot()) {
1263          Dmsg0(100, "Doing read before fsf\n");
1264          if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1265             if (errno == ENOMEM) {     /* tape record exceeds buf len */
1266                stat = rbuf_len;        /* This is OK */
1267             /*
1268              * On IBM drives, they return ENOSPC at EOM
1269              *  instead of EOF status
1270              */
1271             } else if (at_eof() && errno == ENOSPC) {
1272                stat = 0;
1273             } else {
1274                berrno be;
1275                set_eot();
1276                clrerror(-1);
1277                Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1278                   be.strerror());
1279                Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1280                   print_name(), be.strerror());
1281                Dmsg1(100, "%s", errmsg);
1282                break;
1283             }
1284          }
1285          if (stat == 0) {                /* EOF */
1286             Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1287             /* Two reads of zero means end of tape */
1288             if (at_eof()) {
1289                set_eot();
1290                Dmsg0(100, "Set ST_EOT\n");
1291                break;
1292             } else {
1293                set_ateof();
1294                continue;
1295             }
1296          } else {                        /* Got data */
1297             clear_eot();
1298             clear_eof();
1299          }
1300
1301          Dmsg0(100, "Doing MTFSF\n");
1302          stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1303          if (stat < 0) {                 /* error => EOT */
1304             berrno be;
1305             set_eot();
1306             Dmsg0(100, "Set ST_EOT\n");
1307             clrerror(MTFSF);
1308             Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1309                print_name(), be.strerror());
1310             Dmsg0(100, "Got < 0 for MTFSF\n");
1311             Dmsg1(100, "%s", errmsg);
1312          } else {
1313             set_ateof();
1314          }
1315       }
1316       free_memory(rbuf);
1317
1318    /*
1319     * No FSF, so use FSR to simulate it
1320     */
1321    } else {
1322       Dmsg0(200, "Doing FSR for FSF\n");
1323       while (num-- && !at_eot()) {
1324          fsr(INT32_MAX);    /* returns -1 on EOF or EOT */
1325       }
1326       if (at_eot()) {
1327          dev_errno = 0;
1328          Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1329          stat = -1;
1330       } else {
1331          stat = 0;
1332       }
1333    }
1334    Dmsg1(200, "Return %d from FSF\n", stat);
1335    if (at_eof()) {
1336       Dmsg0(200, "ST_EOF set on exit FSF\n");
1337    }
1338    if (at_eot()) {
1339       Dmsg0(200, "ST_EOT set on exit FSF\n");
1340    }
1341    Dmsg1(200, "Return from FSF file=%d\n", file);
1342    return stat == 0;
1343 }
1344
1345 /*
1346  * Backward space a file
1347  *  Returns: false on failure
1348  *           true  on success
1349  */
1350 bool DEVICE::bsf(int num)
1351 {
1352    struct mtop mt_com;
1353    int stat;
1354
1355    if (!is_open()) {
1356       dev_errno = EBADF;
1357       Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1358       Emsg0(M_FATAL, 0, errmsg);
1359       return false;
1360    }
1361
1362    if (!is_tape()) {
1363       Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1364          print_name());
1365       return false;
1366    }
1367
1368    Dmsg0(29, "bsf\n");
1369    clear_eot();
1370    clear_eof();
1371    file -= num;
1372    file_addr = 0;
1373    file_size = 0;
1374    mt_com.mt_op = MTBSF;
1375    mt_com.mt_count = num;
1376    stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1377    if (stat < 0) {
1378       berrno be;
1379       clrerror(MTBSF);
1380       Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1381          print_name(), be.strerror());
1382    }
1383    return stat == 0;
1384 }
1385
1386
1387 /*
1388  * Foward space num records
1389  *  Returns: false on failure
1390  *           true  on success
1391  */
1392 bool DEVICE::fsr(int num)
1393 {
1394    struct mtop mt_com;
1395    int stat;
1396
1397    if (!is_open()) {
1398       dev_errno = EBADF;
1399       Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1400       Emsg0(M_FATAL, 0, errmsg);
1401       return false;
1402    }
1403
1404    if (!is_tape()) {
1405       return false;
1406    }
1407
1408    if (!has_cap(CAP_FSR)) {
1409       Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1410       return false;
1411    }
1412
1413    Dmsg1(29, "fsr %d\n", num);
1414    mt_com.mt_op = MTFSR;
1415    mt_com.mt_count = num;
1416    stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1417    if (stat == 0) {
1418       clear_eof();
1419       block_num += num;
1420    } else {
1421       berrno be;
1422       struct mtget mt_stat;
1423       clrerror(MTFSR);
1424       Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1425       if (dev_get_os_pos(this, &mt_stat)) {
1426          Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1427             block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1428          file = mt_stat.mt_fileno;
1429          block_num = mt_stat.mt_blkno;
1430       } else {
1431          if (at_eof()) {
1432             set_eot();
1433          } else {
1434             set_ateof();
1435          }
1436       }
1437       Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1438          num, print_name(), be.strerror());
1439    }
1440    return stat == 0;
1441 }
1442
1443 /*
1444  * Backward space a record
1445  *   Returns:  false on failure
1446  *             true  on success
1447  */
1448 bool DEVICE::bsr(int num)
1449 {
1450    struct mtop mt_com;
1451    int stat;
1452
1453    if (!is_open()) {
1454       dev_errno = EBADF;
1455       Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1456       Emsg0(M_FATAL, 0, errmsg);
1457       return false;
1458    }
1459
1460    if (!is_tape()) {
1461       return false;
1462    }
1463
1464    if (!has_cap(CAP_BSR)) {
1465       Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1466       return false;
1467    }
1468
1469    Dmsg0(29, "bsr_dev\n");
1470    block_num -= num;
1471    clear_eof();
1472    clear_eot();
1473    mt_com.mt_op = MTBSR;
1474    mt_com.mt_count = num;
1475    stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1476    if (stat < 0) {
1477       berrno be;
1478       clrerror(MTBSR);
1479       Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1480          print_name(), be.strerror());
1481    }
1482    return stat == 0;
1483 }
1484
1485 /*
1486  * Reposition the device to file, block
1487  * Returns: false on failure
1488  *          true  on success
1489  */
1490 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1491 {
1492    if (!is_open()) {
1493       dev_errno = EBADF;
1494       Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1495       Emsg0(M_FATAL, 0, errmsg);
1496       return false;
1497    }
1498
1499    if (!is_tape()) {
1500       off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1501       Dmsg1(100, "===== lseek to %d\n", (int)pos);
1502       if (lseek(dcr, pos, SEEK_SET) == (off_t)-1) {
1503          berrno be;
1504          dev_errno = errno;
1505          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1506             print_name(), be.strerror());
1507          return false;
1508       }
1509       file = rfile;
1510       block_num = rblock;
1511       file_addr = pos;
1512       return true;
1513    }
1514
1515    /* After this point, we are tape only */
1516    Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1517       file, block_num, rfile, rblock);
1518    if (rfile < file) {
1519       Dmsg0(100, "Rewind\n");
1520       if (!rewind(NULL)) {
1521          return false;
1522       }
1523    }
1524    if (rfile > file) {
1525       Dmsg1(100, "fsf %d\n", rfile-file);
1526       if (!fsf(rfile-file)) {
1527          Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1528          return false;
1529       }
1530       Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1531    }
1532    if (rblock < block_num) {
1533       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1534       Dmsg0(100, "bsf 1\n");
1535       bsf(1);
1536       Dmsg0(100, "fsf 1\n");
1537       fsf(1);
1538       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1539    }
1540    if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1541       /* Ignore errors as Bacula can read to the correct block */
1542       Dmsg1(100, "fsr %d\n", rblock-block_num);
1543       return fsr(rblock-block_num);
1544    }
1545    return true;
1546 }
1547
1548
1549
1550 /*
1551  * Write an end of file on the device
1552  *   Returns: true on success
1553  *            false on failure
1554  */
1555 bool DEVICE::weof(int num)
1556 {
1557    struct mtop mt_com;
1558    int stat;
1559    Dmsg0(129, "weof_dev\n");
1560
1561    if (!is_open()) {
1562       dev_errno = EBADF;
1563       Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1564       Emsg0(M_FATAL, 0, errmsg);
1565       return false;
1566    }
1567    file_size = 0;
1568
1569    if (!is_tape()) {
1570       return true;
1571    }
1572    if (!can_append()) {
1573       Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1574       Emsg0(M_FATAL, 0, errmsg);
1575       return false;
1576    }
1577
1578    clear_eof();
1579    clear_eot();
1580    mt_com.mt_op = MTWEOF;
1581    mt_com.mt_count = num;
1582    stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1583    if (stat == 0) {
1584       block_num = 0;
1585       file += num;
1586       file_addr = 0;
1587    } else {
1588       berrno be;
1589       clrerror(MTWEOF);
1590       if (stat == -1) {
1591          Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1592             print_name(), be.strerror());
1593        }
1594    }
1595    return stat == 0;
1596 }
1597
1598
1599 /*
1600  * If implemented in system, clear the tape
1601  * error status.
1602  */
1603 void DEVICE::clrerror(int func)
1604 {
1605    const char *msg = NULL;
1606    struct mtget mt_stat;
1607    char buf[100];
1608
1609    dev_errno = errno;         /* save errno */
1610    if (errno == EIO) {
1611       VolCatInfo.VolCatErrors++;
1612    }
1613
1614    if (!is_tape()) {
1615       return;
1616    }
1617
1618    if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1619       switch (func) {
1620       case -1:
1621          break;              /* ignore message printed later */
1622       case MTWEOF:
1623          msg = "WTWEOF";
1624          capabilities &= ~CAP_EOF; /* turn off feature */
1625          break;
1626 #ifdef MTEOM
1627       case MTEOM:
1628          msg = "WTEOM";
1629          capabilities &= ~CAP_EOM; /* turn off feature */
1630          break;
1631 #endif
1632       case MTFSF:
1633          msg = "MTFSF";
1634          capabilities &= ~CAP_FSF; /* turn off feature */
1635          break;
1636       case MTBSF:
1637          msg = "MTBSF";
1638          capabilities &= ~CAP_BSF; /* turn off feature */
1639          break;
1640       case MTFSR:
1641          msg = "MTFSR";
1642          capabilities &= ~CAP_FSR; /* turn off feature */
1643          break;
1644       case MTBSR:
1645          msg = "MTBSR";
1646          capabilities &= ~CAP_BSR; /* turn off feature */
1647          break;
1648       case MTREW:
1649          msg = "MTREW";
1650          break;
1651 #ifdef MTSETBLK
1652       case MTSETBLK:
1653          msg = "MTSETBLK";
1654          break;
1655 #endif
1656 #ifdef MTSETDRVBUFFER
1657       case MTSETDRVBUFFER:
1658          msg = "MTSETDRVBUFFER";
1659          break;
1660 #endif
1661 #ifdef MTRESET
1662       case MTRESET:
1663          msg = "MTRESET";
1664          break;
1665 #endif
1666
1667 #ifdef MTSETBSIZ
1668       case MTSETBSIZ:
1669          msg = "MTSETBSIZ";
1670          break;
1671 #endif
1672 #ifdef MTSRSZ
1673       case MTSRSZ:
1674          msg = "MTSRSZ";
1675          break;
1676 #endif
1677 #ifdef MTLOAD
1678       case MTLOAD:
1679          msg = "MTLOAD";
1680          break;
1681 #endif
1682 #ifdef MTUNLOCK
1683       case MTUNLOCK:
1684          msg = "MTUNLOCK";
1685          break;
1686 #endif
1687       case MTOFFL:
1688          msg = "MTOFFL";
1689          break;
1690       default:
1691          bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1692          msg = buf;
1693          break;
1694       }
1695       if (msg != NULL) {
1696          dev_errno = ENOSYS;
1697          Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1698          Emsg0(M_ERROR, 0, errmsg);
1699       }
1700    }
1701
1702    /*
1703     * Now we try different methods of clearing the error
1704     *  status on the drive so that it is not locked for
1705     *  further operations.
1706     */
1707
1708    /* On some systems such as NetBSD, this clears all errors */
1709    tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1710
1711 /* Found on Linux */
1712 #ifdef MTIOCLRERR
1713 {
1714    struct mtop mt_com;
1715    mt_com.mt_op = MTIOCLRERR;
1716    mt_com.mt_count = 1;
1717    /* Clear any error condition on the tape */
1718    tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1719    Dmsg0(200, "Did MTIOCLRERR\n");
1720 }
1721 #endif
1722
1723 /* Typically on FreeBSD */
1724 #ifdef MTIOCERRSTAT
1725 {
1726   berrno be;
1727    /* Read and clear SCSI error status */
1728    union mterrstat mt_errstat;
1729    Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1730       be.strerror(dev_errno));
1731    tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1732 }
1733 #endif
1734
1735 /* Clear Subsystem Exception OSF1 */
1736 #ifdef MTCSE
1737 {
1738    struct mtop mt_com;
1739    mt_com.mt_op = MTCSE;
1740    mt_com.mt_count = 1;
1741    /* Clear any error condition on the tape */
1742    tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1743    Dmsg0(200, "Did MTCSE\n");
1744 }
1745 #endif
1746 }
1747
1748 /*
1749  * Close the device
1750  */
1751 void DEVICE::close()
1752 {
1753    Dmsg1(100, "close_dev %s\n", print_name());
1754    if (has_cap(CAP_OFFLINEUNMOUNT)) {
1755       offline();
1756    }
1757
1758    if (is_open()) {
1759       if (is_tape()) {
1760          tape_close(fd);
1761       } else {
1762          ::close(fd);
1763       }
1764    } else {
1765       Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1766          VolHdr.VolumeName);
1767       return;                         /* already closed */
1768    }
1769
1770    /* Clean up device packet so it can be reused */
1771    clear_opened();
1772    state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1773    label_type = B_BACULA_LABEL;
1774    file = block_num = 0;
1775    file_size = 0;
1776    file_addr = 0;
1777    EndFile = EndBlock = 0;
1778    Slot = -1;             /* unknown slot */
1779    free_volume(this);
1780    memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1781    memset(&VolHdr, 0, sizeof(VolHdr));
1782    if (tid) {
1783       stop_thread_timer(tid);
1784       tid = 0;
1785    }
1786    openmode = 0;
1787 }
1788
1789 /*
1790  * This call closes the device, but it is used in DVD handling
1791  *  where we close one part and then open the next part. The
1792  *  difference between close_part() and close() is that close_part()
1793  *  saves the state information of the device (e.g. the Volume lable,
1794  *  the Volume Catalog record, ...  This permits opening and closing
1795  *  the Volume parts multiple times without losing track of what the
1796  *  main Volume parameters are.
1797  */
1798 void DEVICE::close_part(DCR *dcr)
1799 {
1800    VOLUME_LABEL saveVolHdr;
1801    VOLUME_CAT_INFO saveVolCatInfo;     /* Volume Catalog Information */
1802
1803
1804    memcpy(&saveVolHdr, &VolHdr, sizeof(saveVolHdr));
1805    memcpy(&saveVolCatInfo, &VolCatInfo, sizeof(saveVolCatInfo));
1806    close();                           /* close current part */
1807    memcpy(&VolHdr, &saveVolHdr, sizeof(VolHdr));
1808    memcpy(&VolCatInfo, &saveVolCatInfo, sizeof(VolCatInfo));
1809    memcpy(&dcr->VolCatInfo, &saveVolCatInfo, sizeof(dcr->VolCatInfo));
1810 }
1811
1812 off_t DEVICE::lseek(DCR *dcr, off_t offset, int whence)
1813 {
1814    switch (dev_type) {
1815    case B_DVD_DEV:
1816       return lseek_dvd(dcr, offset, whence);
1817    case B_FILE_DEV:
1818       return ::lseek(fd, offset, whence);
1819    }
1820    return -1;
1821 }
1822
1823
1824 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1825 {
1826    Dmsg1(100, "truncate %s\n", print_name());
1827    switch (dev_type) {
1828    case B_TAPE_DEV:
1829       /* maybe we should rewind and write and eof ???? */
1830       return true;                    /* we don't really truncate tapes */
1831    case B_DVD_DEV:
1832       return truncate_dvd(dcr);
1833    case B_FILE_DEV:
1834       /* ***FIXME*** we really need to unlink() the file so that
1835        *  its name can be changed for a relabel.
1836        */
1837       if (ftruncate(fd, 0) != 0) {
1838          berrno be;
1839          Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1840                print_name(), be.strerror());
1841          return false;
1842       }
1843       return true;
1844    }
1845    return false;
1846 }
1847
1848 /* Mount the device.
1849  * If timeout, wait until the mount command returns 0.
1850  * If !timeout, try to mount the device only once.
1851  */
1852 bool DEVICE::mount(int timeout)
1853 {
1854    Dmsg0(190, "Enter mount\n");
1855    if (is_mounted()) {
1856       return true;
1857    } else if (requires_mount()) {
1858       return do_mount(1, timeout);
1859    }
1860    return true;
1861 }
1862
1863 /* Unmount the device
1864  * If timeout, wait until the unmount command returns 0.
1865  * If !timeout, try to unmount the device only once.
1866  */
1867 bool DEVICE::unmount(int timeout)
1868 {
1869    Dmsg0(90, "Enter unmount_dvd\n");
1870    if (is_mounted()) {
1871       return do_mount(0, timeout);
1872    }
1873    return true;
1874 }
1875
1876 /* (Un)mount the device */
1877 bool DEVICE::do_mount(int mount, int dotimeout)
1878 {
1879    POOL_MEM ocmd(PM_FNAME);
1880    POOLMEM *results;
1881    char *icmd;
1882    int status, timeout;
1883
1884    sm_check(__FILE__, __LINE__, false);
1885    if (mount) {
1886       if (is_mounted()) {
1887          Dmsg0(200, "======= mount=1\n");
1888          return true;
1889       }
1890       icmd = device->mount_command;
1891    } else {
1892       if (!is_mounted()) {
1893          Dmsg0(200, "======= mount=0\n");
1894          return true;
1895       }
1896       icmd = device->unmount_command;
1897    }
1898
1899    edit_mount_codes(ocmd, icmd);
1900
1901    Dmsg2(100, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1902
1903    if (dotimeout) {
1904       /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1905       timeout = 1;
1906    } else {
1907       timeout = 0;
1908    }
1909    results = get_memory(2000);
1910    results[0] = 0;
1911
1912    /* If busy retry each second */
1913    Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
1914    while ((status = run_program_full_output(ocmd.c_str(),
1915                        max_open_wait/2, results)) != 0) {
1916       /* Doesn't work with internationalization (This is not a problem) */
1917       if (fnmatch("*is already mounted on", results, 0) == 0) {
1918          break;
1919       }
1920       if (timeout-- > 0) {
1921          /* Sometimes the device cannot be mounted because it is already mounted.
1922           * Try to unmount it, then remount it */
1923          if (mount) {
1924             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1925             do_mount(0, 0);
1926          }
1927          bmicrosleep(1, 0);
1928          continue;
1929       }
1930       Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1931       Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1932            print_name(), results);
1933       /*
1934        * Now, just to be sure it is not mounted, try to read the
1935        *  filesystem.
1936        */
1937       DIR* dp;
1938       struct dirent *entry, *result;
1939       int name_max;
1940       int count;
1941
1942       name_max = pathconf(".", _PC_NAME_MAX);
1943       if (name_max < 1024) {
1944          name_max = 1024;
1945       }
1946
1947       if (!(dp = opendir(device->mount_point))) {
1948          berrno be;
1949          dev_errno = errno;
1950          Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1951                device->mount_point, print_name(), be.strerror());
1952          goto get_out;
1953       }
1954
1955       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1956       count = 0;
1957       while (1) {
1958          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1959             dev_errno = EIO;
1960             Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1961                   device->mount_point, print_name());
1962             break;
1963          }
1964          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1965             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1966             break;
1967          } else {
1968             Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1969          }
1970       }
1971       free(entry);
1972       closedir(dp);
1973
1974       Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1975
1976       if (count > 0) {
1977          mount = 1;                      /* If we got more than ., .. and .keep */
1978          break;                          /*   there must be something mounted */
1979       }
1980 get_out:
1981       set_mounted(false);
1982       sm_check(__FILE__, __LINE__, false);
1983       free_pool_memory(results);
1984       Dmsg0(200, "============ mount=0\n");
1985       return false;
1986    }
1987
1988    set_mounted(mount);              /* set/clear mounted flag */
1989    free_pool_memory(results);
1990    Dmsg1(200, "============ mount=%d\n", mount);
1991    return true;
1992 }
1993
1994 /*
1995  * Edit codes into (Un)MountCommand, Write(First)PartCommand
1996  *  %% = %
1997  *  %a = archive device name
1998  *  %e = erase (set if cannot mount and first part)
1999  *  %n = part number
2000  *  %m = mount point
2001  *  %v = last part name
2002  *
2003  *  omsg = edited output message
2004  *  imsg = input string containing edit codes (%x)
2005  *
2006  */
2007 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2008 {
2009    const char *p;
2010    const char *str;
2011    char add[20];
2012
2013    POOL_MEM archive_name(PM_FNAME);
2014
2015    omsg.c_str()[0] = 0;
2016    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2017    for (p=imsg; *p; p++) {
2018       if (*p == '%') {
2019          switch (*++p) {
2020          case '%':
2021             str = "%";
2022             break;
2023          case 'a':
2024             str = dev_name;
2025             break;
2026          case 'e':
2027             if (num_dvd_parts == 0) {
2028                if (truncating || blank_dvd) {
2029                   str = "2";
2030                } else {
2031                   str = "1";
2032                }
2033             } else {
2034                str = "0";
2035             }
2036             break;
2037          case 'n':
2038             bsnprintf(add, sizeof(add), "%d", part);
2039             str = add;
2040             break;
2041          case 'm':
2042             str = device->mount_point;
2043             break;
2044          case 'v':
2045             make_spooled_dvd_filename(this, archive_name);
2046             str = archive_name.c_str();
2047             break;
2048          default:
2049             add[0] = '%';
2050             add[1] = *p;
2051             add[2] = 0;
2052             str = add;
2053             break;
2054          }
2055       } else {
2056          add[0] = *p;
2057          add[1] = 0;
2058          str = add;
2059       }
2060       Dmsg1(1900, "add_str %s\n", str);
2061       pm_strcat(omsg, (char *)str);
2062       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2063    }
2064 }
2065
2066
2067 /* Return the resource name for the device */
2068 const char *DEVICE::name() const
2069 {
2070    return device->hdr.name;
2071 }
2072
2073 char *
2074 dev_vol_name(DEVICE *dev)
2075 {
2076    return dev->VolCatInfo.VolCatName;
2077 }
2078
2079
2080 /*
2081  * Free memory allocated for the device
2082  */
2083 void DEVICE::term(void)
2084 {
2085    Dmsg1(900, "term dev: %s\n", print_name());
2086    close();
2087    if (dev_name) {
2088       free_memory(dev_name);
2089       dev_name = NULL;
2090    }
2091    if (prt_name) {
2092       free_memory(prt_name);
2093       prt_name = NULL;
2094    }
2095    if (errmsg) {
2096       free_pool_memory(errmsg);
2097       errmsg = NULL;
2098    }
2099    pthread_mutex_destroy(&mutex);
2100    pthread_cond_destroy(&wait);
2101    pthread_cond_destroy(&wait_next_vol);
2102    pthread_mutex_destroy(&spool_mutex);
2103    rwl_destroy(&lock);
2104    if (attached_dcrs) {
2105       delete attached_dcrs;
2106       attached_dcrs = NULL;
2107    }
2108    if (device) {
2109       device->dev = NULL;
2110    }
2111    free((char *)this);
2112 }
2113
2114 /*
2115  * This routine initializes the device wait timers
2116  */
2117 void init_device_wait_timers(DCR *dcr)
2118 {
2119    DEVICE *dev = dcr->dev;
2120    JCR *jcr = dcr->jcr;
2121
2122    /* ******FIXME******* put these on config variables */
2123    dev->min_wait = 60 * 60;
2124    dev->max_wait = 24 * 60 * 60;
2125    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2126    dev->wait_sec = dev->min_wait;
2127    dev->rem_wait_sec = dev->wait_sec;
2128    dev->num_wait = 0;
2129    dev->poll = false;
2130    dev->BadVolName[0] = 0;
2131
2132    jcr->min_wait = 60 * 60;
2133    jcr->max_wait = 24 * 60 * 60;
2134    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2135    jcr->wait_sec = jcr->min_wait;
2136    jcr->rem_wait_sec = jcr->wait_sec;
2137    jcr->num_wait = 0;
2138
2139 }
2140
2141 void init_jcr_device_wait_timers(JCR *jcr)
2142 {
2143    /* ******FIXME******* put these on config variables */
2144    jcr->min_wait = 60 * 60;
2145    jcr->max_wait = 24 * 60 * 60;
2146    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2147    jcr->wait_sec = jcr->min_wait;
2148    jcr->rem_wait_sec = jcr->wait_sec;
2149    jcr->num_wait = 0;
2150 }
2151
2152
2153 /*
2154  * The dev timers are used for waiting on a particular device
2155  *
2156  * Returns: true if time doubled
2157  *          false if max time expired
2158  */
2159 bool double_dev_wait_time(DEVICE *dev)
2160 {
2161    dev->wait_sec *= 2;               /* double wait time */
2162    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2163       dev->wait_sec = dev->max_wait;
2164    }
2165    dev->num_wait++;
2166    dev->rem_wait_sec = dev->wait_sec;
2167    if (dev->num_wait >= dev->max_num_wait) {
2168       return false;
2169    }
2170    return true;
2171 }
2172
2173
2174 void set_os_device_parameters(DEVICE *dev)
2175 {
2176 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2177    struct mtop mt_com;
2178
2179 #if defined(MTRESET)
2180    mt_com.mt_op = MTRESET;
2181    mt_com.mt_count = 0;
2182    if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2183       dev->clrerror(MTRESET);
2184    }
2185 #endif
2186 #if defined(MTSETBLK)
2187    if (dev->min_block_size == dev->max_block_size &&
2188        dev->min_block_size == 0) {    /* variable block mode */
2189       mt_com.mt_op = MTSETBLK;
2190       mt_com.mt_count = 0;
2191       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2192          dev->clrerror(MTSETBLK);
2193       }
2194       Dmsg0(100, "Set block size to 0\n");
2195    }
2196 #endif
2197 #if defined(MTSETDRVBUFFER)
2198    if (getpid() == 0) {          /* Only root can do this */
2199       mt_com.mt_op = MTSETDRVBUFFER;
2200       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2201       if (!dev->has_cap(CAP_TWOEOF)) {
2202          mt_com.mt_count |= MT_ST_TWO_FM;
2203       }
2204       if (dev->has_cap(CAP_EOM)) {
2205          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2206       }
2207       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2208          dev->clrerror(MTSETDRVBUFFER);
2209       }
2210    }
2211 #endif
2212    return;
2213 #endif
2214
2215 #ifdef HAVE_NETBSD_OS
2216    struct mtop mt_com;
2217    if (dev->min_block_size == dev->max_block_size &&
2218        dev->min_block_size == 0) {    /* variable block mode */
2219       mt_com.mt_op = MTSETBSIZ;
2220       mt_com.mt_count = 0;
2221       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2222          dev->clrerror(MTSETBSIZ);
2223       }
2224       /* Get notified at logical end of tape */
2225       mt_com.mt_op = MTEWARN;
2226       mt_com.mt_count = 1;
2227       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2228          dev->clrerror(MTEWARN);
2229       }
2230    }
2231    return;
2232 #endif
2233
2234 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2235    struct mtop mt_com;
2236    if (dev->min_block_size == dev->max_block_size &&
2237        dev->min_block_size == 0) {    /* variable block mode */
2238       mt_com.mt_op = MTSETBSIZ;
2239       mt_com.mt_count = 0;
2240       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2241          dev->clrerror(MTSETBSIZ);
2242       }
2243    }
2244    return;
2245 #endif
2246
2247 #ifdef HAVE_SUN_OS
2248    struct mtop mt_com;
2249    if (dev->min_block_size == dev->max_block_size &&
2250        dev->min_block_size == 0) {    /* variable block mode */
2251       mt_com.mt_op = MTSRSZ;
2252       mt_com.mt_count = 0;
2253       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2254          dev->clrerror(MTSRSZ);
2255       }
2256    }
2257    return;
2258 #endif
2259 }
2260
2261 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2262 {
2263    return dev->has_cap(CAP_MTIOCGET) &&
2264           tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2265           mt_stat->mt_fileno >= 0;
2266 }
2267
2268 static char *modes[] = {
2269    "CREATE_READ_WRITE",
2270    "OPEN_READ_WRITE",
2271    "OPEN_READ_ONLY",
2272    "OPEN_WRITE_ONLY"
2273 };
2274
2275
2276 static char *mode_to_str(int mode)
2277 {
2278    static char buf[100];
2279    if (mode < 1 || mode > 4) {
2280       bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2281       return buf;
2282     }
2283    return modes[mode-1];
2284 }