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