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