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

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