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       VolCatInfo = dcr->VolCatInfo;    /* structure assign */
 357    }
 358
 359    Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
 360          print_name(), getVolCatName(), mode_to_str(omode));
 361    state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
 362    label_type = B_BACULA_LABEL;
 363    if (is_tape() || is_fifo()) {
 364       open_tape_device(dcr, omode);
 365    } else if (is_dvd()) {
 366       Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
 367       open_dvd_device(dcr, omode);
 368    } else {
 369       Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
 370       open_file_device(dcr, omode);
 371    }
 372    state |= preserve;                 /* reset any important state info */
 373    Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
 374    return m_fd;
 375 }
 376
 377 void DEVICE::set_mode(int new_mode)
 378 {
 379    switch (new_mode) {
 380    case CREATE_READ_WRITE:
 381       mode = O_CREAT | O_RDWR | O_BINARY;
 382       break;
 383    case OPEN_READ_WRITE:
 384       mode = O_RDWR | O_BINARY;
 385       break;
 386    case OPEN_READ_ONLY:
 387       mode = O_RDONLY | O_BINARY;
 388       break;
 389    case OPEN_WRITE_ONLY:
 390       mode = O_WRONLY | O_BINARY;
 391       break;
 392    default:
 393       Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
 394    }
 395 }
 396
 397 /*
 398  */
 399 void DEVICE::open_tape_device(DCR *dcr, int omode)
 400 {
 401    file_size = 0;
 402    int timeout = max_open_wait;
 403 #if !defined(HAVE_WIN32)
 404    struct mtop mt_com;
 405    utime_t start_time = time(NULL);
 406 #endif
 407
 408    mount(1);                          /* do mount if required */
 409
 410    Dmsg0(100, "Open dev: device is tape\n");
 411
 412    get_autochanger_loaded_slot(dcr);
 413
 414    openmode = omode;
 415    set_mode(omode);
 416
 417    if (timeout < 1) {
 418       timeout = 1;
 419    }
 420    errno = 0;
 421    if (is_fifo() && timeout) {
 422       /* Set open timer */
 423       tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
 424    }
 425    Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
 426 #if defined(HAVE_WIN32)
 427
 428    /*   Windows Code */
 429    if ((m_fd = d_open(dev_name, mode)) < 0) {
 430       dev_errno = errno;
 431    }
 432
 433 #else
 434
 435    /*  UNIX  Code */
 436    /* If busy retry each second for max_open_wait seconds */
 437    for ( ;; ) {
 438       /* Try non-blocking open */
 439       m_fd = d_open(dev_name, mode+O_NONBLOCK);
 440       if (m_fd < 0) {
 441          berrno be;
 442          dev_errno = errno;
 443          Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
 444               print_name(), omode, mode, errno, be.bstrerror());
 445       } else {
 446          /* Tape open, now rewind it */
 447          Dmsg0(100, "Rewind after open\n");
 448          mt_com.mt_op = MTREW;
 449          mt_com.mt_count = 1;
 450          /* rewind only if dev is a tape */
 451          if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
 452             berrno be;
 453             dev_errno = errno;           /* set error status from rewind */
 454             d_close(m_fd);
 455             clear_opened();
 456             Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
 457                   be.bstrerror(dev_errno));
 458             /* If we get busy, device is probably rewinding, try again */
 459             if (dev_errno != EBUSY) {
 460                break;                    /* error -- no medium */
 461             }
 462          } else {
 463             /* Got fd and rewind worked, so we must have medium in drive */
 464             d_close(m_fd);
 465             m_fd = d_open(dev_name, mode);  /* open normally */
 466             if (m_fd < 0) {
 467                berrno be;
 468                dev_errno = errno;
 469                Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
 470                      print_name(), omode, mode, errno, be.bstrerror());
 471                break;
 472             }
 473             dev_errno = 0;
 474             lock_door();
 475             set_os_device_parameters(dcr);       /* do system dependent stuff */
 476             break;                               /* Successfully opened and rewound */
 477          }
 478       }
 479       bmicrosleep(5, 0);
 480       /* Exceed wait time ? */
 481       if (time(NULL) - start_time >= max_open_wait) {
 482          break;                       /* yes, get out */
 483       }
 484    }
 485 #endif
 486
 487    if (!is_open()) {
 488       berrno be;
 489       Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
 490             print_name(), be.bstrerror(dev_errno));
 491       Dmsg1(100, "%s", errmsg);
 492    }
 493
 494    /* Stop any open() timer we started */
 495    if (tid) {
 496       stop_thread_timer(tid);
 497       tid = 0;
 498    }
 499    Dmsg1(100, "open dev: tape %d opened\n", m_fd);
 500 }
 501
 502
 503 /*
 504  * Open a file device
 505  */
 506 void DEVICE::open_file_device(DCR *dcr, int omode)
 507 {
 508    POOL_MEM archive_name(PM_FNAME);
 509
 510    get_autochanger_loaded_slot(dcr);
 511
 512    /*
 513     * Handle opening of File Archive (not a tape)
 514     */
 515
 516    pm_strcpy(archive_name, dev_name);
 517    /*
 518     * If this is a virtual autochanger (i.e. changer_res != NULL)
 519     *  we simply use the device name, assuming it has been
 520     *  appropriately setup by the "autochanger".
 521     */
 522    if (!device->changer_res || device->changer_command[0] == 0) {
 523       if (VolCatInfo.VolCatName[0] == 0) {
 524          Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
 525             print_name());
 526          clear_opened();
 527          return;
 528       }
 529
 530       if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
 531          pm_strcat(archive_name, "/");
 532       }
 533       pm_strcat(archive_name, getVolCatName());
 534    }
 535
 536    mount(1);                          /* do mount if required */
 537
 538    openmode = omode;
 539    set_mode(omode);
 540    /* If creating file, give 0640 permissions */
 541    Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
 542          archive_name.c_str(), mode);
 543    /* Use system open() */
 544    if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
 545       berrno be;
 546       dev_errno = errno;
 547       Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
 548             be.bstrerror());
 549       Dmsg1(100, "open failed: %s", errmsg);
 550 //    Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
 551    } else {
 552       dev_errno = 0;
 553       file = 0;
 554       file_addr = 0;
 555    }
 556    Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
 557       m_fd, part, num_dvd_parts, part_size);
 558 }
 559
 560 /*
 561  * Open a DVD device. N.B. at this point, dcr->getVolCatName()
 562  *  (NB:??? I think it's getVolCatName() that is right)
 563  *  has the desired Volume name, but there is NO assurance that
 564  *  any other field of VolCatInfo is correct.
 565  */
 566 void DEVICE::open_dvd_device(DCR *dcr, int omode)
 567 {
 568    POOL_MEM archive_name(PM_FNAME);
 569    struct stat filestat;
 570
 571    /*
 572     * Handle opening of DVD Volume
 573     */
 574    Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
 575          &dcr->VolCatInfo, mode_to_str(omode));
 576
 577    /*
 578     * For a DVD we must always pull the state info from dcr->VolCatInfo
 579     *  This is a bit ugly, but is necessary because we need to open/close/re-open
 580     *  the dvd file in order to properly mount/unmount and access the
 581     *  DVD. So we store the state of the DVD as far as is known in the
 582     *  catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
 583     *  copy here, when opening.
 584     */
 585    VolCatInfo = dcr->VolCatInfo;         /* structure assignment */
 586    Dmsg1(100, "Volume=%s\n", getVolCatName());
 587
 588    if (VolCatInfo.VolCatName[0] == 0) {
 589       Dmsg1(10,  "Could not open DVD device %s. No Volume name given.\n",
 590          print_name());
 591       Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
 592          print_name());
 593       clear_opened();
 594       return;
 595    }
 596
 597    if (part == 0) {
 598       Dmsg0(100, "Set part=1\n");
 599       part = 1;                       /* count from 1 */
 600       file_size = 0;
 601    }
 602    part_size = 0;
 603    if (num_dvd_parts != VolCatInfo.VolCatParts) {
 604       num_dvd_parts = VolCatInfo.VolCatParts;
 605    }
 606
 607    /*
 608     * If we are not trying to access the last part, set mode to
 609     *   OPEN_READ_ONLY as writing would be an error.
 610     */
 611    Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
 612    /* Now find the name of the part that we want to access */
 613    if (part <= num_dvd_parts) {
 614       omode = OPEN_READ_ONLY;
 615       make_mounted_dvd_filename(this, archive_name);
 616       set_part_spooled(false);
 617    } else {
 618       omode = OPEN_READ_WRITE;
 619       make_spooled_dvd_filename(this, archive_name);
 620       set_part_spooled(true);
 621    }
 622    set_mode(omode);
 623
 624    // Clear any previous blank_dvd status - we will recalculate it here
 625    blank_dvd = false;
 626
 627    Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
 628       part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
 629
 630    if (mount(1)) {
 631       Dmsg0(99, "DVD device mounted.\n");
 632       if (num_dvd_parts == 0 && !truncating) {
 633          /*
 634           * If we can mount the device, and we are not truncating the DVD,
 635           * we usually want to abort. There is one exception, if there is
 636           * only one 0-sized file on the DVD, with the right volume name,
 637           * we continue (it's the method used by truncate_dvd to truncate a volume).
 638           */
 639          if (!check_can_write_on_non_blank_dvd(dcr)) {
 640             Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
 641             Emsg0(M_FATAL, 0, errmsg);
 642             unmount(1); /* Unmount the device, so the operator can change it. */
 643             clear_opened();
 644             return;
 645          }
 646          blank_dvd = true;
 647       } else {
 648          /*
 649           * Ensure that we have the correct DVD loaded by looking for part1.
 650           * We only succeed the open if it exists. Failure to do this could
 651           * leave us trying to add a part to a different DVD!
 652           */
 653          uint32_t oldpart = part;
 654          struct stat statp;
 655          POOL_MEM part1_name(PM_FNAME);
 656          part = 1;
 657          make_mounted_dvd_filename(this, part1_name);
 658          part = oldpart;
 659          if (stat(part1_name.c_str(), &statp) < 0) {
 660             berrno be;
 661             Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
 662                part1_name.c_str(), be.bstrerror());
 663             Emsg0(M_FATAL, 0, errmsg);
 664             clear_opened();
 665             return;
 666          }
 667          if (!S_ISREG(statp.st_mode)) {
 668             /* It is not a regular file */
 669             Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
 670                part1_name.c_str());
 671             Emsg0(M_FATAL, 0, errmsg);
 672             clear_opened();
 673             return;
 674          }
 675       }
 676    } else {
 677       Dmsg0(99, "DVD device mount failed.\n");
 678       /* We cannot mount the device */
 679       if (num_dvd_parts == 0) {
 680          /* Run free space, check there is a media. */
 681          if (!update_freespace()) {
 682             Emsg0(M_FATAL, 0, errmsg);
 683             clear_opened();
 684             return;
 685          }
 686          if (have_media()) {
 687             Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
 688          } else {
 689             Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
 690             Emsg0(M_FATAL, 0, errmsg);
 691             clear_opened();
 692             return;
 693          }
 694       }  else {
 695          Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
 696          Emsg0(M_FATAL, 0, errmsg);
 697          clear_opened();
 698          return;
 699       }
 700    }
 701
 702    Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
 703       archive_name.c_str(), mode_to_str(omode),
 704       part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
 705    openmode = omode;
 706    Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
 707
 708
 709    /* If creating file, give 0640 permissions */
 710    Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
 711          archive_name.c_str(), mode);
 712    /* Use system open() */
 713    if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
 714       berrno be;
 715       Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
 716             be.bstrerror());
 717       // Should this be set if we try the create/open below
 718       dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
 719       Dmsg1(100, "open failed: %s", errmsg);
 720
 721       /* Previous open failed. See if we can recover */
 722       if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
 723           (part > num_dvd_parts)) {
 724          /* If the last part (on spool), doesn't exist when accessing,
 725           * create it. In read/write mode a write will be allowed (higher
 726           * level software thinks that we are extending a pre-existing
 727           * media. Reads for READ_ONLY will report immediately an EOF
 728           * Sometimes it is better to finish with an EOF than with an error. */
 729          Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
 730          omode = CREATE_READ_WRITE;
 731          set_mode(CREATE_READ_WRITE);
 732          m_fd = ::open(archive_name.c_str(), mode, 0640);
 733          set_mode(omode);
 734       }
 735    }
 736    Dmsg1(100, "after open fd=%d\n", m_fd);
 737    if (is_open()) {
 738       if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
 739          set_append();
 740       }
 741       /* Get size of file */
 742       if (fstat(m_fd, &filestat) < 0) {
 743          berrno be;
 744          dev_errno = errno;
 745          Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
 746                be.bstrerror());
 747          Dmsg1(100, "open failed: %s", errmsg);
 748          /* Use system close() */
 749          d_close(m_fd);
 750          clear_opened();
 751       } else {
 752          part_size = filestat.st_size;
 753          dev_errno = 0;
 754          update_pos(dcr);                    /* update position */
 755       }
 756    }
 757 }
 758
 759
 760 /*
 761  * Rewind the device.
 762  *  Returns: true  on success
 763  *           false on failure
 764  */
 765 bool DEVICE::rewind(DCR *dcr)
 766 {
 767    struct mtop mt_com;
 768    unsigned int i;
 769    bool first = true;
 770
 771    Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
 772    state &= ~(ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
 773    block_num = file = 0;
 774    file_size = 0;
 775    file_addr = 0;
 776    if (m_fd < 0) {
 777       if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
 778          dev_errno = EBADF;
 779          Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
 780             print_name());
 781          Emsg0(M_ABORT, 0, errmsg);
 782       }
 783       return false;
 784    }
 785    if (is_tape()) {
 786       mt_com.mt_op = MTREW;
 787       mt_com.mt_count = 1;
 788       /* If we get an I/O error on rewind, it is probably because
 789        * the drive is actually busy. We loop for (about 5 minutes)
 790        * retrying every 5 seconds.
 791        */
 792       for (i=max_rewind_wait; ; i -= 5) {
 793          if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
 794             berrno be;
 795             clrerror(MTREW);
 796             if (i == max_rewind_wait) {
 797                Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
 798             }
 799             /*
 800              * This is a gross hack, because if the user has the
 801              *   device mounted (i.e. open), then uses mtx to load
 802              *   a tape, the current open file descriptor is invalid.
 803              *   So, we close the drive and re-open it.
 804              */
 805             if (first && dcr) {
 806                int open_mode = openmode;
 807                d_close(m_fd);
 808                clear_opened();
 809                open(dcr, open_mode);
 810                if (m_fd < 0) {
 811                   return false;
 812                }
 813                first = false;
 814                continue;
 815             }
 816 #ifdef HAVE_SUN_OS
 817             if (dev_errno == EIO) {
 818                Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
 819                return false;
 820             }
 821 #else
 822             if (dev_errno == EIO && i > 0) {
 823                Dmsg0(200, "Sleeping 5 seconds.\n");
 824                bmicrosleep(5, 0);
 825                continue;
 826             }
 827 #endif
 828             Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
 829                print_name(), be.bstrerror());
 830             return false;
 831          }
 832          break;
 833       }
 834    } else if (is_file() || is_dvd()) {
 835       if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
 836          berrno be;
 837          dev_errno = errno;
 838          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
 839             print_name(), be.bstrerror());
 840          return false;
 841       }
 842    }
 843    return true;
 844 }
 845
 846
 847 /*
 848  * Called to indicate that we have just read an
 849  *  EOF from the device.
 850  */
 851 void DEVICE::set_ateof()
 852 {
 853    set_eof();
 854    if (is_tape()) {
 855       file++;
 856    }
 857    file_addr = 0;
 858    file_size = 0;
 859    block_num = 0;
 860 }
 861
 862 /*
 863  * Called to indicate we are now at the end of the tape, and
 864  *   writing is not possible.
 865  */
 866 void DEVICE::set_ateot()
 867 {
 868    /* Make tape effectively read-only */
 869    state |= (ST_EOF|ST_EOT|ST_WEOT);
 870    clear_append();
 871 }
 872
 873 /*
 874  * Position device to end of medium (end of data)
 875  *  Returns: true  on succes
 876  *           false on error
 877  */
 878 bool DEVICE::eod(DCR *dcr)
 879 {
 880    struct mtop mt_com;
 881    bool ok = true;
 882    boffset_t pos;
 883    int32_t os_file;
 884
 885    if (m_fd < 0) {
 886       dev_errno = EBADF;
 887       Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
 888       return false;
 889    }
 890
 891 #if defined (__digital__) && defined (__unix__)
 892    return fsf(VolCatInfo.VolCatFiles);
 893 #endif
 894
 895    Dmsg0(100, "Enter eod\n");
 896    if (at_eot()) {
 897       return true;
 898    }
 899    clear_eof();         /* remove EOF flag */
 900    block_num = file = 0;
 901    file_size = 0;
 902    file_addr = 0;
 903    if (is_fifo()) {
 904       return true;
 905    }
 906    if (!is_tape()) {
 907       pos = lseek(dcr, (boffset_t)0, SEEK_END);
 908       Dmsg1(200, "====== Seek to %lld\n", pos);
 909       if (pos >= 0) {
 910          update_pos(dcr);
 911          set_eot();
 912          return true;
 913       }
 914       dev_errno = errno;
 915       berrno be;
 916       Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
 917              print_name(), be.bstrerror());
 918       Dmsg0(100, errmsg);
 919       return false;
 920    }
 921 #ifdef MTEOM
 922    if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
 923       Dmsg0(100,"Using FAST FSF for EOM\n");
 924       /* If unknown position, rewind */
 925       if (get_os_tape_file() < 0) {
 926         if (!rewind(NULL)) {
 927           Dmsg0(100, "Rewind error\n");
 928           return false;
 929         }
 930       }
 931       mt_com.mt_op = MTFSF;
 932       /*
 933        * ***FIXME*** fix code to handle case that INT16_MAX is
 934        *   not large enough.
 935        */
 936       mt_com.mt_count = INT16_MAX;    /* use big positive number */
 937       if (mt_com.mt_count < 0) {
 938          mt_com.mt_count = INT16_MAX; /* brain damaged system */
 939       }
 940    }
 941
 942    if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
 943       if (has_cap(CAP_EOM)) {
 944          Dmsg0(100,"Using EOM for EOM\n");
 945          mt_com.mt_op = MTEOM;
 946          mt_com.mt_count = 1;
 947       }
 948
 949       if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
 950          berrno be;
 951          clrerror(mt_com.mt_op);
 952          Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
 953          update_pos(dcr);
 954          Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
 955             print_name(), be.bstrerror());
 956          Dmsg0(100, errmsg);
 957          return false;
 958       }
 959
 960       os_file = get_os_tape_file();
 961       if (os_file < 0) {
 962          berrno be;
 963          clrerror(-1);
 964          Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
 965             print_name(), be.bstrerror());
 966          Dmsg0(100, errmsg);
 967          return false;
 968       }
 969       Dmsg1(100, "EOD file=%d\n", os_file);
 970       set_ateof();
 971       file = os_file;
 972    } else {
 973 #else
 974    {
 975 #endif
 976       /*
 977        * Rewind then use FSF until EOT reached
 978        */
 979       if (!rewind(NULL)) {
 980          Dmsg0(100, "Rewind error.\n");
 981          return false;
 982       }
 983       /*
 984        * Move file by file to the end of the tape
 985        */
 986       int file_num;
 987       for (file_num=file; !at_eot(); file_num++) {
 988          Dmsg0(200, "eod: doing fsf 1\n");
 989          if (!fsf(1)) {
 990             Dmsg0(100, "fsf error.\n");
 991             return false;
 992          }
 993          /*
 994           * Avoid infinite loop by ensuring we advance.
 995           */
 996          if (!at_eot() && file_num == (int)file) {
 997             Dmsg1(100, "fsf did not advance from file %d\n", file_num);
 998             set_ateof();
 999             os_file = get_os_tape_file();
1000             if (os_file >= 0) {
1001                Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
1002                file = os_file;
1003             }
1004             break;
1005          }
1006       }
1007    }
1008    /*
1009     * Some drivers leave us after second EOF when doing
1010     * MTEOM, so we must backup so that appending overwrites
1011     * the second EOF.
1012     */
1013    if (has_cap(CAP_BSFATEOM)) {
1014       /* Backup over EOF */
1015       ok = bsf(1);
1016       /* If BSF worked and fileno is known (not -1), set file */
1017       os_file = get_os_tape_file();
1018       if (os_file >= 0) {
1019          Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1020          file = os_file;
1021       } else {
1022          file++;                       /* wing it -- not correct on all OSes */
1023       }
1024    } else {
1025       update_pos(dcr);                 /* update position */
1026    }
1027    Dmsg1(200, "EOD dev->file=%d\n", file);
1028    return ok;
1029 }
1030
1031 /*
1032  * Set the position of the device -- only for files and DVD
1033  *   For other devices, there is no generic way to do it.
1034  *  Returns: true  on succes
1035  *           false on error
1036  */
1037 bool DEVICE::update_pos(DCR *dcr)
1038 {
1039    boffset_t pos;
1040    bool ok = true;
1041
1042    if (!is_open()) {
1043       dev_errno = EBADF;
1044       Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1045       Emsg1(M_FATAL, 0, "%s", errmsg);
1046       return false;
1047    }
1048
1049    /* Find out where we are */
1050    if (is_file() || is_dvd()) {
1051       file = 0;
1052       file_addr = 0;
1053       pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1054       if (pos < 0) {
1055          berrno be;
1056          dev_errno = errno;
1057          Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1058          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1059             print_name(), be.bstrerror());
1060          ok = false;
1061       } else {
1062          file_addr = pos;
1063          block_num = (uint32_t)pos;
1064          file = (uint32_t)(pos >> 32);
1065       }
1066    }
1067    return ok;
1068 }
1069
1070 /*
1071  * Return the status of the device.  This was meant
1072  * to be a generic routine. Unfortunately, it doesn't
1073  * seem possible (at least I do not know how to do it
1074  * currently), which means that for the moment, this
1075  * routine has very little value.
1076  *
1077  *   Returns: status
1078  */
1079 uint32_t status_dev(DEVICE *dev)
1080 {
1081    struct mtget mt_stat;
1082    uint32_t stat = 0;
1083
1084    if (dev->state & (ST_EOT | ST_WEOT)) {
1085       stat |= BMT_EOD;
1086       Pmsg0(-20, " EOD");
1087    }
1088    if (dev->state & ST_EOF) {
1089       stat |= BMT_EOF;
1090       Pmsg0(-20, " EOF");
1091    }
1092    if (dev->is_tape()) {
1093       stat |= BMT_TAPE;
1094       Pmsg0(-20,_(" Bacula status:"));
1095       Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1096       if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1097          berrno be;
1098          dev->dev_errno = errno;
1099          Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1100             dev->print_name(), be.bstrerror());
1101          return 0;
1102       }
1103       Pmsg0(-20, _(" Device status:"));
1104
1105 #if defined(HAVE_LINUX_OS)
1106       if (GMT_EOF(mt_stat.mt_gstat)) {
1107          stat |= BMT_EOF;
1108          Pmsg0(-20, " EOF");
1109       }
1110       if (GMT_BOT(mt_stat.mt_gstat)) {
1111          stat |= BMT_BOT;
1112          Pmsg0(-20, " BOT");
1113       }
1114       if (GMT_EOT(mt_stat.mt_gstat)) {
1115          stat |= BMT_EOT;
1116          Pmsg0(-20, " EOT");
1117       }
1118       if (GMT_SM(mt_stat.mt_gstat)) {
1119          stat |= BMT_SM;
1120          Pmsg0(-20, " SM");
1121       }
1122       if (GMT_EOD(mt_stat.mt_gstat)) {
1123          stat |= BMT_EOD;
1124          Pmsg0(-20, " EOD");
1125       }
1126       if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1127          stat |= BMT_WR_PROT;
1128          Pmsg0(-20, " WR_PROT");
1129       }
1130       if (GMT_ONLINE(mt_stat.mt_gstat)) {
1131          stat |= BMT_ONLINE;
1132          Pmsg0(-20, " ONLINE");
1133       }
1134       if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1135          stat |= BMT_DR_OPEN;
1136          Pmsg0(-20, " DR_OPEN");
1137       }
1138       if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1139          stat |= BMT_IM_REP_EN;
1140          Pmsg0(-20, " IM_REP_EN");
1141       }
1142 #elif defined(HAVE_WIN32)
1143       if (GMT_EOF(mt_stat.mt_gstat)) {
1144          stat |= BMT_EOF;
1145          Pmsg0(-20, " EOF");
1146       }
1147       if (GMT_BOT(mt_stat.mt_gstat)) {
1148          stat |= BMT_BOT;
1149          Pmsg0(-20, " BOT");
1150       }
1151       if (GMT_EOT(mt_stat.mt_gstat)) {
1152          stat |= BMT_EOT;
1153          Pmsg0(-20, " EOT");
1154       }
1155       if (GMT_EOD(mt_stat.mt_gstat)) {
1156          stat |= BMT_EOD;
1157          Pmsg0(-20, " EOD");
1158       }
1159       if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1160          stat |= BMT_WR_PROT;
1161          Pmsg0(-20, " WR_PROT");
1162       }
1163       if (GMT_ONLINE(mt_stat.mt_gstat)) {
1164          stat |= BMT_ONLINE;
1165          Pmsg0(-20, " ONLINE");
1166       }
1167       if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1168          stat |= BMT_DR_OPEN;
1169          Pmsg0(-20, " DR_OPEN");
1170       }
1171       if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1172          stat |= BMT_IM_REP_EN;
1173          Pmsg0(-20, " IM_REP_EN");
1174       }
1175
1176 #endif /* !SunOS && !OSF */
1177       if (dev->has_cap(CAP_MTIOCGET)) {
1178          Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1179       } else {
1180          Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1181       }
1182    } else {
1183       stat |= BMT_ONLINE | BMT_BOT;
1184    }
1185    return stat;
1186 }
1187
1188
1189 /*
1190  * Load medium in device
1191  *  Returns: true  on success
1192  *           false on failure
1193  */
1194 bool load_dev(DEVICE *dev)
1195 {
1196 #ifdef MTLOAD
1197    struct mtop mt_com;
1198 #endif
1199
1200    if (dev->fd() < 0) {
1201       dev->dev_errno = EBADF;
1202       Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1203       Emsg0(M_FATAL, 0, dev->errmsg);
1204       return false;
1205    }
1206    if (!(dev->is_tape())) {
1207       return true;
1208    }
1209 #ifndef MTLOAD
1210    Dmsg0(200, "stored: MTLOAD command not available\n");
1211    berrno be;
1212    dev->dev_errno = ENOTTY;           /* function not available */
1213    Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1214          dev->print_name(), be.bstrerror());
1215    return false;
1216 #else
1217
1218    dev->block_num = dev->file = 0;
1219    dev->file_size = 0;
1220    dev->file_addr = 0;
1221    mt_com.mt_op = MTLOAD;
1222    mt_com.mt_count = 1;
1223    if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1224       berrno be;
1225       dev->dev_errno = errno;
1226       Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1227          dev->print_name(), be.bstrerror());
1228       return false;
1229    }
1230    return true;
1231 #endif
1232 }
1233
1234 /*
1235  * Rewind device and put it offline
1236  *  Returns: true  on success
1237  *           false on failure
1238  */
1239 bool DEVICE::offline()
1240 {
1241    struct mtop mt_com;
1242
1243    if (!is_tape()) {
1244       return true;                    /* device not open */
1245    }
1246
1247    state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
1248    block_num = file = 0;
1249    file_size = 0;
1250    file_addr = 0;
1251    unlock_door();
1252    mt_com.mt_op = MTOFFL;
1253    mt_com.mt_count = 1;
1254    if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1255       berrno be;
1256       dev_errno = errno;
1257       Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1258          print_name(), be.bstrerror());
1259       return false;
1260    }
1261    Dmsg1(100, "Offlined device %s\n", print_name());
1262    return true;
1263 }
1264
1265 bool DEVICE::offline_or_rewind()
1266 {
1267    if (m_fd < 0) {
1268       return false;
1269    }
1270    if (has_cap(CAP_OFFLINEUNMOUNT)) {
1271       return offline();
1272    } else {
1273    /*
1274     * Note, this rewind probably should not be here (it wasn't
1275     *  in prior versions of Bacula), but on FreeBSD, this is
1276     *  needed in the case the tape was "frozen" due to an error
1277     *  such as backspacing after writing and EOF. If it is not
1278     *  done, all future references to the drive get and I/O error.
1279     */
1280       clrerror(MTREW);
1281       return rewind(NULL);
1282    }
1283 }
1284
1285 /*
1286  * Foward space a file
1287  *   Returns: true  on success
1288  *            false on failure
1289  */
1290 bool DEVICE::fsf(int num)
1291 {
1292    int32_t os_file = 0;
1293    struct mtop mt_com;
1294    int stat = 0;
1295
1296    if (!is_open()) {
1297       dev_errno = EBADF;
1298       Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1299       Emsg0(M_FATAL, 0, errmsg);
1300       return false;
1301    }
1302
1303    if (!is_tape()) {
1304       return true;
1305    }
1306
1307    if (at_eot()) {
1308       dev_errno = 0;
1309       Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1310       return false;
1311    }
1312    if (at_eof()) {
1313       Dmsg0(200, "ST_EOF set on entry to FSF\n");
1314    }
1315
1316    Dmsg0(100, "fsf\n");
1317    block_num = 0;
1318    /*
1319     * If Fast forward space file is set, then we
1320     *  use MTFSF to forward space and MTIOCGET
1321     *  to get the file position. We assume that
1322     *  the SCSI driver will ensure that we do not
1323     *  forward space past the end of the medium.
1324     */
1325    if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1326       int my_errno = 0;
1327       mt_com.mt_op = MTFSF;
1328       mt_com.mt_count = num;
1329       stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1330       if (stat < 0) {
1331          my_errno = errno;            /* save errno */
1332       } else if ((os_file=get_os_tape_file()) < 0) {
1333          my_errno = errno;            /* save errno */
1334       }
1335       if (my_errno != 0) {
1336          berrno be;
1337          set_eot();
1338          Dmsg0(200, "Set ST_EOT\n");
1339          clrerror(MTFSF);
1340          Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1341             print_name(), be.bstrerror(my_errno));
1342          Dmsg1(200, "%s", errmsg);
1343          return false;
1344       }
1345
1346       Dmsg1(200, "fsf file=%d\n", os_file);
1347       set_ateof();
1348       file = os_file;
1349       return true;
1350
1351    /*
1352     * Here if CAP_FSF is set, and virtually all drives
1353     *  these days support it, we read a record, then forward
1354     *  space one file. Using this procedure, which is slow,
1355     *  is the only way we can be sure that we don't read
1356     *  two consecutive EOF marks, which means End of Data.
1357     */
1358    } else if (has_cap(CAP_FSF)) {
1359       POOLMEM *rbuf;
1360       int rbuf_len;
1361       Dmsg0(200, "FSF has cap_fsf\n");
1362       if (max_block_size == 0) {
1363          rbuf_len = DEFAULT_BLOCK_SIZE;
1364       } else {
1365          rbuf_len = max_block_size;
1366       }
1367       rbuf = get_memory(rbuf_len);
1368       mt_com.mt_op = MTFSF;
1369       mt_com.mt_count = 1;
1370       while (num-- && !at_eot()) {
1371          Dmsg0(100, "Doing read before fsf\n");
1372          if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1373             if (errno == ENOMEM) {     /* tape record exceeds buf len */
1374                stat = rbuf_len;        /* This is OK */
1375             /*
1376              * On IBM drives, they return ENOSPC at EOM
1377              *  instead of EOF status
1378              */
1379             } else if (at_eof() && errno == ENOSPC) {
1380                stat = 0;
1381             } else {
1382                berrno be;
1383                set_eot();
1384                clrerror(-1);
1385                Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1386                   be.bstrerror());
1387                Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1388                   print_name(), be.bstrerror());
1389                Dmsg1(100, "%s", errmsg);
1390                break;
1391             }
1392          }
1393          if (stat == 0) {                /* EOF */
1394             Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1395             /* Two reads of zero means end of tape */
1396             if (at_eof()) {
1397                set_eot();
1398                Dmsg0(100, "Set ST_EOT\n");
1399                break;
1400             } else {
1401                set_ateof();
1402                continue;
1403             }
1404          } else {                        /* Got data */
1405             clear_eot();
1406             clear_eof();
1407          }
1408
1409          Dmsg0(100, "Doing MTFSF\n");
1410          stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1411          if (stat < 0) {                 /* error => EOT */
1412             berrno be;
1413             set_eot();
1414             Dmsg0(100, "Set ST_EOT\n");
1415             clrerror(MTFSF);
1416             Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1417                print_name(), be.bstrerror());
1418             Dmsg0(100, "Got < 0 for MTFSF\n");
1419             Dmsg1(100, "%s", errmsg);
1420          } else {
1421             set_ateof();
1422          }
1423       }
1424       free_memory(rbuf);
1425
1426    /*
1427     * No FSF, so use FSR to simulate it
1428     */
1429    } else {
1430       Dmsg0(200, "Doing FSR for FSF\n");
1431       while (num-- && !at_eot()) {
1432          fsr(INT32_MAX);    /* returns -1 on EOF or EOT */
1433       }
1434       if (at_eot()) {
1435          dev_errno = 0;
1436          Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1437          stat = -1;
1438       } else {
1439          stat = 0;
1440       }
1441    }
1442    Dmsg1(200, "Return %d from FSF\n", stat);
1443    if (at_eof()) {
1444       Dmsg0(200, "ST_EOF set on exit FSF\n");
1445    }
1446    if (at_eot()) {
1447       Dmsg0(200, "ST_EOT set on exit FSF\n");
1448    }
1449    Dmsg1(200, "Return from FSF file=%d\n", file);
1450    return stat == 0;
1451 }
1452
1453 /*
1454  * Backward space a file
1455  *  Returns: false on failure
1456  *           true  on success
1457  */
1458 bool DEVICE::bsf(int num)
1459 {
1460    struct mtop mt_com;
1461    int stat;
1462
1463    if (!is_open()) {
1464       dev_errno = EBADF;
1465       Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1466       Emsg0(M_FATAL, 0, errmsg);
1467       return false;
1468    }
1469
1470    if (!is_tape()) {
1471       Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1472          print_name());
1473       return false;
1474    }
1475
1476    Dmsg0(100, "bsf\n");
1477    clear_eot();
1478    clear_eof();
1479    file -= num;
1480    file_addr = 0;
1481    file_size = 0;
1482    mt_com.mt_op = MTBSF;
1483    mt_com.mt_count = num;
1484    stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1485    if (stat < 0) {
1486       berrno be;
1487       clrerror(MTBSF);
1488       Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1489          print_name(), be.bstrerror());
1490    }
1491    return stat == 0;
1492 }
1493
1494
1495 /*
1496  * Foward space num records
1497  *  Returns: false on failure
1498  *           true  on success
1499  */
1500 bool DEVICE::fsr(int num)
1501 {
1502    struct mtop mt_com;
1503    int stat;
1504
1505    if (!is_open()) {
1506       dev_errno = EBADF;
1507       Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1508       Emsg0(M_FATAL, 0, errmsg);
1509       return false;
1510    }
1511
1512    if (!is_tape()) {
1513       return false;
1514    }
1515
1516    if (!has_cap(CAP_FSR)) {
1517       Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1518       return false;
1519    }
1520
1521    Dmsg1(100, "fsr %d\n", num);
1522    mt_com.mt_op = MTFSR;
1523    mt_com.mt_count = num;
1524    stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1525    if (stat == 0) {
1526       clear_eof();
1527       block_num += num;
1528    } else {
1529       berrno be;
1530       struct mtget mt_stat;
1531       clrerror(MTFSR);
1532       Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1533       if (dev_get_os_pos(this, &mt_stat)) {
1534          Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1535             block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1536          file = mt_stat.mt_fileno;
1537          block_num = mt_stat.mt_blkno;
1538       } else {
1539          if (at_eof()) {
1540             set_eot();
1541          } else {
1542             set_ateof();
1543          }
1544       }
1545       Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1546          num, print_name(), be.bstrerror());
1547    }
1548    return stat == 0;
1549 }
1550
1551 /*
1552  * Backward space a record
1553  *   Returns:  false on failure
1554  *             true  on success
1555  */
1556 bool DEVICE::bsr(int num)
1557 {
1558    struct mtop mt_com;
1559    int stat;
1560
1561    if (!is_open()) {
1562       dev_errno = EBADF;
1563       Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1564       Emsg0(M_FATAL, 0, errmsg);
1565       return false;
1566    }
1567
1568    if (!is_tape()) {
1569       return false;
1570    }
1571
1572    if (!has_cap(CAP_BSR)) {
1573       Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1574       return false;
1575    }
1576
1577    Dmsg0(100, "bsr_dev\n");
1578    block_num -= num;
1579    clear_eof();
1580    clear_eot();
1581    mt_com.mt_op = MTBSR;
1582    mt_com.mt_count = num;
1583    stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1584    if (stat < 0) {
1585       berrno be;
1586       clrerror(MTBSR);
1587       Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1588          print_name(), be.bstrerror());
1589    }
1590    return stat == 0;
1591 }
1592
1593 void DEVICE::lock_door()
1594 {
1595 #ifdef MTLOCK
1596    struct mtop mt_com;
1597    mt_com.mt_op = MTLOCK;
1598    mt_com.mt_count = 1;
1599    d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1600 #endif
1601 }
1602
1603 void DEVICE::unlock_door()
1604 {
1605 #ifdef MTUNLOCK
1606    struct mtop mt_com;
1607    mt_com.mt_op = MTUNLOCK;
1608    mt_com.mt_count = 1;
1609    d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1610 #endif
1611 }
1612
1613 void DEVICE::set_slot(int32_t slot)
1614 {
1615    m_slot = slot;
1616    if (vol) vol->clear_slot();
1617 }
1618
1619 void DEVICE::clear_slot()
1620 {
1621    m_slot = -1;
1622    if (vol) vol->set_slot(-1);
1623 }
1624
1625
1626
1627 /*
1628  * Reposition the device to file, block
1629  * Returns: false on failure
1630  *          true  on success
1631  */
1632 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1633 {
1634    if (!is_open()) {
1635       dev_errno = EBADF;
1636       Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1637       Emsg0(M_FATAL, 0, errmsg);
1638       return false;
1639    }
1640
1641    if (!is_tape()) {
1642       boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1643       Dmsg1(100, "===== lseek to %d\n", (int)pos);
1644       if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1645          berrno be;
1646          dev_errno = errno;
1647          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1648             print_name(), be.bstrerror());
1649          return false;
1650       }
1651       file = rfile;
1652       block_num = rblock;
1653       file_addr = pos;
1654       return true;
1655    }
1656
1657    /* After this point, we are tape only */
1658    Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1659    if (rfile < file) {
1660       Dmsg0(100, "Rewind\n");
1661       if (!rewind(NULL)) {
1662          return false;
1663       }
1664    }
1665    if (rfile > file) {
1666       Dmsg1(100, "fsf %d\n", rfile-file);
1667       if (!fsf(rfile-file)) {
1668          Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1669          return false;
1670       }
1671       Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1672    }
1673    if (rblock < block_num) {
1674       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1675       Dmsg0(100, "bsf 1\n");
1676       bsf(1);
1677       Dmsg0(100, "fsf 1\n");
1678       fsf(1);
1679       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1680    }
1681    if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1682       /* Ignore errors as Bacula can read to the correct block */
1683       Dmsg1(100, "fsr %d\n", rblock-block_num);
1684       return fsr(rblock-block_num);
1685    } else {
1686       while (rblock > block_num) {
1687          if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1688             berrno be;
1689             dev_errno = errno;
1690             Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1691                print_name(), be.bstrerror());
1692             return false;
1693          }
1694          Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1695       }
1696    }
1697    return true;
1698 }
1699
1700
1701
1702 /*
1703  * Write an end of file on the device
1704  *   Returns: true on success
1705  *            false on failure
1706  */
1707 bool DEVICE::weof(int num)
1708 {
1709    struct mtop mt_com;
1710    int stat;
1711    Dmsg1(129, "=== weof_dev=%s\n", print_name());
1712
1713    if (!is_open()) {
1714       dev_errno = EBADF;
1715       Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1716       Emsg0(M_FATAL, 0, errmsg);
1717       return false;
1718    }
1719    file_size = 0;
1720
1721    if (!is_tape()) {
1722       return true;
1723    }
1724    if (!can_append()) {
1725       Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1726       Emsg0(M_FATAL, 0, errmsg);
1727       return false;
1728    }
1729
1730    clear_eof();
1731    clear_eot();
1732    mt_com.mt_op = MTWEOF;
1733    mt_com.mt_count = num;
1734    stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1735    if (stat == 0) {
1736       block_num = 0;
1737       file += num;
1738       file_addr = 0;
1739    } else {
1740       berrno be;
1741       clrerror(MTWEOF);
1742       if (stat == -1) {
1743          Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1744             print_name(), be.bstrerror());
1745        }
1746    }
1747    return stat == 0;
1748 }
1749
1750
1751 /*
1752  * If implemented in system, clear the tape
1753  * error status.
1754  */
1755 void DEVICE::clrerror(int func)
1756 {
1757    const char *msg = NULL;
1758    char buf[100];
1759
1760    dev_errno = errno;         /* save errno */
1761    if (errno == EIO) {
1762       VolCatInfo.VolCatErrors++;
1763    }
1764
1765    if (!is_tape()) {
1766       return;
1767    }
1768
1769    if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1770       switch (func) {
1771       case -1:
1772          break;                  /* ignore message printed later */
1773       case MTWEOF:
1774          msg = "WTWEOF";
1775          clear_cap(CAP_EOF);     /* turn off feature */
1776          break;
1777 #ifdef MTEOM
1778       case MTEOM:
1779          msg = "WTEOM";
1780          clear_cap(CAP_EOM);     /* turn off feature */
1781          break;
1782 #endif
1783       case MTFSF:
1784          msg = "MTFSF";
1785          clear_cap(CAP_FSF);     /* turn off feature */
1786          break;
1787       case MTBSF:
1788          msg = "MTBSF";
1789          clear_cap(CAP_BSF);     /* turn off feature */
1790          break;
1791       case MTFSR:
1792          msg = "MTFSR";
1793          clear_cap(CAP_FSR);     /* turn off feature */
1794          break;
1795       case MTBSR:
1796          msg = "MTBSR";
1797          clear_cap(CAP_BSR);     /* turn off feature */
1798          break;
1799       case MTREW:
1800          msg = "MTREW";
1801          break;
1802 #ifdef MTSETBLK
1803       case MTSETBLK:
1804          msg = "MTSETBLK";
1805          break;
1806 #endif
1807 #ifdef MTSETDRVBUFFER
1808       case MTSETDRVBUFFER:
1809          msg = "MTSETDRVBUFFER";
1810          break;
1811 #endif
1812 #ifdef MTRESET
1813       case MTRESET:
1814          msg = "MTRESET";
1815          break;
1816 #endif
1817
1818 #ifdef MTSETBSIZ
1819       case MTSETBSIZ:
1820          msg = "MTSETBSIZ";
1821          break;
1822 #endif
1823 #ifdef MTSRSZ
1824       case MTSRSZ:
1825          msg = "MTSRSZ";
1826          break;
1827 #endif
1828 #ifdef MTLOAD
1829       case MTLOAD:
1830          msg = "MTLOAD";
1831          break;
1832 #endif
1833 #ifdef MTUNLOCK
1834       case MTUNLOCK:
1835          msg = "MTUNLOCK";
1836          break;
1837 #endif
1838       case MTOFFL:
1839          msg = "MTOFFL";
1840          break;
1841       default:
1842          bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1843          msg = buf;
1844          break;
1845       }
1846       if (msg != NULL) {
1847          dev_errno = ENOSYS;
1848          Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1849          Emsg0(M_ERROR, 0, errmsg);
1850       }
1851    }
1852
1853    /*
1854     * Now we try different methods of clearing the error
1855     *  status on the drive so that it is not locked for
1856     *  further operations.
1857     */
1858
1859    /* On some systems such as NetBSD, this clears all errors */
1860    get_os_tape_file();
1861
1862 /* Found on Solaris */
1863 #ifdef MTIOCLRERR
1864 {
1865    d_ioctl(m_fd, MTIOCLRERR);
1866    Dmsg0(200, "Did MTIOCLRERR\n");
1867 }
1868 #endif
1869
1870 /* Typically on FreeBSD */
1871 #ifdef MTIOCERRSTAT
1872 {
1873   berrno be;
1874    /* Read and clear SCSI error status */
1875    union mterrstat mt_errstat;
1876    Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1877       be.bstrerror(dev_errno));
1878    d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1879 }
1880 #endif
1881
1882 /* Clear Subsystem Exception OSF1 */
1883 #ifdef MTCSE
1884 {
1885    struct mtop mt_com;
1886    mt_com.mt_op = MTCSE;
1887    mt_com.mt_count = 1;
1888    /* Clear any error condition on the tape */
1889    d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1890    Dmsg0(200, "Did MTCSE\n");
1891 }
1892 #endif
1893 }
1894
1895
1896 /*
1897  * Set to unload the current volume in the drive
1898  */
1899 void DEVICE::set_unload()
1900 {
1901    if (!m_unload && VolHdr.VolumeName[0] != 0) {
1902        m_unload = true;
1903        memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1904    }
1905 }
1906
1907
1908 /*
1909  * Clear volume header
1910  */
1911 void DEVICE::clear_volhdr()
1912 {
1913    Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1914    memset(&VolHdr, 0, sizeof(VolHdr));
1915    setVolCatInfo(false);
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->getVolCatName();
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 }