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