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

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