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

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