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