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