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 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_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 #ifdef needed
 531          /*
 532           * If we can mount the device, and we are not truncating the DVD,
 533           * we usually want to abort. There is one exception, if there is
 534           * only one 0-sized file on the DVD, with the right volume name,
 535           * we continue (it's the method used by truncate_dvd to truncate a volume).
 536           */
 537          if (!check_can_write_on_non_blank_dvd(dcr)) {
 538             Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
 539             Emsg0(M_FATAL, 0, errmsg);
 540             unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
 541             clear_opened();
 542             return;
 543          }
 544 #endif
 545          truncated_dvd = true;
 546       }
 547    } else {
 548       Dmsg0(99, "DVD device mount failed.\n");
 549       /* We cannot mount the device */
 550       if (num_dvd_parts == 0) {
 551          /* Run free space, check there is a media. */
 552          if (!update_free_space_dev(this)) {
 553             Emsg0(M_FATAL, 0, errmsg);
 554             clear_opened();
 555             return;
 556          }
 557          if (have_media()) {
 558             Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
 559          } else {
 560             Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
 561             Emsg0(M_FATAL, 0, errmsg);
 562             clear_opened();
 563             return;
 564          }
 565       }  else {
 566          Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
 567          Emsg0(M_FATAL, 0, errmsg);
 568          clear_opened();
 569          return;
 570       }
 571    }
 572
 573    Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
 574       archive_name.c_str(), mode_to_str(omode),
 575       part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
 576    openmode = omode;
 577    Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
 578
 579    /*
 580     * If we are not trying to access the last part, set mode to
 581     *   OPEN_READ_ONLY as writing would be an error.
 582     */
 583    Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
 584    if (part <= num_dvd_parts) {
 585       omode = OPEN_READ_ONLY;
 586       make_mounted_dvd_filename(this, archive_name);
 587    } else {
 588       omode = OPEN_READ_WRITE;
 589       make_spooled_dvd_filename(this, archive_name);
 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    if (fd < 0) {
 657       if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
 658          dev_errno = EBADF;
 659          Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
 660             print_name());
 661          Emsg0(M_ABORT, 0, errmsg);
 662       }
 663       return false;
 664    }
 665    state &= ~(ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
 666    block_num = file = 0;
 667    file_size = 0;
 668    file_addr = 0;
 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       int part_save = part;
1784       POOL_MEM archive_name(PM_FNAME);
1785
1786       part = num_dvd_parts;
1787       Dmsg3(100, "Remove empty part in close call make_dvd_filename. part=%d num=%d vol=%s\n",
1788          part, num_dvd_parts, VolCatInfo.VolCatName);
1789       make_spooled_dvd_filename(this, archive_name);
1790       /* Check that the part file is empty */
1791       if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1792          Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1793          unlink(archive_name.c_str());
1794       }
1795       part = part_save;               /* restore part number */
1796    }
1797
1798    /* Clean up device packet so it can be reused */
1799    clear_opened();
1800    state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1801    label_type = B_BACULA_LABEL;
1802    file = block_num = 0;
1803    file_size = 0;
1804    file_addr = 0;
1805    EndFile = EndBlock = 0;
1806    Slot = -1;             /* unknown slot */
1807    free_volume(this);
1808    memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1809    memset(&VolHdr, 0, sizeof(VolHdr));
1810    if (tid) {
1811       stop_thread_timer(tid);
1812       tid = 0;
1813    }
1814    openmode = 0;
1815 }
1816
1817
1818
1819 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1820 {
1821    Dmsg1(100, "truncate_dev %s\n", print_name());
1822    if (is_tape()) {
1823       return true;                    /* we don't really truncate tapes */
1824       /* maybe we should rewind and write and eof ???? */
1825    }
1826
1827    if (is_dvd()) {
1828       return truncate_dvd(dcr);
1829    }
1830
1831    if (ftruncate(fd, 0) != 0) {
1832       berrno be;
1833       Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1834             print_name(), be.strerror());
1835       return false;
1836    }
1837    return true;
1838 }
1839
1840 /* Mount the device.
1841  * If timeout, wait until the mount command returns 0.
1842  * If !timeout, try to mount the device only once.
1843  */
1844 bool DEVICE::mount(int timeout)
1845 {
1846    Dmsg0(190, "Enter mount\n");
1847    if (is_mounted()) {
1848       return true;
1849    } else if (requires_mount()) {
1850       return do_mount(1, timeout);
1851    }
1852    return true;
1853 }
1854
1855 /* Unmount the device
1856  * If timeout, wait until the unmount command returns 0.
1857  * If !timeout, try to unmount the device only once.
1858  */
1859 bool DEVICE::unmount(int timeout)
1860 {
1861    Dmsg0(90, "Enter unmount_dvd\n");
1862    if (is_mounted()) {
1863       return do_mount(0, timeout);
1864    }
1865    return true;
1866 }
1867
1868 /* (Un)mount the device */
1869 bool DEVICE::do_mount(int mount, int dotimeout)
1870 {
1871    POOL_MEM ocmd(PM_FNAME);
1872    POOLMEM *results;
1873    char *icmd;
1874    int status, timeout;
1875
1876    sm_check(__FILE__, __LINE__, false);
1877    if (mount) {
1878       if (is_mounted()) {
1879          Dmsg0(200, "======= mount=1\n");
1880          return true;
1881       }
1882       icmd = device->mount_command;
1883    } else {
1884       if (!is_mounted()) {
1885          Dmsg0(200, "======= mount=0\n");
1886          return true;
1887       }
1888       icmd = device->unmount_command;
1889    }
1890
1891    edit_mount_codes(ocmd, icmd);
1892
1893    Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1894
1895    if (dotimeout) {
1896       /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1897       timeout = 1;
1898    } else {
1899       timeout = 0;
1900    }
1901    results = get_memory(2000);
1902    results[0] = 0;
1903    /* If busy retry each second */
1904    while ((status = run_program_full_output(ocmd.c_str(),
1905                        max_open_wait/2, results)) != 0) {
1906       /* Doesn't work with internationalisation (This is not a problem) */
1907       if (fnmatch("*is already mounted on", results, 0) == 0) {
1908          break;
1909       }
1910       if (timeout-- > 0) {
1911          /* Sometimes the device cannot be mounted because it is already mounted.
1912           * Try to unmount it, then remount it */
1913          if (mount) {
1914             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1915             do_mount(0, 0);
1916          }
1917          bmicrosleep(1, 0);
1918          continue;
1919       }
1920       Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1921       Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1922            print_name(), results);
1923       /*
1924        * Now, just to be sure it is not mounted, try to read the
1925        *  filesystem.
1926        */
1927       DIR* dp;
1928       struct dirent *entry, *result;
1929       int name_max;
1930       int count;
1931
1932       name_max = pathconf(".", _PC_NAME_MAX);
1933       if (name_max < 1024) {
1934          name_max = 1024;
1935       }
1936
1937       if (!(dp = opendir(device->mount_point))) {
1938          berrno be;
1939          dev_errno = errno;
1940          Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1941                device->mount_point, print_name(), be.strerror());
1942          goto get_out;
1943       }
1944
1945       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1946       count = 0;
1947       while (1) {
1948          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1949             dev_errno = EIO;
1950             Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1951                   device->mount_point, print_name());
1952             break;
1953          }
1954          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1955             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1956             break;
1957          } else {
1958             Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1959          }
1960       }
1961       free(entry);
1962       closedir(dp);
1963
1964       Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1965
1966       if (count > 0) {
1967          mount = 1;                      /* If we got more than ., .. and .keep */
1968          break;                          /*   there must be something mounted */
1969       }
1970 get_out:
1971       set_mounted(false);
1972       sm_check(__FILE__, __LINE__, false);
1973       free_pool_memory(results);
1974       Dmsg0(200, "============ mount=0\n");
1975       return false;
1976    }
1977
1978    set_mounted(mount);              /* set/clear mounted flag */
1979    free_pool_memory(results);
1980    Dmsg1(200, "============ mount=%d\n", mount);
1981    return true;
1982 }
1983
1984 /*
1985  * Edit codes into (Un)MountCommand, Write(First)PartCommand
1986  *  %% = %
1987  *  %a = archive device name
1988  *  %e = erase (set if cannot mount and first part)
1989  *  %n = part number
1990  *  %m = mount point
1991  *  %v = last part name
1992  *
1993  *  omsg = edited output message
1994  *  imsg = input string containing edit codes (%x)
1995  *
1996  */
1997 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1998 {
1999    const char *p;
2000    const char *str;
2001    char add[20];
2002
2003    POOL_MEM archive_name(PM_FNAME);
2004
2005    omsg.c_str()[0] = 0;
2006    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2007    for (p=imsg; *p; p++) {
2008       if (*p == '%') {
2009          switch (*++p) {
2010          case '%':
2011             str = "%";
2012             break;
2013          case 'a':
2014             str = dev_name;
2015             break;
2016          case 'e':
2017             if (num_dvd_parts == 0) {
2018                if (truncating || truncated_dvd) {
2019                   str = "2";
2020                } else {
2021                   str = "1";
2022                }
2023             } else {
2024                str = "0";
2025             }
2026             break;
2027          case 'n':
2028             bsnprintf(add, sizeof(add), "%d", part);
2029             str = add;
2030             break;
2031          case 'm':
2032             str = device->mount_point;
2033             break;
2034          case 'v':
2035             make_spooled_dvd_filename(this, archive_name);
2036             str = archive_name.c_str();
2037             break;
2038          default:
2039             add[0] = '%';
2040             add[1] = *p;
2041             add[2] = 0;
2042             str = add;
2043             break;
2044          }
2045       } else {
2046          add[0] = *p;
2047          add[1] = 0;
2048          str = add;
2049       }
2050       Dmsg1(1900, "add_str %s\n", str);
2051       pm_strcat(omsg, (char *)str);
2052       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2053    }
2054 }
2055
2056
2057 /* Return the resource name for the device */
2058 const char *DEVICE::name() const
2059 {
2060    return device->hdr.name;
2061 }
2062
2063 char *
2064 dev_vol_name(DEVICE *dev)
2065 {
2066    return dev->VolCatInfo.VolCatName;
2067 }
2068
2069 uint32_t dev_block(DEVICE *dev)
2070 {
2071    update_pos_dev(dev);
2072    return dev->block_num;
2073 }
2074
2075 uint32_t dev_file(DEVICE *dev)
2076 {
2077    update_pos_dev(dev);
2078    return dev->file;
2079 }
2080
2081 /*
2082  * Free memory allocated for the device
2083  */
2084 void DEVICE::term(void)
2085 {
2086    Dmsg1(900, "term dev: %s\n", print_name());
2087    close();
2088    if (dev_name) {
2089       free_memory(dev_name);
2090       dev_name = NULL;
2091    }
2092    if (prt_name) {
2093       free_memory(prt_name);
2094       prt_name = NULL;
2095    }
2096    if (errmsg) {
2097       free_pool_memory(errmsg);
2098       errmsg = NULL;
2099    }
2100    pthread_mutex_destroy(&mutex);
2101    pthread_cond_destroy(&wait);
2102    pthread_cond_destroy(&wait_next_vol);
2103    pthread_mutex_destroy(&spool_mutex);
2104    rwl_destroy(&lock);
2105    if (attached_dcrs) {
2106       delete attached_dcrs;
2107       attached_dcrs = NULL;
2108    }
2109    if (device) {
2110       device->dev = NULL;
2111    }
2112    free((char *)this);
2113 }
2114
2115 /*
2116  * This routine initializes the device wait timers
2117  */
2118 void init_device_wait_timers(DCR *dcr)
2119 {
2120    DEVICE *dev = dcr->dev;
2121    JCR *jcr = dcr->jcr;
2122
2123    /* ******FIXME******* put these on config variables */
2124    dev->min_wait = 60 * 60;
2125    dev->max_wait = 24 * 60 * 60;
2126    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2127    dev->wait_sec = dev->min_wait;
2128    dev->rem_wait_sec = dev->wait_sec;
2129    dev->num_wait = 0;
2130    dev->poll = false;
2131    dev->BadVolName[0] = 0;
2132
2133    jcr->min_wait = 60 * 60;
2134    jcr->max_wait = 24 * 60 * 60;
2135    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2136    jcr->wait_sec = jcr->min_wait;
2137    jcr->rem_wait_sec = jcr->wait_sec;
2138    jcr->num_wait = 0;
2139
2140 }
2141
2142 void init_jcr_device_wait_timers(JCR *jcr)
2143 {
2144    /* ******FIXME******* put these on config variables */
2145    jcr->min_wait = 60 * 60;
2146    jcr->max_wait = 24 * 60 * 60;
2147    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2148    jcr->wait_sec = jcr->min_wait;
2149    jcr->rem_wait_sec = jcr->wait_sec;
2150    jcr->num_wait = 0;
2151 }
2152
2153
2154 /*
2155  * The dev timers are used for waiting on a particular device
2156  *
2157  * Returns: true if time doubled
2158  *          false if max time expired
2159  */
2160 bool double_dev_wait_time(DEVICE *dev)
2161 {
2162    dev->wait_sec *= 2;               /* double wait time */
2163    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2164       dev->wait_sec = dev->max_wait;
2165    }
2166    dev->num_wait++;
2167    dev->rem_wait_sec = dev->wait_sec;
2168    if (dev->num_wait >= dev->max_num_wait) {
2169       return false;
2170    }
2171    return true;
2172 }
2173
2174
2175 void set_os_device_parameters(DEVICE *dev)
2176 {
2177 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2178    struct mtop mt_com;
2179    if (dev->min_block_size == dev->max_block_size &&
2180        dev->min_block_size == 0) {    /* variable block mode */
2181       mt_com.mt_op = MTSETBLK;
2182       mt_com.mt_count = 0;
2183       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2184          dev->clrerror(MTSETBLK);
2185       }
2186       mt_com.mt_op = MTSETDRVBUFFER;
2187       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2188       if (!dev->has_cap(CAP_TWOEOF)) {
2189          mt_com.mt_count |= MT_ST_TWO_FM;
2190       }
2191       if (dev->has_cap(CAP_EOM)) {
2192          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2193       }
2194       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2195          dev->clrerror(MTSETBLK);
2196       }
2197    }
2198    return;
2199 #endif
2200
2201 #ifdef HAVE_NETBSD_OS
2202    struct mtop mt_com;
2203    if (dev->min_block_size == dev->max_block_size &&
2204        dev->min_block_size == 0) {    /* variable block mode */
2205       mt_com.mt_op = MTSETBSIZ;
2206       mt_com.mt_count = 0;
2207       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2208          dev->clrerror(MTSETBSIZ);
2209       }
2210       /* Get notified at logical end of tape */
2211       mt_com.mt_op = MTEWARN;
2212       mt_com.mt_count = 1;
2213       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2214          dev->clrerror(MTEWARN);
2215       }
2216    }
2217    return;
2218 #endif
2219
2220 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2221    struct mtop mt_com;
2222    if (dev->min_block_size == dev->max_block_size &&
2223        dev->min_block_size == 0) {    /* variable block mode */
2224       mt_com.mt_op = MTSETBSIZ;
2225       mt_com.mt_count = 0;
2226       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2227          dev->clrerror(MTSETBSIZ);
2228       }
2229    }
2230    return;
2231 #endif
2232
2233 #ifdef HAVE_SUN_OS
2234    struct mtop mt_com;
2235    if (dev->min_block_size == dev->max_block_size &&
2236        dev->min_block_size == 0) {    /* variable block mode */
2237       mt_com.mt_op = MTSRSZ;
2238       mt_com.mt_count = 0;
2239       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2240          dev->clrerror(MTSRSZ);
2241       }
2242    }
2243    return;
2244 #endif
2245 }
2246
2247 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2248 {
2249    return dev->has_cap(CAP_MTIOCGET) &&
2250           tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2251           mt_stat->mt_fileno >= 0;
2252 }
2253
2254 static char *modes[] = {
2255    "CREATE_READ_WRITE",
2256    "OPEN_READ_WRITE",
2257    "OPEN_READ_ONLY",
2258    "OPEN_WRITE_ONLY"
2259 };
2260
2261
2262 static char *mode_to_str(int mode)
2263 {
2264    static char buf[100];
2265    if (mode < 1 || mode > 4) {
2266       bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2267       return buf;
2268     }
2269    return modes[mode-1];
2270 }