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(DCR *dcr);
  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(dcr);       /* 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 (!IsPathSeparator(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, (boffset_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    boffset_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, (boffset_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    boffset_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, (boffset_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       boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1572       Dmsg1(100, "===== lseek to %d\n", (int)pos);
1573       if (lseek(dcr, pos, SEEK_SET) == (boffset_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 boffset_t DEVICE::lseek(DCR *dcr, boffset_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 #if defined(HAVE_WIN32)
1903       return ::_lseeki64(fd, (__int64)offset, whence);
1904 #else
1905       return ::lseek(fd, (off_t)offset, whence);
1906 #endif
1907    }
1908    return -1;
1909 }
1910
1911
1912 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1913 {
1914    Dmsg1(100, "truncate %s\n", print_name());
1915    switch (dev_type) {
1916    case B_TAPE_DEV:
1917       /* maybe we should rewind and write and eof ???? */
1918       return true;                    /* we don't really truncate tapes */
1919    case B_DVD_DEV:
1920       return truncate_dvd(dcr);
1921    case B_FILE_DEV:
1922       /* ***FIXME*** we really need to unlink() the file so that
1923        *  its name can be changed for a relabel.
1924        */
1925       if (ftruncate(fd, 0) != 0) {
1926          berrno be;
1927          Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1928                print_name(), be.strerror());
1929          return false;
1930       }
1931       return true;
1932    }
1933    return false;
1934 }
1935
1936 /* Mount the device.
1937  * If timeout, wait until the mount command returns 0.
1938  * If !timeout, try to mount the device only once.
1939  */
1940 bool DEVICE::mount(int timeout)
1941 {
1942    Dmsg0(190, "Enter mount\n");
1943    if (is_mounted()) {
1944       return true;
1945    } else if (requires_mount()) {
1946       return do_mount(1, timeout);
1947    }
1948    return true;
1949 }
1950
1951 /* Unmount the device
1952  * If timeout, wait until the unmount command returns 0.
1953  * If !timeout, try to unmount the device only once.
1954  */
1955 bool DEVICE::unmount(int timeout)
1956 {
1957    Dmsg0(90, "Enter unmount\n");
1958    if (is_mounted()) {
1959       return do_mount(0, timeout);
1960    }
1961    return true;
1962 }
1963
1964 /* (Un)mount the device */
1965 bool DEVICE::do_mount(int mount, int dotimeout)
1966 {
1967    POOL_MEM ocmd(PM_FNAME);
1968    POOLMEM *results;
1969    char *icmd;
1970    int status, timeout;
1971
1972    sm_check(__FILE__, __LINE__, false);
1973    if (mount) {
1974       if (is_mounted()) {
1975          Dmsg0(200, "======= mount=1\n");
1976          return true;
1977       }
1978       icmd = device->mount_command;
1979    } else {
1980       if (!is_mounted()) {
1981          Dmsg0(200, "======= mount=0\n");
1982          return true;
1983       }
1984       icmd = device->unmount_command;
1985    }
1986
1987    clear_freespace_ok();
1988    edit_mount_codes(ocmd, icmd);
1989
1990    Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1991
1992    if (dotimeout) {
1993       /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1994       timeout = 1;
1995    } else {
1996       timeout = 0;
1997    }
1998    results = get_memory(4000);
1999    results[0] = 0;
2000
2001    /* If busy retry each second */
2002    Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
2003    while ((status = run_program_full_output(ocmd.c_str(),
2004                        max_open_wait/2, results)) != 0) {
2005       /* Doesn't work with internationalization (This is not a problem) */
2006       if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2007          break;
2008       }
2009       if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2010          break;
2011       }
2012       if (timeout-- > 0) {
2013          /* Sometimes the device cannot be mounted because it is already mounted.
2014           * Try to unmount it, then remount it */
2015          if (mount) {
2016             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2017             do_mount(0, 0);
2018          }
2019          bmicrosleep(1, 0);
2020          continue;
2021       }
2022       if (status != 0) {
2023          berrno be;
2024          Dmsg5(40, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2025               (mount ? "" : "un"), status, results, be.strerror(status));
2026          Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2027               print_name(), (mount ? "" : "un"), be.strerror(status));
2028       } else {
2029          Dmsg4(40, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2030               (mount ? "" : "un"), status, results);
2031          Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2032               print_name(), (mount ? "" : "un"), results);
2033       }
2034       /*
2035        * Now, just to be sure it is not mounted, try to read the
2036        *  filesystem.
2037        */
2038       DIR* dp;
2039       struct dirent *entry, *result;
2040       int name_max;
2041       int count;
2042
2043       name_max = pathconf(".", _PC_NAME_MAX);
2044       if (name_max < 1024) {
2045          name_max = 1024;
2046       }
2047
2048       if (!(dp = opendir(device->mount_point))) {
2049          berrno be;
2050          dev_errno = errno;
2051          Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2052                device->mount_point, print_name(), be.strerror());
2053          goto get_out;
2054       }
2055
2056       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2057       count = 0;
2058       while (1) {
2059          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2060             dev_errno = EIO;
2061             Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2062                   device->mount_point, print_name());
2063             break;
2064          }
2065          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2066             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2067             break;
2068          } else {
2069             Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2070          }
2071       }
2072       free(entry);
2073       closedir(dp);
2074
2075       Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2076
2077       if (count > 0) {
2078          /* If we got more than ., .. and .keep */
2079          /*   there must be something mounted */
2080          if (mount) {
2081             Dmsg1(100, "Did Mount by count=%d\n", count);
2082             break;
2083          } else {
2084             /* An unmount request. We failed to unmount - report an error */
2085             set_mounted(true);
2086             free_pool_memory(results);
2087             Dmsg0(200, "== error mount=1 wanted unmount\n");
2088             return false;
2089          }
2090       }
2091 get_out:
2092       set_mounted(false);
2093       sm_check(__FILE__, __LINE__, false);
2094       free_pool_memory(results);
2095       Dmsg0(200, "============ mount=0\n");
2096       return false;
2097    }
2098
2099    set_mounted(mount);              /* set/clear mounted flag */
2100    free_pool_memory(results);
2101    /* Do not check free space when unmounting */
2102    if (mount && !update_freespace()) {
2103       return false;
2104    }
2105    Dmsg1(200, "============ mount=%d\n", mount);
2106    return true;
2107 }
2108
2109 /*
2110  * Edit codes into (Un)MountCommand, Write(First)PartCommand
2111  *  %% = %
2112  *  %a = archive device name
2113  *  %e = erase (set if cannot mount and first part)
2114  *  %n = part number
2115  *  %m = mount point
2116  *  %v = last part name
2117  *
2118  *  omsg = edited output message
2119  *  imsg = input string containing edit codes (%x)
2120  *
2121  */
2122 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2123 {
2124    const char *p;
2125    const char *str;
2126    char add[20];
2127
2128    POOL_MEM archive_name(PM_FNAME);
2129
2130    omsg.c_str()[0] = 0;
2131    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2132    for (p=imsg; *p; p++) {
2133       if (*p == '%') {
2134          switch (*++p) {
2135          case '%':
2136             str = "%";
2137             break;
2138          case 'a':
2139             str = dev_name;
2140             break;
2141          case 'e':
2142             if (num_dvd_parts == 0) {
2143                if (truncating || blank_dvd) {
2144                   str = "2";
2145                } else {
2146                   str = "1";
2147                }
2148             } else {
2149                str = "0";
2150             }
2151             break;
2152          case 'n':
2153             bsnprintf(add, sizeof(add), "%d", part);
2154             str = add;
2155             break;
2156          case 'm':
2157             str = device->mount_point;
2158             break;
2159          case 'v':
2160             make_spooled_dvd_filename(this, archive_name);
2161             str = archive_name.c_str();
2162             break;
2163          default:
2164             add[0] = '%';
2165             add[1] = *p;
2166             add[2] = 0;
2167             str = add;
2168             break;
2169          }
2170       } else {
2171          add[0] = *p;
2172          add[1] = 0;
2173          str = add;
2174       }
2175       Dmsg1(1900, "add_str %s\n", str);
2176       pm_strcat(omsg, (char *)str);
2177       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2178    }
2179 }
2180
2181
2182 /* Return the resource name for the device */
2183 const char *DEVICE::name() const
2184 {
2185    return device->hdr.name;
2186 }
2187
2188 char *
2189 dev_vol_name(DEVICE *dev)
2190 {
2191    return dev->VolCatInfo.VolCatName;
2192 }
2193
2194
2195 /*
2196  * Free memory allocated for the device
2197  */
2198 void DEVICE::term(void)
2199 {
2200    Dmsg1(900, "term dev: %s\n", print_name());
2201    close();
2202    if (dev_name) {
2203       free_memory(dev_name);
2204       dev_name = NULL;
2205    }
2206    if (prt_name) {
2207       free_memory(prt_name);
2208       prt_name = NULL;
2209    }
2210    if (errmsg) {
2211       free_pool_memory(errmsg);
2212       errmsg = NULL;
2213    }
2214    pthread_mutex_destroy(&mutex);
2215    pthread_cond_destroy(&wait);
2216    pthread_cond_destroy(&wait_next_vol);
2217    pthread_mutex_destroy(&spool_mutex);
2218    rwl_destroy(&lock);
2219    if (attached_dcrs) {
2220       delete attached_dcrs;
2221       attached_dcrs = NULL;
2222    }
2223    if (device) {
2224       device->dev = NULL;
2225    }
2226    free((char *)this);
2227 }
2228
2229 /*
2230  * This routine initializes the device wait timers
2231  */
2232 void init_device_wait_timers(DCR *dcr)
2233 {
2234    DEVICE *dev = dcr->dev;
2235    JCR *jcr = dcr->jcr;
2236
2237    /* ******FIXME******* put these on config variables */
2238    dev->min_wait = 60 * 60;
2239    dev->max_wait = 24 * 60 * 60;
2240    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2241    dev->wait_sec = dev->min_wait;
2242    dev->rem_wait_sec = dev->wait_sec;
2243    dev->num_wait = 0;
2244    dev->poll = false;
2245    dev->BadVolName[0] = 0;
2246
2247    jcr->min_wait = 60 * 60;
2248    jcr->max_wait = 24 * 60 * 60;
2249    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2250    jcr->wait_sec = jcr->min_wait;
2251    jcr->rem_wait_sec = jcr->wait_sec;
2252    jcr->num_wait = 0;
2253
2254 }
2255
2256 void init_jcr_device_wait_timers(JCR *jcr)
2257 {
2258    /* ******FIXME******* put these on config variables */
2259    jcr->min_wait = 60 * 60;
2260    jcr->max_wait = 24 * 60 * 60;
2261    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2262    jcr->wait_sec = jcr->min_wait;
2263    jcr->rem_wait_sec = jcr->wait_sec;
2264    jcr->num_wait = 0;
2265 }
2266
2267
2268 /*
2269  * The dev timers are used for waiting on a particular device
2270  *
2271  * Returns: true if time doubled
2272  *          false if max time expired
2273  */
2274 bool double_dev_wait_time(DEVICE *dev)
2275 {
2276    dev->wait_sec *= 2;               /* double wait time */
2277    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2278       dev->wait_sec = dev->max_wait;
2279    }
2280    dev->num_wait++;
2281    dev->rem_wait_sec = dev->wait_sec;
2282    if (dev->num_wait >= dev->max_num_wait) {
2283       return false;
2284    }
2285    return true;
2286 }
2287
2288
2289 void set_os_device_parameters(DCR *dcr)
2290 {
2291    DEVICE *dev = dcr->dev;
2292
2293 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2294    struct mtop mt_com;
2295
2296    Dmsg0(050, "In set_os_device_parameters\n");
2297 #if defined(MTSETBLK)
2298    if (dev->min_block_size == dev->max_block_size &&
2299        dev->min_block_size == 0) {    /* variable block mode */
2300       mt_com.mt_op = MTSETBLK;
2301       mt_com.mt_count = 0;
2302       Dmsg0(050, "Set block size to zero\n");
2303       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2304          dev->clrerror(MTSETBLK);
2305       }
2306    }
2307 #endif
2308 #if defined(MTSETDRVBUFFER)
2309    if (getpid() == 0) {          /* Only root can do this */
2310       mt_com.mt_op = MTSETDRVBUFFER;
2311       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2312       if (!dev->has_cap(CAP_TWOEOF)) {
2313          mt_com.mt_count |= MT_ST_TWO_FM;
2314       }
2315       if (dev->has_cap(CAP_EOM)) {
2316          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2317       }
2318       Dmsg0(050, "MTSETDRVBUFFER\n");
2319       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2320          dev->clrerror(MTSETDRVBUFFER);
2321       }
2322    }
2323 #endif
2324    return;
2325 #endif
2326
2327 #ifdef HAVE_NETBSD_OS
2328    struct mtop mt_com;
2329    if (dev->min_block_size == dev->max_block_size &&
2330        dev->min_block_size == 0) {    /* variable block mode */
2331       mt_com.mt_op = MTSETBSIZ;
2332       mt_com.mt_count = 0;
2333       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2334          dev->clrerror(MTSETBSIZ);
2335       }
2336       /* Get notified at logical end of tape */
2337       mt_com.mt_op = MTEWARN;
2338       mt_com.mt_count = 1;
2339       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2340          dev->clrerror(MTEWARN);
2341       }
2342    }
2343    return;
2344 #endif
2345
2346 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2347    struct mtop mt_com;
2348    if (dev->min_block_size == dev->max_block_size &&
2349        dev->min_block_size == 0) {    /* variable block mode */
2350       mt_com.mt_op = MTSETBSIZ;
2351       mt_com.mt_count = 0;
2352       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2353          dev->clrerror(MTSETBSIZ);
2354       }
2355    }
2356 /* Turn this on later when fully tested */
2357 #if defined(xxxMTIOCSETEOTMODEL)
2358    uint32_t neof;
2359    if (dev_cap(dev, CAP_TWOEOF)) {
2360       neof = 2;
2361    } else {
2362       neof = 1;
2363    }
2364    if (ioctl(dev->fd, MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2365       berrno be;
2366       dev->dev_errno = errno;         /* save errno */
2367       Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2368             dev->print_name(), be.strerror(dev->dev_errno));
2369       Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2370    }
2371 #endif
2372    return;
2373 #endif
2374
2375 #ifdef HAVE_SUN_OS
2376    struct mtop mt_com;
2377    if (dev->min_block_size == dev->max_block_size &&
2378        dev->min_block_size == 0) {    /* variable block mode */
2379       mt_com.mt_op = MTSRSZ;
2380       mt_com.mt_count = 0;
2381       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2382          dev->clrerror(MTSRSZ);
2383       }
2384    }
2385    return;
2386 #endif
2387 }
2388
2389 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2390 {
2391    Dmsg0(050, "dev_get_os_pos\n");
2392    return dev->has_cap(CAP_MTIOCGET) &&
2393           tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2394           mt_stat->mt_fileno >= 0;
2395 }
2396
2397 static char *modes[] = {
2398    "CREATE_READ_WRITE",
2399    "OPEN_READ_WRITE",
2400    "OPEN_READ_ONLY",
2401    "OPEN_WRITE_ONLY"
2402 };
2403
2404
2405 static char *mode_to_str(int mode)
2406 {
2407    static char buf[100];
2408    if (mode < 1 || mode > 4) {
2409       bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2410       return buf;
2411     }
2412    return modes[mode-1];
2413 }