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

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