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