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