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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2010 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  */
  51
  52 /*
  53  * Handling I/O errors and end of tape conditions are a bit tricky.
  54  * This is how it is currently done when writing.
  55  * On either an I/O error or end of tape,
  56  * we will stop writing on the physical device (no I/O recovery is
  57  * attempted at least in this daemon). The state flag will be sent
  58  * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
  59  * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
  60  * cleared only when the problem goes away.  Now when ST_WEOT
  61  * is set all calls to write_block_to_device() call the fix_up
  62  * routine. In addition, all threads are blocked
  63  * from writing on the tape by calling lock_dev(), and thread other
  64  * than the first thread to hit the EOT will block on a condition
  65  * variable. The first thread to hit the EOT will continue to
  66  * be able to read and write the tape (he sort of tunnels through
  67  * the locking mechanism -- see lock_dev() for details).
  68  *
  69  * Now presumably somewhere higher in the chain of command
  70  * (device.c), someone will notice the EOT condition and
  71  * get a new tape up, get the tape label read, and mark
  72  * the label for rewriting. Then this higher level routine
  73  * will write the unwritten buffer to the new volume.
  74  * Finally, he will release
  75  * any blocked threads by doing a broadcast on the condition
  76  * variable.  At that point, we should be totally back in
  77  * business with no lost data.
  78  */
  79
  80
  81 #include "bacula.h"
  82 #include "stored.h"
  83
  84 #ifndef O_NONBLOCK
  85 #define O_NONBLOCK 0
  86 #endif
  87
  88 /* Forward referenced functions */
  89 void set_os_device_parameters(DCR *dcr);
  90 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
  91 static const char *mode_to_str(int mode);
  92
  93 /*
  94  * Allocate and initialize the DEVICE structure
  95  * Note, if dev is non-NULL, it is already allocated,
  96  * thus we neither allocate it nor free it. This allows
  97  * the caller to put the packet in shared memory.
  98  *
  99  *  Note, for a tape, the device->device_name is the device name
 100  *     (e.g. /dev/nst0), and for a file, the device name
 101  *     is the directory in which the file will be placed.
 102  *
 103  */
 104 DEVICE *
 105 init_dev(JCR *jcr, DEVRES *device)
 106 {
 107    struct stat statp;
 108    int errstat;
 109    DCR *dcr = NULL;
 110    DEVICE *dev;
 111    uint32_t max_bs;
 112
 113
 114    /* If no device type specified, try to guess */
 115    if (!device->dev_type) {
 116       /* Check that device is available */
 117       if (stat(device->device_name, &statp) < 0) {
 118          berrno be;
 119          Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
 120             device->device_name, be.bstrerror());
 121          return NULL;
 122       }
 123       if (S_ISDIR(statp.st_mode)) {
 124          device->dev_type = B_FILE_DEV;
 125       } else if (S_ISCHR(statp.st_mode)) {
 126          device->dev_type = B_TAPE_DEV;
 127       } else if (S_ISFIFO(statp.st_mode)) {
 128          device->dev_type = B_FIFO_DEV;
 129 #ifdef USE_VTAPE
 130       /* must set DeviceType = Vtape
 131        * in normal mode, autodetection is disabled
 132        */
 133       } else if (S_ISREG(statp.st_mode)) {
 134          device->dev_type = B_VTAPE_DEV;
 135 #endif
 136       } else if (!(device->cap_bits & CAP_REQMOUNT)) {
 137          Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
 138                " or have RequiresMount=yes for DVD. st_mode=%x\n"),
 139             device->device_name, statp.st_mode);
 140          return NULL;
 141       } else {
 142          device->dev_type = B_DVD_DEV;
 143       }
 144    }
 145
 146    dev = (DEVICE *)malloc(sizeof(DEVICE));
 147    memset(dev, 0, sizeof(DEVICE));
 148    dev->clear_slot();         /* unknown */
 149
 150    /* Copy user supplied device parameters from Resource */
 151    dev->dev_name = get_memory(strlen(device->device_name)+1);
 152    pm_strcpy(dev->dev_name, device->device_name);
 153    dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
 154    /* We edit "Resource-name" (physical-name) */
 155    Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
 156    Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
 157    dev->capabilities = device->cap_bits;
 158    dev->min_block_size = device->min_block_size;
 159    dev->max_block_size = device->max_block_size;
 160    dev->max_volume_size = device->max_volume_size;
 161    dev->max_file_size = device->max_file_size;
 162    dev->max_concurrent_jobs = device->max_concurrent_jobs;
 163    dev->volume_capacity = device->volume_capacity;
 164    dev->max_rewind_wait = device->max_rewind_wait;
 165    dev->max_open_wait = device->max_open_wait;
 166    dev->max_open_vols = device->max_open_vols;
 167    dev->vol_poll_interval = device->vol_poll_interval;
 168    dev->max_spool_size = device->max_spool_size;
 169    dev->drive_index = device->drive_index;
 170    dev->autoselect = device->autoselect;
 171    dev->dev_type = device->dev_type;
 172    dev->init_backend();
 173    if (dev->is_tape()) { /* No parts on tapes */
 174       dev->max_part_size = 0;
 175    } else {
 176       dev->max_part_size = device->max_part_size;
 177    }
 178    /* Sanity check */
 179    if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
 180       dev->vol_poll_interval = 60;
 181    }
 182    /* Link the dev and device structures together */
 183    dev->device = device;
 184    device->dev = dev;
 185
 186    if (dev->is_fifo()) {
 187       dev->capabilities |= CAP_STREAM; /* set stream device */
 188    }
 189
 190    /* If the device requires mount :
 191     * - Check that the mount point is available
 192     * - Check that (un)mount commands are defined
 193     */
 194    if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
 195       if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
 196          berrno be;
 197          dev->dev_errno = errno;
 198          Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
 199             device->mount_point, be.bstrerror());
 200       }
 201
 202       if (!device->mount_command || !device->unmount_command) {
 203          Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
 204       }
 205    }
 206    if (dev->is_dvd()) {
 207       if (!device->write_part_command) {
 208          Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
 209       }
 210    }
 211
 212    /* Sanity check */
 213    if (dev->max_block_size == 0) {
 214       max_bs = DEFAULT_BLOCK_SIZE;
 215    } else {
 216       max_bs = dev->max_block_size;
 217    }
 218    if (dev->min_block_size > max_bs) {
 219       Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
 220            dev->print_name());
 221    }
 222    if (dev->max_block_size > 4096000) {
 223       Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
 224          dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
 225       dev->max_block_size = 0;
 226    }
 227    if (dev->max_block_size % TAPE_BSIZE != 0) {
 228       Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
 229          dev->max_block_size, dev->print_name());
 230    }
 231    if (dev->max_volume_size != 0 && dev->max_volume_size < (dev->max_block_size << 4)) {
 232       Jmsg(jcr, M_ERROR_TERM, 0, _("Max Vol Size < 8 * Max Block Size on device %s\n"),
 233            dev->print_name());
 234    }
 235
 236    dev->errmsg = get_pool_memory(PM_EMSG);
 237    *dev->errmsg = 0;
 238
 239    if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
 240       berrno be;
 241       dev->dev_errno = errstat;
 242       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
 243       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 244    }
 245    if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
 246       berrno be;
 247       dev->dev_errno = errstat;
 248       Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
 249       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 250    }
 251    if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
 252       berrno be;
 253       dev->dev_errno = errstat;
 254       Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
 255       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 256    }
 257    if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
 258       berrno be;
 259       dev->dev_errno = errstat;
 260       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
 261       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 262    }
 263    if ((errstat = pthread_mutex_init(&dev->acquire_mutex, NULL)) != 0) {
 264       berrno be;
 265       dev->dev_errno = errstat;
 266       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
 267       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 268    }
 269    /* Ensure that we respect this order in P/V operations */
 270    bthread_mutex_set_priority(&dev->m_mutex,       PRIO_SD_DEV_ACCESS);
 271    bthread_mutex_set_priority(&dev->spool_mutex,   PRIO_SD_DEV_SPOOL);
 272    bthread_mutex_set_priority(&dev->acquire_mutex, PRIO_SD_DEV_ACQUIRE);
 273 #ifdef xxx
 274    if ((errstat = rwl_init(&dev->lock)) != 0) {
 275       berrno be;
 276       dev->dev_errno = errstat;
 277       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
 278       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 279    }
 280 #endif
 281
 282    dev->clear_opened();
 283    dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
 284    Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
 285    dev->initiated = true;
 286
 287    return dev;
 288 }
 289
 290 /* Choose the right backend */
 291 void DEVICE::init_backend()
 292 {
 293
 294 #ifdef HAVE_WIN32
 295    if (is_tape()) {
 296       d_open  = win32_tape_open;
 297       d_write = win32_tape_write;
 298       d_close = win32_tape_close;
 299       d_ioctl = win32_tape_ioctl;
 300       d_read  = win32_tape_read;
 301
 302    } else {
 303       d_open  = ::open;
 304       d_close = ::close;
 305       d_ioctl = win32_ioctl;    /* dummy function */
 306       d_write = win32_write;    /* win32 read/write are not POSIX */
 307       d_read  = win32_read;
 308    }
 309
 310 #else  /* POSIX / UNIX Interface */
 311    if (is_vtape()) {            /* test backend */
 312       d_open  = vtape_open;     /* vtape isn't available for WIN32 or FreeBSD */
 313       d_write = vtape_write;
 314       d_close = vtape_close;
 315       d_ioctl = vtape_ioctl;
 316       d_read  = vtape_read;
 317
 318    } else {                     /* tape and file are using normal io */
 319       d_open  = ::open;
 320       d_write = ::write;
 321       d_close = ::close;
 322       d_ioctl = ::ioctl;
 323       d_read  = ::read;
 324    }
 325 #endif
 326 }
 327
 328 /*
 329  * Open the device with the operating system and
 330  * initialize buffer pointers.
 331  *
 332  * Returns:  -1  on error
 333  *           fd  on success
 334  *
 335  * Note, for a tape, the VolName is the name we give to the
 336  *    volume (not really used here), but for a file, the
 337  *    VolName represents the name of the file to be created/opened.
 338  *    In the case of a file, the full name is the device name
 339  *    (archive_name) with the VolName concatenated.
 340  */
 341 int
 342 DEVICE::open(DCR *dcr, int omode)
 343 {
 344    int preserve = 0;
 345    if (is_open()) {
 346       if (openmode == omode) {
 347          return m_fd;
 348       } else {
 349          d_close(m_fd);
 350          clear_opened();
 351          Dmsg0(100, "Close fd for mode change.\n");
 352          preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
 353       }
 354    }
 355    if (dcr) {
 356       dcr->setVolCatName(dcr->VolumeName);
 357       VolCatInfo = dcr->VolCatInfo;    /* structure assign */
 358    }
 359
 360    Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
 361          print_name(), getVolCatName(), 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, getVolCatName());
 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->getVolCatName()
 563  *  (NB:??? I think it's getVolCatName() 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", getVolCatName());
 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    setVolCatInfo(false);
1917 }
1918
1919
1920 /*
1921  * Close the device
1922  */
1923 void DEVICE::close()
1924 {
1925    Dmsg1(100, "close_dev %s\n", print_name());
1926    offline_or_rewind();
1927
1928    if (!is_open()) {
1929       Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1930          VolHdr.VolumeName);
1931       return;                         /* already closed */
1932    }
1933
1934    switch (dev_type) {
1935    case B_VTL_DEV:
1936    case B_VTAPE_DEV:
1937    case B_TAPE_DEV:
1938       unlock_door();
1939    default:
1940       d_close(m_fd);
1941       break;
1942    }
1943
1944    unmount(1);                        /* do unmount if required */
1945
1946    /* Clean up device packet so it can be reused */
1947    clear_opened();
1948    /*
1949     * Be careful not to clear items needed by the DVD driver
1950     *    when it is closing a single part.
1951     */
1952    state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1953               ST_MOUNTED|ST_MEDIA|ST_SHORT);
1954    label_type = B_BACULA_LABEL;
1955    file = block_num = 0;
1956    file_size = 0;
1957    file_addr = 0;
1958    EndFile = EndBlock = 0;
1959    openmode = 0;
1960    clear_volhdr();
1961    memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1962    if (tid) {
1963       stop_thread_timer(tid);
1964       tid = 0;
1965    }
1966 }
1967
1968 /*
1969  * This call closes the device, but it is used in DVD handling
1970  *  where we close one part and then open the next part. The
1971  *  difference between close_part() and close() is that close_part()
1972  *  saves the state information of the device (e.g. the Volume lable,
1973  *  the Volume Catalog record, ...  This permits opening and closing
1974  *  the Volume parts multiple times without losing track of what the
1975  *  main Volume parameters are.
1976  */
1977 void DEVICE::close_part(DCR * /*dcr*/)
1978 {
1979    VOLUME_LABEL saveVolHdr;
1980    VOLUME_CAT_INFO saveVolCatInfo;     /* Volume Catalog Information */
1981
1982
1983    saveVolHdr = VolHdr;               /* structure assignment */
1984    saveVolCatInfo = VolCatInfo;       /* structure assignment */
1985    close();                           /* close current part */
1986    VolHdr = saveVolHdr;               /* structure assignment */
1987    VolCatInfo = saveVolCatInfo;       /* structure assignment */
1988 }
1989
1990 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1991 {
1992    switch (dev_type) {
1993    case B_DVD_DEV:
1994       return lseek_dvd(dcr, offset, whence);
1995    case B_FILE_DEV:
1996 #if defined(HAVE_WIN32)
1997       return ::_lseeki64(m_fd, (__int64)offset, whence);
1998 #else
1999       return ::lseek(m_fd, offset, whence);
2000 #endif
2001    }
2002    return -1;
2003 }
2004
2005
2006 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
2007 {
2008    struct stat st;
2009
2010    Dmsg1(100, "truncate %s\n", print_name());
2011    switch (dev_type) {
2012    case B_VTL_DEV:
2013    case B_VTAPE_DEV:
2014    case B_TAPE_DEV:
2015       /* maybe we should rewind and write and eof ???? */
2016       return true;                    /* we don't really truncate tapes */
2017    case B_DVD_DEV:
2018       return truncate_dvd(dcr);
2019    case B_FILE_DEV:
2020       if (ftruncate(m_fd, 0) != 0) {
2021          berrno be;
2022          Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2023                print_name(), be.bstrerror());
2024          return false;
2025       }
2026
2027       /*
2028        * Check for a successful ftruncate() and issue a work-around for devices
2029        * (mostly cheap NAS) that don't support truncation.
2030        * Workaround supplied by Martin Schmid as a solution to bug #1011.
2031        * 1. close file
2032        * 2. delete file
2033        * 3. open new file with same mode
2034        * 4. change ownership to original
2035        */
2036
2037       if (fstat(m_fd, &st) != 0) {
2038          berrno be;
2039          Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2040                print_name(), be.bstrerror());
2041          return false;
2042       }
2043
2044       if (st.st_size != 0) {             /* ftruncate() didn't work */
2045          POOL_MEM archive_name(PM_FNAME);
2046
2047          pm_strcpy(archive_name, dev_name);
2048          if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2049             pm_strcat(archive_name, "/");
2050          }
2051          pm_strcat(archive_name, dcr->VolumeName);
2052
2053          Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2054                print_name(), archive_name.c_str());
2055
2056          /* Close file and blow it away */
2057          ::close(m_fd);
2058          ::unlink(archive_name.c_str());
2059
2060          /* Recreate the file -- of course, empty */
2061          set_mode(CREATE_READ_WRITE);
2062          if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2063             berrno be;
2064             dev_errno = errno;
2065             Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2066                   be.bstrerror());
2067             Dmsg1(100, "reopen failed: %s", errmsg);
2068             Emsg0(M_FATAL, 0, errmsg);
2069             return false;
2070          }
2071
2072          /* Reset proper owner */
2073          chown(archive_name.c_str(), st.st_uid, st.st_gid);
2074       }
2075
2076       return true;
2077    }
2078    return false;
2079 }
2080
2081 /*
2082  * Mount the device.
2083  * If timeout, wait until the mount command returns 0.
2084  * If !timeout, try to mount the device only once.
2085  */
2086 bool DEVICE::mount(int timeout)
2087 {
2088    Dmsg0(190, "Enter mount\n");
2089
2090    if (is_mounted()) {
2091       return true;
2092    }
2093
2094    switch (dev_type) {
2095    case B_VTL_DEV:
2096    case B_VTAPE_DEV:
2097    case B_TAPE_DEV:
2098       if (device->mount_command) {
2099          return do_tape_mount(1, timeout);
2100       }
2101       break;
2102    case B_FILE_DEV:
2103    case B_DVD_DEV:
2104       if (requires_mount() && device->mount_command) {
2105          return do_file_mount(1, timeout);
2106       }
2107       break;
2108    default:
2109       break;
2110    }
2111
2112    return true;
2113 }
2114
2115 /*
2116  * Unmount the device
2117  * If timeout, wait until the unmount command returns 0.
2118  * If !timeout, try to unmount the device only once.
2119  */
2120 bool DEVICE::unmount(int timeout)
2121 {
2122    Dmsg0(100, "Enter unmount\n");
2123
2124    if (!is_mounted()) {
2125       return true;
2126    }
2127
2128    switch (dev_type) {
2129    case B_VTL_DEV:
2130    case B_VTAPE_DEV:
2131    case B_TAPE_DEV:
2132       if (device->unmount_command) {
2133          return do_tape_mount(0, timeout);
2134       }
2135       break;
2136    case B_FILE_DEV:
2137    case B_DVD_DEV:
2138       if (requires_mount() && device->unmount_command) {
2139          return do_file_mount(0, timeout);
2140       }
2141       break;
2142    default:
2143       break;
2144    }
2145
2146    return true;
2147 }
2148
2149 /*
2150  * (Un)mount the device (for tape devices)
2151  */
2152 bool DEVICE::do_tape_mount(int mount, int dotimeout)
2153 {
2154    POOL_MEM ocmd(PM_FNAME);
2155    POOLMEM *results;
2156    char *icmd;
2157    int status, tries;
2158    berrno be;
2159
2160    Dsm_check(1);
2161    if (mount) {
2162       icmd = device->mount_command;
2163    } else {
2164       icmd = device->unmount_command;
2165    }
2166
2167    edit_mount_codes(ocmd, icmd);
2168
2169    Dmsg2(100, "do_tape_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2170
2171    if (dotimeout) {
2172       /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2173       tries = 10;
2174    } else {
2175       tries = 1;
2176    }
2177    results = get_memory(4000);
2178
2179    /* If busy retry each second */
2180    Dmsg1(100, "do_tape_mount run_prog=%s\n", ocmd.c_str());
2181    while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2182       if (tries-- > 0) {
2183          continue;
2184       }
2185
2186       Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2187            (mount ? "" : "un"), status, results, be.bstrerror(status));
2188       Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2189            print_name(), (mount ? "" : "un"), be.bstrerror(status));
2190
2191       set_mounted(false);
2192       free_pool_memory(results);
2193       Dmsg0(200, "============ mount=0\n");
2194       Dsm_check(1);
2195       return false;
2196    }
2197
2198    set_mounted(mount);              /* set/clear mounted flag */
2199    free_pool_memory(results);
2200    Dmsg1(200, "============ mount=%d\n", mount);
2201    return true;
2202 }
2203
2204 /*
2205  * (Un)mount the device (either a FILE or DVD device)
2206  */
2207 bool DEVICE::do_file_mount(int mount, int dotimeout)
2208 {
2209    POOL_MEM ocmd(PM_FNAME);
2210    POOLMEM *results;
2211    DIR* dp;
2212    char *icmd;
2213    struct dirent *entry, *result;
2214    int status, tries, name_max, count;
2215    berrno be;
2216
2217    Dsm_check(1);
2218    if (mount) {
2219       icmd = device->mount_command;
2220    } else {
2221       icmd = device->unmount_command;
2222    }
2223
2224    clear_freespace_ok();
2225    edit_mount_codes(ocmd, icmd);
2226
2227    Dmsg2(100, "do_file_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2228
2229    if (dotimeout) {
2230       /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2231       tries = 10;
2232    } else {
2233       tries = 1;
2234    }
2235    results = get_memory(4000);
2236
2237    /* If busy retry each second */
2238    Dmsg1(100, "do_file_mount run_prog=%s\n", ocmd.c_str());
2239    while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2240       /* Doesn't work with internationalization (This is not a problem) */
2241       if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2242          break;
2243       }
2244       if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2245          break;
2246       }
2247       if (tries-- > 0) {
2248          /* Sometimes the device cannot be mounted because it is already mounted.
2249           * Try to unmount it, then remount it */
2250          if (mount) {
2251             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2252             do_file_mount(0, 0);
2253          }
2254          bmicrosleep(1, 0);
2255          continue;
2256       }
2257       Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2258            (mount ? "" : "un"), status, results, be.bstrerror(status));
2259       Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2260            print_name(), (mount ? "" : "un"), be.bstrerror(status));
2261
2262       /*
2263        * Now, just to be sure it is not mounted, try to read the filesystem.
2264        */
2265       name_max = pathconf(".", _PC_NAME_MAX);
2266       if (name_max < 1024) {
2267          name_max = 1024;
2268       }
2269
2270       if (!(dp = opendir(device->mount_point))) {
2271          berrno be;
2272          dev_errno = errno;
2273          Dmsg3(100, "do_file_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2274                device->mount_point, print_name(), be.bstrerror());
2275          goto get_out;
2276       }
2277
2278       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2279       count = 0;
2280       while (1) {
2281          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2282             dev_errno = EIO;
2283             Dmsg2(129, "do_file_mount: failed to find suitable file in dir %s (dev=%s)\n",
2284                   device->mount_point, print_name());
2285             break;
2286          }
2287          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2288             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2289             break;
2290          } else {
2291             Dmsg2(129, "do_file_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2292          }
2293       }
2294       free(entry);
2295       closedir(dp);
2296
2297       Dmsg1(100, "do_file_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2298
2299       if (count > 0) {
2300          /* If we got more than ., .. and .keep */
2301          /*   there must be something mounted */
2302          if (mount) {
2303             Dmsg1(100, "Did Mount by count=%d\n", count);
2304             break;
2305          } else {
2306             /* An unmount request. We failed to unmount - report an error */
2307             set_mounted(true);
2308             free_pool_memory(results);
2309             Dmsg0(200, "== error mount=1 wanted unmount\n");
2310             return false;
2311          }
2312       }
2313 get_out:
2314       set_mounted(false);
2315       free_pool_memory(results);
2316       Dmsg0(200, "============ mount=0\n");
2317       Dsm_check(1);
2318       return false;
2319    }
2320
2321    set_mounted(mount);              /* set/clear mounted flag */
2322    free_pool_memory(results);
2323    /* Do not check free space when unmounting */
2324    if (mount && !update_freespace()) {
2325       return false;
2326    }
2327    Dmsg1(200, "============ mount=%d\n", mount);
2328    return true;
2329 }
2330
2331 /*
2332  * Edit codes into (Un)MountCommand, Write(First)PartCommand
2333  *  %% = %
2334  *  %a = archive device name
2335  *  %e = erase (set if cannot mount and first part)
2336  *  %n = part number
2337  *  %m = mount point
2338  *  %v = last part name
2339  *
2340  *  omsg = edited output message
2341  *  imsg = input string containing edit codes (%x)
2342  *
2343  */
2344 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2345 {
2346    const char *p;
2347    const char *str;
2348    char add[20];
2349
2350    POOL_MEM archive_name(PM_FNAME);
2351
2352    omsg.c_str()[0] = 0;
2353    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2354    for (p=imsg; *p; p++) {
2355       if (*p == '%') {
2356          switch (*++p) {
2357          case '%':
2358             str = "%";
2359             break;
2360          case 'a':
2361             str = dev_name;
2362             break;
2363          case 'e':
2364             if (num_dvd_parts == 0) {
2365                if (truncating || blank_dvd) {
2366                   str = "2";
2367                } else {
2368                   str = "1";
2369                }
2370             } else {
2371                str = "0";
2372             }
2373             break;
2374          case 'n':
2375             bsnprintf(add, sizeof(add), "%d", part);
2376             str = add;
2377             break;
2378          case 'm':
2379             str = device->mount_point;
2380             break;
2381          case 'v':
2382             make_spooled_dvd_filename(this, archive_name);
2383             str = archive_name.c_str();
2384             break;
2385          default:
2386             add[0] = '%';
2387             add[1] = *p;
2388             add[2] = 0;
2389             str = add;
2390             break;
2391          }
2392       } else {
2393          add[0] = *p;
2394          add[1] = 0;
2395          str = add;
2396       }
2397       Dmsg1(1900, "add_str %s\n", str);
2398       pm_strcat(omsg, (char *)str);
2399       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2400    }
2401 }
2402
2403 /* return the last timer interval (ms)
2404  * or 0 if something goes wrong
2405  */
2406 btime_t DEVICE::get_timer_count()
2407 {
2408    btime_t temp = last_timer;
2409    last_timer = get_current_btime();
2410    temp = last_timer - temp;   /* get elapsed time */
2411    return (temp>0)?temp:0;     /* take care of skewed clock */
2412 }
2413
2414 /* read from fd */
2415 ssize_t DEVICE::read(void *buf, size_t len)
2416 {
2417    ssize_t read_len ;
2418
2419    get_timer_count();
2420
2421    read_len = d_read(m_fd, buf, len);
2422
2423    last_tick = get_timer_count();
2424
2425    DevReadTime += last_tick;
2426    VolCatInfo.VolReadTime += last_tick;
2427
2428    if (read_len > 0) {          /* skip error */
2429       DevReadBytes += read_len;
2430    }
2431
2432    return read_len;
2433 }
2434
2435 /* write to fd */
2436 ssize_t DEVICE::write(const void *buf, size_t len)
2437 {
2438    ssize_t write_len ;
2439
2440    get_timer_count();
2441
2442    write_len = d_write(m_fd, buf, len);
2443
2444    last_tick = get_timer_count();
2445
2446    DevWriteTime += last_tick;
2447    VolCatInfo.VolWriteTime += last_tick;
2448
2449    if (write_len > 0) {         /* skip error */
2450       DevWriteBytes += write_len;
2451    }
2452
2453    return write_len;
2454 }
2455
2456 /* Return the resource name for the device */
2457 const char *DEVICE::name() const
2458 {
2459    return device->hdr.name;
2460 }
2461
2462 /* Returns file position on tape or -1 */
2463 int32_t DEVICE::get_os_tape_file()
2464 {
2465    struct mtget mt_stat;
2466
2467    if (has_cap(CAP_MTIOCGET) &&
2468        d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2469       return mt_stat.mt_fileno;
2470    }
2471    return -1;
2472 }
2473
2474 char *
2475 dev_vol_name(DEVICE *dev)
2476 {
2477    return dev->getVolCatName();
2478 }
2479
2480
2481 /*
2482  * Free memory allocated for the device
2483  */
2484 void DEVICE::term(void)
2485 {
2486    Dmsg1(900, "term dev: %s\n", print_name());
2487    close();
2488    if (dev_name) {
2489       free_memory(dev_name);
2490       dev_name = NULL;
2491    }
2492    if (prt_name) {
2493       free_memory(prt_name);
2494       prt_name = NULL;
2495    }
2496    if (errmsg) {
2497       free_pool_memory(errmsg);
2498       errmsg = NULL;
2499    }
2500    pthread_mutex_destroy(&m_mutex);
2501    pthread_cond_destroy(&wait);
2502    pthread_cond_destroy(&wait_next_vol);
2503    pthread_mutex_destroy(&spool_mutex);
2504 // rwl_destroy(&lock);
2505    if (attached_dcrs) {
2506       delete attached_dcrs;
2507       attached_dcrs = NULL;
2508    }
2509    if (device) {
2510       device->dev = NULL;
2511    }
2512    free((char *)this);
2513 }
2514
2515 /*
2516  * This routine initializes the device wait timers
2517  */
2518 void init_device_wait_timers(DCR *dcr)
2519 {
2520    DEVICE *dev = dcr->dev;
2521    JCR *jcr = dcr->jcr;
2522
2523    /* ******FIXME******* put these on config variables */
2524    dev->min_wait = 60 * 60;
2525    dev->max_wait = 24 * 60 * 60;
2526    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2527    dev->wait_sec = dev->min_wait;
2528    dev->rem_wait_sec = dev->wait_sec;
2529    dev->num_wait = 0;
2530    dev->poll = false;
2531
2532    jcr->min_wait = 60 * 60;
2533    jcr->max_wait = 24 * 60 * 60;
2534    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2535    jcr->wait_sec = jcr->min_wait;
2536    jcr->rem_wait_sec = jcr->wait_sec;
2537    jcr->num_wait = 0;
2538
2539 }
2540
2541 void init_jcr_device_wait_timers(JCR *jcr)
2542 {
2543    /* ******FIXME******* put these on config variables */
2544    jcr->min_wait = 60 * 60;
2545    jcr->max_wait = 24 * 60 * 60;
2546    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2547    jcr->wait_sec = jcr->min_wait;
2548    jcr->rem_wait_sec = jcr->wait_sec;
2549    jcr->num_wait = 0;
2550 }
2551
2552
2553 /*
2554  * The dev timers are used for waiting on a particular device
2555  *
2556  * Returns: true if time doubled
2557  *          false if max time expired
2558  */
2559 bool double_dev_wait_time(DEVICE *dev)
2560 {
2561    dev->wait_sec *= 2;               /* double wait time */
2562    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2563       dev->wait_sec = dev->max_wait;
2564    }
2565    dev->num_wait++;
2566    dev->rem_wait_sec = dev->wait_sec;
2567    if (dev->num_wait >= dev->max_num_wait) {
2568       return false;
2569    }
2570    return true;
2571 }
2572
2573
2574 void set_os_device_parameters(DCR *dcr)
2575 {
2576    DEVICE *dev = dcr->dev;
2577
2578    if (strcmp(dev->dev_name, "/dev/null") == 0) {
2579       return;                            /* no use trying to set /dev/null */
2580    }
2581
2582 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2583    struct mtop mt_com;
2584
2585    Dmsg0(100, "In set_os_device_parameters\n");
2586 #if defined(MTSETBLK)
2587    if (dev->min_block_size == dev->max_block_size &&
2588        dev->min_block_size == 0) {    /* variable block mode */
2589       mt_com.mt_op = MTSETBLK;
2590       mt_com.mt_count = 0;
2591       Dmsg0(100, "Set block size to zero\n");
2592       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2593          dev->clrerror(MTSETBLK);
2594       }
2595    }
2596 #endif
2597 #if defined(MTSETDRVBUFFER)
2598    if (getuid() == 0) {          /* Only root can do this */
2599       mt_com.mt_op = MTSETDRVBUFFER;
2600       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2601       if (!dev->has_cap(CAP_TWOEOF)) {
2602          mt_com.mt_count |= MT_ST_TWO_FM;
2603       }
2604       if (dev->has_cap(CAP_EOM)) {
2605          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2606       }
2607       Dmsg0(100, "MTSETDRVBUFFER\n");
2608       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2609          dev->clrerror(MTSETDRVBUFFER);
2610       }
2611    }
2612 #endif
2613    return;
2614 #endif
2615
2616 #ifdef HAVE_NETBSD_OS
2617    struct mtop mt_com;
2618    if (dev->min_block_size == dev->max_block_size &&
2619        dev->min_block_size == 0) {    /* variable block mode */
2620       mt_com.mt_op = MTSETBSIZ;
2621       mt_com.mt_count = 0;
2622       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2623          dev->clrerror(MTSETBSIZ);
2624       }
2625       /* Get notified at logical end of tape */
2626       mt_com.mt_op = MTEWARN;
2627       mt_com.mt_count = 1;
2628       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2629          dev->clrerror(MTEWARN);
2630       }
2631    }
2632    return;
2633 #endif
2634
2635 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2636    struct mtop mt_com;
2637    if (dev->min_block_size == dev->max_block_size &&
2638        dev->min_block_size == 0) {    /* variable block mode */
2639       mt_com.mt_op = MTSETBSIZ;
2640       mt_com.mt_count = 0;
2641       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2642          dev->clrerror(MTSETBSIZ);
2643       }
2644    }
2645 #if defined(MTIOCSETEOTMODEL)
2646    uint32_t neof;
2647    if (dev->has_cap(CAP_TWOEOF)) {
2648       neof = 2;
2649    } else {
2650       neof = 1;
2651    }
2652    if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2653       berrno be;
2654       dev->dev_errno = errno;         /* save errno */
2655       Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2656             dev->print_name(), be.bstrerror(dev->dev_errno));
2657       Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2658    }
2659 #endif
2660    return;
2661 #endif
2662
2663 #ifdef HAVE_SUN_OS
2664    struct mtop mt_com;
2665    if (dev->min_block_size == dev->max_block_size &&
2666        dev->min_block_size == 0) {    /* variable block mode */
2667       mt_com.mt_op = MTSRSZ;
2668       mt_com.mt_count = 0;
2669       if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2670          dev->clrerror(MTSRSZ);
2671       }
2672    }
2673    return;
2674 #endif
2675 }
2676
2677 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2678 {
2679    Dmsg0(100, "dev_get_os_pos\n");
2680    return dev->has_cap(CAP_MTIOCGET) &&
2681           dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2682           mt_stat->mt_fileno >= 0;
2683 }
2684
2685 static const char *modes[] = {
2686    "CREATE_READ_WRITE",
2687    "OPEN_READ_WRITE",
2688    "OPEN_READ_ONLY",
2689    "OPEN_WRITE_ONLY"
2690 };
2691
2692
2693 static const char *mode_to_str(int mode)
2694 {
2695    static char buf[100];
2696    if (mode < 1 || mode > 4) {
2697       bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2698       return buf;
2699     }
2700    return modes[mode-1];
2701 }