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

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