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

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