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, "Enter 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(200, "====== 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       Dmsg0(100, errmsg);
 920       return false;
 921    }
 922 #ifdef MTEOM
 923    if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
 924       Dmsg0(100,"Using FAST FSF for EOM\n");
 925       /* If unknown position, rewind */
 926       if (get_os_tape_file() < 0) {
 927         if (!rewind(NULL)) {
 928           Dmsg0(100, "Rewind error\n");
 929           return false;
 930         }
 931       }
 932       mt_com.mt_op = MTFSF;
 933       /*
 934        * ***FIXME*** fix code to handle case that INT16_MAX is
 935        *   not large enough.
 936        */
 937       mt_com.mt_count = INT16_MAX;    /* use big positive number */
 938       if (mt_com.mt_count < 0) {
 939          mt_com.mt_count = INT16_MAX; /* brain damaged system */
 940       }
 941    }
 942
 943    if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
 944       if (has_cap(CAP_EOM)) {
 945          Dmsg0(100,"Using EOM for EOM\n");
 946          mt_com.mt_op = MTEOM;
 947          mt_com.mt_count = 1;
 948       }
 949
 950       if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
 951          berrno be;
 952          clrerror(mt_com.mt_op);
 953          Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
 954          update_pos(dcr);
 955          Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
 956             print_name(), be.bstrerror());
 957          Dmsg0(100, errmsg);
 958          return false;
 959       }
 960
 961       os_file = get_os_tape_file();
 962       if (os_file < 0) {
 963          berrno be;
 964          clrerror(-1);
 965          Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
 966             print_name(), be.bstrerror());
 967          Dmsg0(100, errmsg);
 968          return false;
 969       }
 970       Dmsg1(100, "EOD file=%d\n", os_file);
 971       set_ateof();
 972       file = os_file;
 973    } else {
 974 #else
 975    {
 976 #endif
 977       /*
 978        * Rewind then use FSF until EOT reached
 979        */
 980       if (!rewind(NULL)) {
 981          Dmsg0(100, "Rewind error.\n");
 982          return false;
 983       }
 984       /*
 985        * Move file by file to the end of the tape
 986        */
 987       int file_num;
 988       for (file_num=file; !at_eot(); file_num++) {
 989          Dmsg0(200, "eod: doing fsf 1\n");
 990          if (!fsf(1)) {
 991             Dmsg0(100, "fsf error.\n");
 992             return false;
 993          }
 994          /*
 995           * Avoid infinite loop by ensuring we advance.
 996           */
 997          if (!at_eot() && file_num == (int)file) {
 998             Dmsg1(100, "fsf did not advance from file %d\n", file_num);
 999             set_ateof();
1000             os_file = get_os_tape_file();
1001             if (os_file >= 0) {
1002                Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
1003                file = os_file;
1004             }
1005             break;
1006          }
1007       }
1008    }
1009    /*
1010     * Some drivers leave us after second EOF when doing
1011     * MTEOM, so we must backup so that appending overwrites
1012     * the second EOF.
1013     */
1014    if (has_cap(CAP_BSFATEOM)) {
1015       /* Backup over EOF */
1016       ok = bsf(1);
1017       /* If BSF worked and fileno is known (not -1), set file */
1018       os_file = get_os_tape_file();
1019       if (os_file >= 0) {
1020          Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1021          file = os_file;
1022       } else {
1023          file++;                       /* wing it -- not correct on all OSes */
1024       }
1025    } else {
1026       update_pos(dcr);                 /* update position */
1027    }
1028    Dmsg1(200, "EOD dev->file=%d\n", file);
1029    return ok;
1030 }
1031
1032 /*
1033  * Set the position of the device -- only for files and DVD
1034  *   For other devices, there is no generic way to do it.
1035  *  Returns: true  on succes
1036  *           false on error
1037  */
1038 bool DEVICE::update_pos(DCR *dcr)
1039 {
1040    boffset_t pos;
1041    bool ok = true;
1042
1043    if (!is_open()) {
1044       dev_errno = EBADF;
1045       Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1046       Emsg1(M_FATAL, 0, "%s", errmsg);
1047       return false;
1048    }
1049
1050    /* Find out where we are */
1051    if (is_file() || is_dvd()) {
1052       file = 0;
1053       file_addr = 0;
1054       pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1055       if (pos < 0) {
1056          berrno be;
1057          dev_errno = errno;
1058          Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1059          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1060             print_name(), be.bstrerror());
1061          ok = false;
1062       } else {
1063          file_addr = pos;
1064          block_num = (uint32_t)pos;
1065          file = (uint32_t)(pos >> 32);
1066       }
1067    }
1068    return ok;
1069 }
1070
1071 /*
1072  * Return the status of the device.  This was meant
1073  * to be a generic routine. Unfortunately, it doesn't
1074  * seem possible (at least I do not know how to do it
1075  * currently), which means that for the moment, this
1076  * routine has very little value.
1077  *
1078  *   Returns: status
1079  */
1080 uint32_t status_dev(DEVICE *dev)
1081 {
1082    struct mtget mt_stat;
1083    uint32_t stat = 0;
1084
1085    if (dev->state & (ST_EOT | ST_WEOT)) {
1086       stat |= BMT_EOD;
1087       Pmsg0(-20, " EOD");
1088    }
1089    if (dev->state & ST_EOF) {
1090       stat |= BMT_EOF;
1091       Pmsg0(-20, " EOF");
1092    }
1093    if (dev->is_tape()) {
1094       stat |= BMT_TAPE;
1095       Pmsg0(-20,_(" Bacula status:"));
1096       Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1097       if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1098          berrno be;
1099          dev->dev_errno = errno;
1100          Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1101             dev->print_name(), be.bstrerror());
1102          return 0;
1103       }
1104       Pmsg0(-20, _(" Device status:"));
1105
1106 #if defined(HAVE_LINUX_OS)
1107       if (GMT_EOF(mt_stat.mt_gstat)) {
1108          stat |= BMT_EOF;
1109          Pmsg0(-20, " EOF");
1110       }
1111       if (GMT_BOT(mt_stat.mt_gstat)) {
1112          stat |= BMT_BOT;
1113          Pmsg0(-20, " BOT");
1114       }
1115       if (GMT_EOT(mt_stat.mt_gstat)) {
1116          stat |= BMT_EOT;
1117          Pmsg0(-20, " EOT");
1118       }
1119       if (GMT_SM(mt_stat.mt_gstat)) {
1120          stat |= BMT_SM;
1121          Pmsg0(-20, " SM");
1122       }
1123       if (GMT_EOD(mt_stat.mt_gstat)) {
1124          stat |= BMT_EOD;
1125          Pmsg0(-20, " EOD");
1126       }
1127       if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1128          stat |= BMT_WR_PROT;
1129          Pmsg0(-20, " WR_PROT");
1130       }
1131       if (GMT_ONLINE(mt_stat.mt_gstat)) {
1132          stat |= BMT_ONLINE;
1133          Pmsg0(-20, " ONLINE");
1134       }
1135       if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1136          stat |= BMT_DR_OPEN;
1137          Pmsg0(-20, " DR_OPEN");
1138       }
1139       if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1140          stat |= BMT_IM_REP_EN;
1141          Pmsg0(-20, " IM_REP_EN");
1142       }
1143 #elif defined(HAVE_WIN32)
1144       if (GMT_EOF(mt_stat.mt_gstat)) {
1145          stat |= BMT_EOF;
1146          Pmsg0(-20, " EOF");
1147       }
1148       if (GMT_BOT(mt_stat.mt_gstat)) {
1149          stat |= BMT_BOT;
1150          Pmsg0(-20, " BOT");
1151       }
1152       if (GMT_EOT(mt_stat.mt_gstat)) {
1153          stat |= BMT_EOT;
1154          Pmsg0(-20, " EOT");
1155       }
1156       if (GMT_EOD(mt_stat.mt_gstat)) {
1157          stat |= BMT_EOD;
1158          Pmsg0(-20, " EOD");
1159       }
1160       if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1161          stat |= BMT_WR_PROT;
1162          Pmsg0(-20, " WR_PROT");
1163       }
1164       if (GMT_ONLINE(mt_stat.mt_gstat)) {
1165          stat |= BMT_ONLINE;
1166          Pmsg0(-20, " ONLINE");
1167       }
1168       if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1169          stat |= BMT_DR_OPEN;
1170          Pmsg0(-20, " DR_OPEN");
1171       }
1172       if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1173          stat |= BMT_IM_REP_EN;
1174          Pmsg0(-20, " IM_REP_EN");
1175       }
1176
1177 #endif /* !SunOS && !OSF */
1178       if (dev->has_cap(CAP_MTIOCGET)) {
1179          Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1180       } else {
1181          Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1182       }
1183    } else {
1184       stat |= BMT_ONLINE | BMT_BOT;
1185    }
1186    return stat;
1187 }
1188
1189
1190 /*
1191  * Load medium in device
1192  *  Returns: true  on success
1193  *           false on failure
1194  */
1195 bool load_dev(DEVICE *dev)
1196 {
1197 #ifdef MTLOAD
1198    struct mtop mt_com;
1199 #endif
1200
1201    if (dev->fd() < 0) {
1202       dev->dev_errno = EBADF;
1203       Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1204       Emsg0(M_FATAL, 0, dev->errmsg);
1205       return false;
1206    }
1207    if (!(dev->is_tape())) {
1208       return true;
1209    }
1210 #ifndef MTLOAD
1211    Dmsg0(200, "stored: MTLOAD command not available\n");
1212    berrno be;
1213    dev->dev_errno = ENOTTY;           /* function not available */
1214    Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1215          dev->print_name(), be.bstrerror());
1216    return false;
1217 #else
1218
1219    dev->block_num = dev->file = 0;
1220    dev->file_size = 0;
1221    dev->file_addr = 0;
1222    mt_com.mt_op = MTLOAD;
1223    mt_com.mt_count = 1;
1224    if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1225       berrno be;
1226       dev->dev_errno = errno;
1227       Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1228          dev->print_name(), be.bstrerror());
1229       return false;
1230    }
1231    return true;
1232 #endif
1233 }
1234
1235 /*
1236  * Rewind device and put it offline
1237  *  Returns: true  on success
1238  *           false on failure
1239  */
1240 bool DEVICE::offline()
1241 {
1242    struct mtop mt_com;
1243
1244    if (!is_tape()) {
1245       return true;                    /* device not open */
1246    }
1247
1248    state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
1249    block_num = file = 0;
1250    file_size = 0;
1251    file_addr = 0;
1252    unlock_door();
1253    mt_com.mt_op = MTOFFL;
1254    mt_com.mt_count = 1;
1255    if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1256       berrno be;
1257       dev_errno = errno;
1258       Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1259          print_name(), be.bstrerror());
1260       return false;
1261    }
1262    Dmsg1(100, "Offlined device %s\n", print_name());
1263    return true;
1264 }
1265
1266 bool DEVICE::offline_or_rewind()
1267 {
1268    if (m_fd < 0) {
1269       return false;
1270    }
1271    if (has_cap(CAP_OFFLINEUNMOUNT)) {
1272       return offline();
1273    } else {
1274    /*
1275     * Note, this rewind probably should not be here (it wasn't
1276     *  in prior versions of Bacula), but on FreeBSD, this is
1277     *  needed in the case the tape was "frozen" due to an error
1278     *  such as backspacing after writing and EOF. If it is not
1279     *  done, all future references to the drive get and I/O error.
1280     */
1281       clrerror(MTREW);
1282       return rewind(NULL);
1283    }
1284 }
1285
1286 /*
1287  * Foward space a file
1288  *   Returns: true  on success
1289  *            false on failure
1290  */
1291 bool DEVICE::fsf(int num)
1292 {
1293    int32_t os_file = 0;
1294    struct mtop mt_com;
1295    int stat = 0;
1296
1297    if (!is_open()) {
1298       dev_errno = EBADF;
1299       Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1300       Emsg0(M_FATAL, 0, errmsg);
1301       return false;
1302    }
1303
1304    if (!is_tape()) {
1305       return true;
1306    }
1307
1308    if (at_eot()) {
1309       dev_errno = 0;
1310       Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1311       return false;
1312    }
1313    if (at_eof()) {
1314       Dmsg0(200, "ST_EOF set on entry to FSF\n");
1315    }
1316
1317    Dmsg0(100, "fsf\n");
1318    block_num = 0;
1319    /*
1320     * If Fast forward space file is set, then we
1321     *  use MTFSF to forward space and MTIOCGET
1322     *  to get the file position. We assume that
1323     *  the SCSI driver will ensure that we do not
1324     *  forward space past the end of the medium.
1325     */
1326    if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1327       int my_errno = 0;
1328       mt_com.mt_op = MTFSF;
1329       mt_com.mt_count = num;
1330       stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1331       if (stat < 0) {
1332          my_errno = errno;            /* save errno */
1333       } else if ((os_file=get_os_tape_file()) < 0) {
1334          my_errno = errno;            /* save errno */
1335       }
1336       if (my_errno != 0) {
1337          berrno be;
1338          set_eot();
1339          Dmsg0(200, "Set ST_EOT\n");
1340          clrerror(MTFSF);
1341          Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1342             print_name(), be.bstrerror(my_errno));
1343          Dmsg1(200, "%s", errmsg);
1344          return false;
1345       }
1346
1347       Dmsg1(200, "fsf file=%d\n", os_file);
1348       set_ateof();
1349       file = os_file;
1350       return true;
1351
1352    /*
1353     * Here if CAP_FSF is set, and virtually all drives
1354     *  these days support it, we read a record, then forward
1355     *  space one file. Using this procedure, which is slow,
1356     *  is the only way we can be sure that we don't read
1357     *  two consecutive EOF marks, which means End of Data.
1358     */
1359    } else if (has_cap(CAP_FSF)) {
1360       POOLMEM *rbuf;
1361       int rbuf_len;
1362       Dmsg0(200, "FSF has cap_fsf\n");
1363       if (max_block_size == 0) {
1364          rbuf_len = DEFAULT_BLOCK_SIZE;
1365       } else {
1366          rbuf_len = max_block_size;
1367       }
1368       rbuf = get_memory(rbuf_len);
1369       mt_com.mt_op = MTFSF;
1370       mt_com.mt_count = 1;
1371       while (num-- && !at_eot()) {
1372          Dmsg0(100, "Doing read before fsf\n");
1373          if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1374             if (errno == ENOMEM) {     /* tape record exceeds buf len */
1375                stat = rbuf_len;        /* This is OK */
1376             /*
1377              * On IBM drives, they return ENOSPC at EOM
1378              *  instead of EOF status
1379              */
1380             } else if (at_eof() && errno == ENOSPC) {
1381                stat = 0;
1382             } else {
1383                berrno be;
1384                set_eot();
1385                clrerror(-1);
1386                Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1387                   be.bstrerror());
1388                Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1389                   print_name(), be.bstrerror());
1390                Dmsg1(100, "%s", errmsg);
1391                break;
1392             }
1393          }
1394          if (stat == 0) {                /* EOF */
1395             Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1396             /* Two reads of zero means end of tape */
1397             if (at_eof()) {
1398                set_eot();
1399                Dmsg0(100, "Set ST_EOT\n");
1400                break;
1401             } else {
1402                set_ateof();
1403                continue;
1404             }
1405          } else {                        /* Got data */
1406             clear_eot();
1407             clear_eof();
1408          }
1409
1410          Dmsg0(100, "Doing MTFSF\n");
1411          stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1412          if (stat < 0) {                 /* error => EOT */
1413             berrno be;
1414             set_eot();
1415             Dmsg0(100, "Set ST_EOT\n");
1416             clrerror(MTFSF);
1417             Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1418                print_name(), be.bstrerror());
1419             Dmsg0(100, "Got < 0 for MTFSF\n");
1420             Dmsg1(100, "%s", errmsg);
1421          } else {
1422             set_ateof();
1423          }
1424       }
1425       free_memory(rbuf);
1426
1427    /*
1428     * No FSF, so use FSR to simulate it
1429     */
1430    } else {
1431       Dmsg0(200, "Doing FSR for FSF\n");
1432       while (num-- && !at_eot()) {
1433          fsr(INT32_MAX);    /* returns -1 on EOF or EOT */
1434       }
1435       if (at_eot()) {
1436          dev_errno = 0;
1437          Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1438          stat = -1;
1439       } else {
1440          stat = 0;
1441       }
1442    }
1443    Dmsg1(200, "Return %d from FSF\n", stat);
1444    if (at_eof()) {
1445       Dmsg0(200, "ST_EOF set on exit FSF\n");
1446    }
1447    if (at_eot()) {
1448       Dmsg0(200, "ST_EOT set on exit FSF\n");
1449    }
1450    Dmsg1(200, "Return from FSF file=%d\n", file);
1451    return stat == 0;
1452 }
1453
1454 /*
1455  * Backward space a file
1456  *  Returns: false on failure
1457  *           true  on success
1458  */
1459 bool DEVICE::bsf(int num)
1460 {
1461    struct mtop mt_com;
1462    int stat;
1463
1464    if (!is_open()) {
1465       dev_errno = EBADF;
1466       Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1467       Emsg0(M_FATAL, 0, errmsg);
1468       return false;
1469    }
1470
1471    if (!is_tape()) {
1472       Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1473          print_name());
1474       return false;
1475    }
1476
1477    Dmsg0(100, "bsf\n");
1478    clear_eot();
1479    clear_eof();
1480    file -= num;
1481    file_addr = 0;
1482    file_size = 0;
1483    mt_com.mt_op = MTBSF;
1484    mt_com.mt_count = num;
1485    stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1486    if (stat < 0) {
1487       berrno be;
1488       clrerror(MTBSF);
1489       Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1490          print_name(), be.bstrerror());
1491    }
1492    return stat == 0;
1493 }
1494
1495
1496 /*
1497  * Foward space num records
1498  *  Returns: false on failure
1499  *           true  on success
1500  */
1501 bool DEVICE::fsr(int num)
1502 {
1503    struct mtop mt_com;
1504    int stat;
1505
1506    if (!is_open()) {
1507       dev_errno = EBADF;
1508       Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1509       Emsg0(M_FATAL, 0, errmsg);
1510       return false;
1511    }
1512
1513    if (!is_tape()) {
1514       return false;
1515    }
1516
1517    if (!has_cap(CAP_FSR)) {
1518       Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1519       return false;
1520    }
1521
1522    Dmsg1(100, "fsr %d\n", num);
1523    mt_com.mt_op = MTFSR;
1524    mt_com.mt_count = num;
1525    stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1526    if (stat == 0) {
1527       clear_eof();
1528       block_num += num;
1529    } else {
1530       berrno be;
1531       struct mtget mt_stat;
1532       clrerror(MTFSR);
1533       Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1534       if (dev_get_os_pos(this, &mt_stat)) {
1535          Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1536             block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1537          file = mt_stat.mt_fileno;
1538          block_num = mt_stat.mt_blkno;
1539       } else {
1540          if (at_eof()) {
1541             set_eot();
1542          } else {
1543             set_ateof();
1544          }
1545       }
1546       Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1547          num, print_name(), be.bstrerror());
1548    }
1549    return stat == 0;
1550 }
1551
1552 /*
1553  * Backward space a record
1554  *   Returns:  false on failure
1555  *             true  on success
1556  */
1557 bool DEVICE::bsr(int num)
1558 {
1559    struct mtop mt_com;
1560    int stat;
1561
1562    if (!is_open()) {
1563       dev_errno = EBADF;
1564       Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1565       Emsg0(M_FATAL, 0, errmsg);
1566       return false;
1567    }
1568
1569    if (!is_tape()) {
1570       return false;
1571    }
1572
1573    if (!has_cap(CAP_BSR)) {
1574       Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1575       return false;
1576    }
1577
1578    Dmsg0(100, "bsr_dev\n");
1579    block_num -= num;
1580    clear_eof();
1581    clear_eot();
1582    mt_com.mt_op = MTBSR;
1583    mt_com.mt_count = num;
1584    stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1585    if (stat < 0) {
1586       berrno be;
1587       clrerror(MTBSR);
1588       Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1589          print_name(), be.bstrerror());
1590    }
1591    return stat == 0;
1592 }
1593
1594 void DEVICE::lock_door()
1595 {
1596 #ifdef MTLOCK
1597    struct mtop mt_com;
1598    mt_com.mt_op = MTLOCK;
1599    mt_com.mt_count = 1;
1600    d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1601 #endif
1602 }
1603
1604 void DEVICE::unlock_door()
1605 {
1606 #ifdef MTUNLOCK
1607    struct mtop mt_com;
1608    mt_com.mt_op = MTUNLOCK;
1609    mt_com.mt_count = 1;
1610    d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1611 #endif
1612 }
1613
1614 void DEVICE::set_slot(int32_t slot)
1615 {
1616    m_slot = slot;
1617    if (vol) vol->clear_slot();
1618 }
1619
1620 void DEVICE::clear_slot()
1621 {
1622    m_slot = -1;
1623    if (vol) vol->set_slot(-1);
1624 }
1625
1626
1627
1628 /*
1629  * Reposition the device to file, block
1630  * Returns: false on failure
1631  *          true  on success
1632  */
1633 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1634 {
1635    if (!is_open()) {
1636       dev_errno = EBADF;
1637       Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1638       Emsg0(M_FATAL, 0, errmsg);
1639       return false;
1640    }
1641
1642    if (!is_tape()) {
1643       boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1644       Dmsg1(100, "===== lseek to %d\n", (int)pos);
1645       if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1646          berrno be;
1647          dev_errno = errno;
1648          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1649             print_name(), be.bstrerror());
1650          return false;
1651       }
1652       file = rfile;
1653       block_num = rblock;
1654       file_addr = pos;
1655       return true;
1656    }
1657
1658    /* After this point, we are tape only */
1659    Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1660    if (rfile < file) {
1661       Dmsg0(100, "Rewind\n");
1662       if (!rewind(NULL)) {
1663          return false;
1664       }
1665    }
1666    if (rfile > file) {
1667       Dmsg1(100, "fsf %d\n", rfile-file);
1668       if (!fsf(rfile-file)) {
1669          Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1670          return false;
1671       }
1672       Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1673    }
1674    if (rblock < block_num) {
1675       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1676       Dmsg0(100, "bsf 1\n");
1677       bsf(1);
1678       Dmsg0(100, "fsf 1\n");
1679       fsf(1);
1680       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1681    }
1682    if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1683       /* Ignore errors as Bacula can read to the correct block */
1684       Dmsg1(100, "fsr %d\n", rblock-block_num);
1685       return fsr(rblock-block_num);
1686    } else {
1687       while (rblock > block_num) {
1688          if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1689             berrno be;
1690             dev_errno = errno;
1691             Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1692                print_name(), be.bstrerror());
1693             return false;
1694          }
1695          Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1696       }
1697    }
1698    return true;
1699 }
1700
1701
1702
1703 /*
1704  * Write an end of file on the device
1705  *   Returns: true on success
1706  *            false on failure
1707  */
1708 bool DEVICE::weof(int num)
1709 {
1710    struct mtop mt_com;
1711    int stat;
1712    Dmsg1(129, "=== weof_dev=%s\n", print_name());
1713
1714    if (!is_open()) {
1715       dev_errno = EBADF;
1716       Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1717       Emsg0(M_FATAL, 0, errmsg);
1718       return false;
1719    }
1720    file_size = 0;
1721
1722    if (!is_tape()) {
1723       return true;
1724    }
1725    if (!can_append()) {
1726       Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1727       Emsg0(M_FATAL, 0, errmsg);
1728       return false;
1729    }
1730
1731    clear_eof();
1732    clear_eot();
1733    mt_com.mt_op = MTWEOF;
1734    mt_com.mt_count = num;
1735    stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1736    if (stat == 0) {
1737       block_num = 0;
1738       file += num;
1739       file_addr = 0;
1740    } else {
1741       berrno be;
1742       clrerror(MTWEOF);
1743       if (stat == -1) {
1744          Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1745             print_name(), be.bstrerror());
1746        }
1747    }
1748    return stat == 0;
1749 }
1750
1751
1752 /*
1753  * If implemented in system, clear the tape
1754  * error status.
1755  */
1756 void DEVICE::clrerror(int func)
1757 {
1758    const char *msg = NULL;
1759    char buf[100];
1760
1761    dev_errno = errno;         /* save errno */
1762    if (errno == EIO) {
1763       VolCatInfo.VolCatErrors++;
1764    }
1765
1766    if (!is_tape()) {
1767       return;
1768    }
1769
1770    if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1771       switch (func) {
1772       case -1:
1773          break;                  /* ignore message printed later */
1774       case MTWEOF:
1775          msg = "WTWEOF";
1776          clear_cap(CAP_EOF);     /* turn off feature */
1777          break;
1778 #ifdef MTEOM
1779       case MTEOM:
1780          msg = "WTEOM";
1781          clear_cap(CAP_EOM);     /* turn off feature */
1782          break;
1783 #endif
1784       case MTFSF:
1785          msg = "MTFSF";
1786          clear_cap(CAP_FSF);     /* turn off feature */
1787          break;
1788       case MTBSF:
1789          msg = "MTBSF";
1790          clear_cap(CAP_BSF);     /* turn off feature */
1791          break;
1792       case MTFSR:
1793          msg = "MTFSR";
1794          clear_cap(CAP_FSR);     /* turn off feature */
1795          break;
1796       case MTBSR:
1797          msg = "MTBSR";
1798          clear_cap(CAP_BSR);     /* turn off feature */
1799          break;
1800       case MTREW:
1801          msg = "MTREW";
1802          break;
1803 #ifdef MTSETBLK
1804       case MTSETBLK:
1805          msg = "MTSETBLK";
1806          break;
1807 #endif
1808 #ifdef MTSETDRVBUFFER
1809       case MTSETDRVBUFFER:
1810          msg = "MTSETDRVBUFFER";
1811          break;
1812 #endif
1813 #ifdef MTRESET
1814       case MTRESET:
1815          msg = "MTRESET";
1816          break;
1817 #endif
1818
1819 #ifdef MTSETBSIZ
1820       case MTSETBSIZ:
1821          msg = "MTSETBSIZ";
1822          break;
1823 #endif
1824 #ifdef MTSRSZ
1825       case MTSRSZ:
1826          msg = "MTSRSZ";
1827          break;
1828 #endif
1829 #ifdef MTLOAD
1830       case MTLOAD:
1831          msg = "MTLOAD";
1832          break;
1833 #endif
1834 #ifdef MTUNLOCK
1835       case MTUNLOCK:
1836          msg = "MTUNLOCK";
1837          break;
1838 #endif
1839       case MTOFFL:
1840          msg = "MTOFFL";
1841          break;
1842       default:
1843          bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1844          msg = buf;
1845          break;
1846       }
1847       if (msg != NULL) {
1848          dev_errno = ENOSYS;
1849          Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1850          Emsg0(M_ERROR, 0, errmsg);
1851       }
1852    }
1853
1854    /*
1855     * Now we try different methods of clearing the error
1856     *  status on the drive so that it is not locked for
1857     *  further operations.
1858     */
1859
1860    /* On some systems such as NetBSD, this clears all errors */
1861    get_os_tape_file();
1862
1863 /* Found on Solaris */
1864 #ifdef MTIOCLRERR
1865 {
1866    d_ioctl(m_fd, MTIOCLRERR);
1867    Dmsg0(200, "Did MTIOCLRERR\n");
1868 }
1869 #endif
1870
1871 /* Typically on FreeBSD */
1872 #ifdef MTIOCERRSTAT
1873 {
1874   berrno be;
1875    /* Read and clear SCSI error status */
1876    union mterrstat mt_errstat;
1877    Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1878       be.bstrerror(dev_errno));
1879    d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1880 }
1881 #endif
1882
1883 /* Clear Subsystem Exception OSF1 */
1884 #ifdef MTCSE
1885 {
1886    struct mtop mt_com;
1887    mt_com.mt_op = MTCSE;
1888    mt_com.mt_count = 1;
1889    /* Clear any error condition on the tape */
1890    d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1891    Dmsg0(200, "Did MTCSE\n");
1892 }
1893 #endif
1894 }
1895
1896
1897 /*
1898  * Set to unload the current volume in the drive
1899  */
1900 void DEVICE::set_unload()
1901 {
1902    if (!m_unload && VolHdr.VolumeName[0] != 0) {
1903        m_unload = true;
1904        memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1905    }
1906 }
1907
1908
1909 /*
1910  * Clear volume header
1911  */
1912 void DEVICE::clear_volhdr()
1913 {
1914    Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1915    memset(&VolHdr, 0, sizeof(VolHdr));
1916 }
1917
1918
1919 /*
1920  * Close the device
1921  */
1922 void DEVICE::close()
1923 {
1924    Dmsg1(100, "close_dev %s\n", print_name());
1925    if (has_cap(CAP_OFFLINEUNMOUNT)) {
1926       offline();
1927    }
1928
1929    if (!is_open()) {
1930       Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1931          VolHdr.VolumeName);
1932       return;                         /* already closed */
1933    }
1934
1935    switch (dev_type) {
1936    case B_VTL_DEV:
1937    case B_VTAPE_DEV:
1938    case B_TAPE_DEV:
1939       unlock_door();
1940    default:
1941       d_close(m_fd);
1942       break;
1943    }
1944
1945    unmount(1);                        /* do unmount if required */
1946
1947    /* Clean up device packet so it can be reused */
1948    clear_opened();
1949    /*
1950     * Be careful not to clear items needed by the DVD driver
1951     *    when it is closing a single part.
1952     */
1953    state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1954               ST_MOUNTED|ST_MEDIA|ST_SHORT);
1955    label_type = B_BACULA_LABEL;
1956    file = block_num = 0;
1957    file_size = 0;
1958    file_addr = 0;
1959    EndFile = EndBlock = 0;
1960    openmode = 0;
1961    clear_volhdr();
1962    memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1963    if (tid) {
1964       stop_thread_timer(tid);
1965       tid = 0;
1966    }
1967 }
1968
1969 /*
1970  * This call closes the device, but it is used in DVD handling
1971  *  where we close one part and then open the next part. The
1972  *  difference between close_part() and close() is that close_part()
1973  *  saves the state information of the device (e.g. the Volume lable,
1974  *  the Volume Catalog record, ...  This permits opening and closing
1975  *  the Volume parts multiple times without losing track of what the
1976  *  main Volume parameters are.
1977  */
1978 void DEVICE::close_part(DCR * /*dcr*/)
1979 {
1980    VOLUME_LABEL saveVolHdr;
1981    VOLUME_CAT_INFO saveVolCatInfo;     /* Volume Catalog Information */
1982
1983
1984    saveVolHdr = VolHdr;               /* structure assignment */
1985    saveVolCatInfo = VolCatInfo;       /* structure assignment */
1986    close();                           /* close current part */
1987    VolHdr = saveVolHdr;               /* structure assignment */
1988    VolCatInfo = saveVolCatInfo;       /* structure assignment */
1989 }
1990
1991 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1992 {
1993    switch (dev_type) {
1994    case B_DVD_DEV:
1995       return lseek_dvd(dcr, offset, whence);
1996    case B_FILE_DEV:
1997 #if defined(HAVE_WIN32)
1998       return ::_lseeki64(m_fd, (__int64)offset, whence);
1999 #else
2000       return ::lseek(m_fd, offset, whence);
2001 #endif
2002    }
2003    return -1;
2004 }
2005
2006
2007 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
2008 {
2009    struct stat st;
2010
2011    Dmsg1(100, "truncate %s\n", print_name());
2012    switch (dev_type) {
2013    case B_VTL_DEV:
2014    case B_VTAPE_DEV:
2015    case B_TAPE_DEV:
2016       /* maybe we should rewind and write and eof ???? */
2017       return true;                    /* we don't really truncate tapes */
2018    case B_DVD_DEV:
2019       return truncate_dvd(dcr);
2020    case B_FILE_DEV:
2021       if (ftruncate(m_fd, 0) != 0) {
2022          berrno be;
2023          Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2024                print_name(), be.bstrerror());
2025          return false;
2026       }
2027
2028       /*
2029        * Check for a successful ftruncate() and issue a work-around for devices
2030        * (mostly cheap NAS) that don't support truncation.
2031        * Workaround supplied by Martin Schmid as a solution to bug #1011.
2032        * 1. close file
2033        * 2. delete file
2034        * 3. open new file with same mode
2035        * 4. change ownership to original
2036        */
2037
2038       if (fstat(m_fd, &st) != 0) {
2039          berrno be;
2040          Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2041                print_name(), be.bstrerror());
2042          return false;
2043       }
2044
2045       if (st.st_size != 0) {             /* ftruncate() didn't work */
2046          POOL_MEM archive_name(PM_FNAME);
2047
2048          pm_strcpy(archive_name, dev_name);
2049          if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2050             pm_strcat(archive_name, "/");
2051          }
2052          pm_strcat(archive_name, dcr->VolumeName);
2053
2054          Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2055                print_name(), archive_name.c_str());
2056
2057          /* Close file and blow it away */
2058          ::close(m_fd);
2059          ::unlink(archive_name.c_str());
2060
2061          /* Recreate the file -- of course, empty */
2062          set_mode(CREATE_READ_WRITE);
2063          if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2064             berrno be;
2065             dev_errno = errno;
2066             Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2067                   be.bstrerror());
2068             Dmsg1(100, "reopen failed: %s", errmsg);
2069             Emsg0(M_FATAL, 0, errmsg);
2070             return false;
2071          }
2072
2073          /* Reset proper owner */
2074          chown(archive_name.c_str(), st.st_uid, st.st_gid);
2075       }
2076
2077       return true;
2078    }
2079    return false;
2080 }
2081
2082 /*
2083  * Mount the device.
2084  * If timeout, wait until the mount command returns 0.
2085  * If !timeout, try to mount the device only once.
2086  */
2087 bool DEVICE::mount(int timeout)
2088 {
2089    Dmsg0(190, "Enter mount\n");
2090
2091    if (is_mounted()) {
2092       return true;
2093    }
2094
2095    switch (dev_type) {
2096    case B_VTL_DEV:
2097    case B_VTAPE_DEV:
2098    case B_TAPE_DEV:
2099       if (device->mount_command) {
2100          return do_tape_mount(1, timeout);
2101       }
2102       break;
2103    case B_FILE_DEV:
2104    case B_DVD_DEV:
2105       if (requires_mount() && device->mount_command) {
2106          return do_file_mount(1, timeout);
2107       }
2108       break;
2109    default:
2110       break;
2111    }
2112
2113    return true;
2114 }
2115
2116 /*
2117  * Unmount the device
2118  * If timeout, wait until the unmount command returns 0.
2119  * If !timeout, try to unmount the device only once.
2120  */
2121 bool DEVICE::unmount(int timeout)
2122 {
2123    Dmsg0(100, "Enter unmount\n");
2124
2125    if (!is_mounted()) {
2126       return true;
2127    }
2128
2129    switch (dev_type) {
2130    case B_VTL_DEV:
2131    case B_VTAPE_DEV:
2132    case B_TAPE_DEV:
2133       if (device->unmount_command) {
2134          return do_tape_mount(0, timeout);
2135       }
2136       break;
2137    case B_FILE_DEV:
2138    case B_DVD_DEV:
2139       if (requires_mount() && device->unmount_command) {
2140          return do_file_mount(0, timeout);
2141       }
2142       break;
2143    default:
2144       break;
2145    }
2146
2147    return true;
2148 }
2149
2150 /*
2151  * (Un)mount the device (for tape devices)
2152  */
2153 bool DEVICE::do_tape_mount(int mount, int dotimeout)
2154 {
2155    POOL_MEM ocmd(PM_FNAME);
2156    POOLMEM *results;
2157    char *icmd;
2158    int status, tries;
2159    berrno be;
2160
2161    Dsm_check(1);
2162    if (mount) {
2163       icmd = device->mount_command;
2164    } else {
2165       icmd = device->unmount_command;
2166    }
2167
2168    edit_mount_codes(ocmd, icmd);
2169
2170    Dmsg2(100, "do_tape_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2171
2172    if (dotimeout) {
2173       /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2174       tries = 10;
2175    } else {
2176       tries = 1;
2177    }
2178    results = get_memory(4000);
2179
2180    /* If busy retry each second */
2181    Dmsg1(100, "do_tape_mount run_prog=%s\n", ocmd.c_str());
2182    while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2183       if (tries-- > 0) {
2184          continue;
2185       }
2186
2187       Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2188            (mount ? "" : "un"), status, results, be.bstrerror(status));
2189       Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2190            print_name(), (mount ? "" : "un"), be.bstrerror(status));
2191
2192       set_mounted(false);
2193       free_pool_memory(results);
2194       Dmsg0(200, "============ mount=0\n");
2195       Dsm_check(1);
2196       return false;
2197    }
2198
2199    set_mounted(mount);              /* set/clear mounted flag */
2200    free_pool_memory(results);
2201    Dmsg1(200, "============ mount=%d\n", mount);
2202    return true;
2203 }
2204
2205 /*
2206  * (Un)mount the device (either a FILE or DVD device)
2207  */
2208 bool DEVICE::do_file_mount(int mount, int dotimeout)
2209 {
2210    POOL_MEM ocmd(PM_FNAME);
2211    POOLMEM *results;
2212    DIR* dp;
2213    char *icmd;
2214    struct dirent *entry, *result;
2215    int status, tries, name_max, count;
2216    berrno be;
2217
2218    Dsm_check(1);
2219    if (mount) {
2220       icmd = device->mount_command;
2221    } else {
2222       icmd = device->unmount_command;
2223    }
2224
2225    clear_freespace_ok();
2226    edit_mount_codes(ocmd, icmd);
2227
2228    Dmsg2(100, "do_file_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2229
2230    if (dotimeout) {
2231       /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2232       tries = 10;
2233    } else {
2234       tries = 1;
2235    }
2236    results = get_memory(4000);
2237
2238    /* If busy retry each second */
2239    Dmsg1(100, "do_file_mount run_prog=%s\n", ocmd.c_str());
2240    while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2241       /* Doesn't work with internationalization (This is not a problem) */
2242       if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2243          break;
2244       }
2245       if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2246          break;
2247       }
2248       if (tries-- > 0) {
2249          /* Sometimes the device cannot be mounted because it is already mounted.
2250           * Try to unmount it, then remount it */
2251          if (mount) {
2252             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2253             do_file_mount(0, 0);
2254          }
2255          bmicrosleep(1, 0);
2256          continue;
2257       }
2258       Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2259            (mount ? "" : "un"), status, results, be.bstrerror(status));
2260       Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2261            print_name(), (mount ? "" : "un"), be.bstrerror(status));
2262
2263       /*
2264        * Now, just to be sure it is not mounted, try to read the filesystem.
2265        */
2266       name_max = pathconf(".", _PC_NAME_MAX);
2267       if (name_max < 1024) {
2268          name_max = 1024;
2269       }
2270
2271       if (!(dp = opendir(device->mount_point))) {
2272          berrno be;
2273          dev_errno = errno;
2274          Dmsg3(100, "do_file_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2275                device->mount_point, print_name(), be.bstrerror());
2276          goto get_out;
2277       }
2278
2279       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2280       count = 0;
2281       while (1) {
2282          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2283             dev_errno = EIO;
2284             Dmsg2(129, "do_file_mount: failed to find suitable file in dir %s (dev=%s)\n",
2285                   device->mount_point, print_name());
2286             break;
2287          }
2288          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2289             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2290             break;
2291          } else {
2292             Dmsg2(129, "do_file_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2293          }
2294       }
2295       free(entry);
2296       closedir(dp);
2297
2298       Dmsg1(100, "do_file_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2299
2300       if (count > 0) {
2301          /* If we got more than ., .. and .keep */
2302          /*   there must be something mounted */
2303          if (mount) {
2304             Dmsg1(100, "Did Mount by count=%d\n", count);
2305             break;
2306          } else {
2307             /* An unmount request. We failed to unmount - report an error */
2308             set_mounted(true);
2309             free_pool_memory(results);
2310             Dmsg0(200, "== error mount=1 wanted unmount\n");
2311             return false;
2312          }
2313       }
2314 get_out:
2315       set_mounted(false);
2316       free_pool_memory(results);
2317       Dmsg0(200, "============ mount=0\n");
2318       Dsm_check(1);
2319       return false;
2320    }
2321
2322    set_mounted(mount);              /* set/clear mounted flag */
2323    free_pool_memory(results);
2324    /* Do not check free space when unmounting */
2325    if (mount && !update_freespace()) {
2326       return false;
2327    }
2328    Dmsg1(200, "============ mount=%d\n", mount);
2329    return true;
2330 }
2331
2332 /*
2333  * Edit codes into (Un)MountCommand, Write(First)PartCommand
2334  *  %% = %
2335  *  %a = archive device name
2336  *  %e = erase (set if cannot mount and first part)
2337  *  %n = part number
2338  *  %m = mount point
2339  *  %v = last part name
2340  *
2341  *  omsg = edited output message
2342  *  imsg = input string containing edit codes (%x)
2343  *
2344  */
2345 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2346 {
2347    const char *p;
2348    const char *str;
2349    char add[20];
2350
2351    POOL_MEM archive_name(PM_FNAME);
2352
2353    omsg.c_str()[0] = 0;
2354    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2355    for (p=imsg; *p; p++) {
2356       if (*p == '%') {
2357          switch (*++p) {
2358          case '%':
2359             str = "%";
2360             break;
2361          case 'a':
2362             str = dev_name;
2363             break;
2364          case 'e':
2365             if (num_dvd_parts == 0) {
2366                if (truncating || blank_dvd) {
2367                   str = "2";
2368                } else {
2369                   str = "1";
2370                }
2371             } else {
2372                str = "0";
2373             }
2374             break;
2375          case 'n':
2376             bsnprintf(add, sizeof(add), "%d", part);
2377             str = add;
2378             break;
2379          case 'm':
2380             str = device->mount_point;
2381             break;
2382          case 'v':
2383             make_spooled_dvd_filename(this, archive_name);
2384             str = archive_name.c_str();
2385             break;
2386          default:
2387             add[0] = '%';
2388             add[1] = *p;
2389             add[2] = 0;
2390             str = add;
2391             break;
2392          }
2393       } else {
2394          add[0] = *p;
2395          add[1] = 0;
2396          str = add;
2397       }
2398       Dmsg1(1900, "add_str %s\n", str);
2399       pm_strcat(omsg, (char *)str);
2400       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2401    }
2402 }
2403
2404 /* return the last timer interval (ms)
2405  * or 0 if something goes wrong
2406  */
2407 btime_t DEVICE::get_timer_count()
2408 {
2409    btime_t temp = last_timer;
2410    last_timer = get_current_btime();
2411    temp = last_timer - temp;   /* get elapsed time */
2412    return (temp>0)?temp:0;     /* take care of skewed clock */
2413 }
2414
2415 /* read from fd */
2416 ssize_t DEVICE::read(void *buf, size_t len)
2417 {
2418    ssize_t read_len ;
2419
2420    get_timer_count();
2421
2422    read_len = d_read(m_fd, buf, len);
2423
2424    last_tick = get_timer_count();
2425
2426    DevReadTime += last_tick;
2427    VolCatInfo.VolReadTime += last_tick;
2428
2429    if (read_len > 0) {          /* skip error */
2430       DevReadBytes += read_len;
2431    }
2432
2433    return read_len;
2434 }
2435
2436 /* write to fd */
2437 ssize_t DEVICE::write(const void *buf, size_t len)
2438 {
2439    ssize_t write_len ;
2440
2441    get_timer_count();
2442
2443    write_len = d_write(m_fd, buf, len);
2444
2445    last_tick = get_timer_count();
2446
2447    DevWriteTime += last_tick;
2448    VolCatInfo.VolWriteTime += last_tick;
2449
2450    if (write_len > 0) {         /* skip error */
2451       DevWriteBytes += write_len;
2452    }
2453
2454    return write_len;
2455 }
2456
2457 /* Return the resource name for the device */
2458 const char *DEVICE::name() const
2459 {
2460    return device->hdr.name;
2461 }
2462
2463 /* Returns file position on tape or -1 */
2464 int32_t DEVICE::get_os_tape_file()
2465 {
2466    struct mtget mt_stat;
2467
2468    if (has_cap(CAP_MTIOCGET) &&
2469        d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2470       return mt_stat.mt_fileno;
2471    }
2472    return -1;
2473 }
2474
2475 char *
2476 dev_vol_name(DEVICE *dev)
2477 {
2478    return dev->VolCatInfo.VolCatName;
2479 }
2480
2481
2482 /*
2483  * Free memory allocated for the device
2484  */
2485 void DEVICE::term(void)
2486 {
2487    Dmsg1(900, "term dev: %s\n", print_name());
2488    close();
2489    if (dev_name) {
2490       free_memory(dev_name);
2491       dev_name = NULL;
2492    }
2493    if (prt_name) {
2494       free_memory(prt_name);
2495       prt_name = NULL;
2496    }
2497    if (errmsg) {
2498       free_pool_memory(errmsg);
2499       errmsg = NULL;
2500    }
2501    pthread_mutex_destroy(&m_mutex);
2502    pthread_cond_destroy(&wait);
2503    pthread_cond_destroy(&wait_next_vol);
2504    pthread_mutex_destroy(&spool_mutex);
2505 // rwl_destroy(&lock);
2506    if (attached_dcrs) {
2507       delete attached_dcrs;
2508       attached_dcrs = NULL;
2509    }
2510    if (device) {
2511       device->dev = NULL;
2512    }
2513    free((char *)this);
2514 }
2515
2516 /*
2517  * This routine initializes the device wait timers
2518  */
2519 void init_device_wait_timers(DCR *dcr)
2520 {
2521    DEVICE *dev = dcr->dev;
2522    JCR *jcr = dcr->jcr;
2523
2524    /* ******FIXME******* put these on config variables */
2525    dev->min_wait = 60 * 60;
2526    dev->max_wait = 24 * 60 * 60;
2527    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2528    dev->wait_sec = dev->min_wait;
2529    dev->rem_wait_sec = dev->wait_sec;
2530    dev->num_wait = 0;
2531    dev->poll = false;
2532
2533    jcr->min_wait = 60 * 60;
2534    jcr->max_wait = 24 * 60 * 60;
2535    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2536    jcr->wait_sec = jcr->min_wait;
2537    jcr->rem_wait_sec = jcr->wait_sec;
2538    jcr->num_wait = 0;
2539
2540 }
2541
2542 void init_jcr_device_wait_timers(JCR *jcr)
2543 {
2544    /* ******FIXME******* put these on config variables */
2545    jcr->min_wait = 60 * 60;
2546    jcr->max_wait = 24 * 60 * 60;
2547    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2548    jcr->wait_sec = jcr->min_wait;
2549    jcr->rem_wait_sec = jcr->wait_sec;
2550    jcr->num_wait = 0;
2551 }
2552
2553
2554 /*
2555  * The dev timers are used for waiting on a particular device
2556  *
2557  * Returns: true if time doubled
2558  *          false if max time expired
2559  */
2560 bool double_dev_wait_time(DEVICE *dev)
2561 {
2562    dev->wait_sec *= 2;               /* double wait time */
2563    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2564       dev->wait_sec = dev->max_wait;
2565    }
2566    dev->num_wait++;
2567    dev->rem_wait_sec = dev->wait_sec;
2568    if (dev->num_wait >= dev->max_num_wait) {
2569       return false;
2570    }
2571    return true;
2572 }
2573
2574
2575 void set_os_device_parameters(DCR *dcr)
2576 {
2577    DEVICE *dev = dcr->dev;
2578
2579    if (strcmp(dev->dev_name, "/dev/null") == 0) {
2580       return;                            /* no use trying to set /dev/null */
2581    }
2582
2583 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2584    struct mtop mt_com;
2585
2586    Dmsg0(100, "In set_os_device_parameters\n");
2587 #if defined(MTSETBLK)
2588    if (dev->min_block_size == dev->max_block_size &&
2589        dev->min_block_size == 0) {    /* variable block mode */
2590       mt_com.mt_op = MTSETBLK;
2591       mt_com.mt_count = 0;
2592       Dmsg0(100, "Set block size to zero\n");
2593       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2594          dev->clrerror(MTSETBLK);
2595       }
2596    }
2597 #endif
2598 #if defined(MTSETDRVBUFFER)
2599    if (getuid() == 0) {          /* Only root can do this */
2600       mt_com.mt_op = MTSETDRVBUFFER;
2601       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2602       if (!dev->has_cap(CAP_TWOEOF)) {
2603          mt_com.mt_count |= MT_ST_TWO_FM;
2604       }
2605       if (dev->has_cap(CAP_EOM)) {
2606          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2607       }
2608       Dmsg0(100, "MTSETDRVBUFFER\n");
2609       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2610          dev->clrerror(MTSETDRVBUFFER);
2611       }
2612    }
2613 #endif
2614    return;
2615 #endif
2616
2617 #ifdef HAVE_NETBSD_OS
2618    struct mtop mt_com;
2619    if (dev->min_block_size == dev->max_block_size &&
2620        dev->min_block_size == 0) {    /* variable block mode */
2621       mt_com.mt_op = MTSETBSIZ;
2622       mt_com.mt_count = 0;
2623       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2624          dev->clrerror(MTSETBSIZ);
2625       }
2626       /* Get notified at logical end of tape */
2627       mt_com.mt_op = MTEWARN;
2628       mt_com.mt_count = 1;
2629       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2630          dev->clrerror(MTEWARN);
2631       }
2632    }
2633    return;
2634 #endif
2635
2636 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2637    struct mtop mt_com;
2638    if (dev->min_block_size == dev->max_block_size &&
2639        dev->min_block_size == 0) {    /* variable block mode */
2640       mt_com.mt_op = MTSETBSIZ;
2641       mt_com.mt_count = 0;
2642       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2643          dev->clrerror(MTSETBSIZ);
2644       }
2645    }
2646 #if defined(MTIOCSETEOTMODEL)
2647    uint32_t neof;
2648    if (dev->has_cap(CAP_TWOEOF)) {
2649       neof = 2;
2650    } else {
2651       neof = 1;
2652    }
2653    if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2654       berrno be;
2655       dev->dev_errno = errno;         /* save errno */
2656       Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2657             dev->print_name(), be.bstrerror(dev->dev_errno));
2658       Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2659    }
2660 #endif
2661    return;
2662 #endif
2663
2664 #ifdef HAVE_SUN_OS
2665    struct mtop mt_com;
2666    if (dev->min_block_size == dev->max_block_size &&
2667        dev->min_block_size == 0) {    /* variable block mode */
2668       mt_com.mt_op = MTSRSZ;
2669       mt_com.mt_count = 0;
2670       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2671          dev->clrerror(MTSRSZ);
2672       }
2673    }
2674    return;
2675 #endif
2676 }
2677
2678 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2679 {
2680    Dmsg0(100, "dev_get_os_pos\n");
2681    return dev->has_cap(CAP_MTIOCGET) &&
2682           dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2683           mt_stat->mt_fileno >= 0;
2684 }
2685
2686 static const char *modes[] = {
2687    "CREATE_READ_WRITE",
2688    "OPEN_READ_WRITE",
2689    "OPEN_READ_ONLY",
2690    "OPEN_WRITE_ONLY"
2691 };
2692
2693
2694 static const char *mode_to_str(int mode)
2695 {
2696    static char buf[100];
2697    if (mode < 1 || mode > 4) {
2698       bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2699       return buf;
2700     }
2701    return modes[mode-1];
2702 }