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

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