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