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 plus additions
  11    that are listed 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(29, "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(29, "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(29, "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(050, "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(050, "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(050, "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(29, "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(29, "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(29, "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(29, "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(29, "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(29, "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(29, "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(29, "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(29, "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(29, "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(29, "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(29, "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(29, "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;
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 errno_save;
1298       mt_com.mt_op = MTFSF;
1299       mt_com.mt_count = num;
1300       stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1301       errno_save = errno;
1302       if (stat < 0 || (os_file=get_os_tape_file()) < 0) {
1303          if (os_file >= 0) {             /* get_os_tape_file reset errno */
1304             errno = errno_save;
1305          }
1306          berrno be;
1307          set_eot();
1308          Dmsg0(200, "Set ST_EOT\n");
1309          clrerror(MTFSF);
1310          Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1311             print_name(), be.bstrerror());
1312          Dmsg1(200, "%s", errmsg);
1313          return false;
1314       }
1315       Dmsg1(200, "fsf file=%d\n", os_file);
1316       set_ateof();
1317       file = os_file;
1318       return true;
1319
1320    /*
1321     * Here if CAP_FSF is set, and virtually all drives
1322     *  these days support it, we read a record, then forward
1323     *  space one file. Using this procedure, which is slow,
1324     *  is the only way we can be sure that we don't read
1325     *  two consecutive EOF marks, which means End of Data.
1326     */
1327    } else if (has_cap(CAP_FSF)) {
1328       POOLMEM *rbuf;
1329       int rbuf_len;
1330       Dmsg0(200, "FSF has cap_fsf\n");
1331       if (max_block_size == 0) {
1332          rbuf_len = DEFAULT_BLOCK_SIZE;
1333       } else {
1334          rbuf_len = max_block_size;
1335       }
1336       rbuf = get_memory(rbuf_len);
1337       mt_com.mt_op = MTFSF;
1338       mt_com.mt_count = 1;
1339       while (num-- && !at_eot()) {
1340          Dmsg0(100, "Doing read before fsf\n");
1341          if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1342             if (errno == ENOMEM) {     /* tape record exceeds buf len */
1343                stat = rbuf_len;        /* This is OK */
1344             /*
1345              * On IBM drives, they return ENOSPC at EOM
1346              *  instead of EOF status
1347              */
1348             } else if (at_eof() && errno == ENOSPC) {
1349                stat = 0;
1350             } else {
1351                berrno be;
1352                set_eot();
1353                clrerror(-1);
1354                Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1355                   be.bstrerror());
1356                Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1357                   print_name(), be.bstrerror());
1358                Dmsg1(100, "%s", errmsg);
1359                break;
1360             }
1361          }
1362          if (stat == 0) {                /* EOF */
1363             Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1364             /* Two reads of zero means end of tape */
1365             if (at_eof()) {
1366                set_eot();
1367                Dmsg0(100, "Set ST_EOT\n");
1368                break;
1369             } else {
1370                set_ateof();
1371                continue;
1372             }
1373          } else {                        /* Got data */
1374             clear_eot();
1375             clear_eof();
1376          }
1377
1378          Dmsg0(100, "Doing MTFSF\n");
1379          stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1380          if (stat < 0) {                 /* error => EOT */
1381             berrno be;
1382             set_eot();
1383             Dmsg0(100, "Set ST_EOT\n");
1384             clrerror(MTFSF);
1385             Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1386                print_name(), be.bstrerror());
1387             Dmsg0(100, "Got < 0 for MTFSF\n");
1388             Dmsg1(100, "%s", errmsg);
1389          } else {
1390             set_ateof();
1391          }
1392       }
1393       free_memory(rbuf);
1394
1395    /*
1396     * No FSF, so use FSR to simulate it
1397     */
1398    } else {
1399       Dmsg0(200, "Doing FSR for FSF\n");
1400       while (num-- && !at_eot()) {
1401          fsr(INT32_MAX);    /* returns -1 on EOF or EOT */
1402       }
1403       if (at_eot()) {
1404          dev_errno = 0;
1405          Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1406          stat = -1;
1407       } else {
1408          stat = 0;
1409       }
1410    }
1411    Dmsg1(200, "Return %d from FSF\n", stat);
1412    if (at_eof()) {
1413       Dmsg0(200, "ST_EOF set on exit FSF\n");
1414    }
1415    if (at_eot()) {
1416       Dmsg0(200, "ST_EOT set on exit FSF\n");
1417    }
1418    Dmsg1(200, "Return from FSF file=%d\n", file);
1419    return stat == 0;
1420 }
1421
1422 /*
1423  * Backward space a file
1424  *  Returns: false on failure
1425  *           true  on success
1426  */
1427 bool DEVICE::bsf(int num)
1428 {
1429    struct mtop mt_com;
1430    int stat;
1431
1432    if (!is_open()) {
1433       dev_errno = EBADF;
1434       Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1435       Emsg0(M_FATAL, 0, errmsg);
1436       return false;
1437    }
1438
1439    if (!is_tape()) {
1440       Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1441          print_name());
1442       return false;
1443    }
1444
1445    Dmsg0(29, "bsf\n");
1446    clear_eot();
1447    clear_eof();
1448    file -= num;
1449    file_addr = 0;
1450    file_size = 0;
1451    mt_com.mt_op = MTBSF;
1452    mt_com.mt_count = num;
1453    stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1454    if (stat < 0) {
1455       berrno be;
1456       clrerror(MTBSF);
1457       Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1458          print_name(), be.bstrerror());
1459    }
1460    return stat == 0;
1461 }
1462
1463
1464 /*
1465  * Foward space num records
1466  *  Returns: false on failure
1467  *           true  on success
1468  */
1469 bool DEVICE::fsr(int num)
1470 {
1471    struct mtop mt_com;
1472    int stat;
1473
1474    if (!is_open()) {
1475       dev_errno = EBADF;
1476       Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1477       Emsg0(M_FATAL, 0, errmsg);
1478       return false;
1479    }
1480
1481    if (!is_tape()) {
1482       return false;
1483    }
1484
1485    if (!has_cap(CAP_FSR)) {
1486       Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1487       return false;
1488    }
1489
1490    Dmsg1(29, "fsr %d\n", num);
1491    mt_com.mt_op = MTFSR;
1492    mt_com.mt_count = num;
1493    stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1494    if (stat == 0) {
1495       clear_eof();
1496       block_num += num;
1497    } else {
1498       berrno be;
1499       struct mtget mt_stat;
1500       clrerror(MTFSR);
1501       Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1502       if (dev_get_os_pos(this, &mt_stat)) {
1503          Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1504             block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1505          file = mt_stat.mt_fileno;
1506          block_num = mt_stat.mt_blkno;
1507       } else {
1508          if (at_eof()) {
1509             set_eot();
1510          } else {
1511             set_ateof();
1512          }
1513       }
1514       Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1515          num, print_name(), be.bstrerror());
1516    }
1517    return stat == 0;
1518 }
1519
1520 /*
1521  * Backward space a record
1522  *   Returns:  false on failure
1523  *             true  on success
1524  */
1525 bool DEVICE::bsr(int num)
1526 {
1527    struct mtop mt_com;
1528    int stat;
1529
1530    if (!is_open()) {
1531       dev_errno = EBADF;
1532       Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1533       Emsg0(M_FATAL, 0, errmsg);
1534       return false;
1535    }
1536
1537    if (!is_tape()) {
1538       return false;
1539    }
1540
1541    if (!has_cap(CAP_BSR)) {
1542       Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1543       return false;
1544    }
1545
1546    Dmsg0(29, "bsr_dev\n");
1547    block_num -= num;
1548    clear_eof();
1549    clear_eot();
1550    mt_com.mt_op = MTBSR;
1551    mt_com.mt_count = num;
1552    stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1553    if (stat < 0) {
1554       berrno be;
1555       clrerror(MTBSR);
1556       Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1557          print_name(), be.bstrerror());
1558    }
1559    return stat == 0;
1560 }
1561
1562 void DEVICE::lock_door()
1563 {
1564 #ifdef MTLOCK
1565    struct mtop mt_com;
1566    mt_com.mt_op = MTLOCK;
1567    mt_com.mt_count = 1;
1568    tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1569 #endif
1570 }
1571
1572 void DEVICE::unlock_door()
1573 {
1574 #ifdef MTUNLOCK
1575    struct mtop mt_com;
1576    mt_com.mt_op = MTUNLOCK;
1577    mt_com.mt_count = 1;
1578    tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1579 #endif
1580 }
1581
1582
1583 /*
1584  * Reposition the device to file, block
1585  * Returns: false on failure
1586  *          true  on success
1587  */
1588 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1589 {
1590    if (!is_open()) {
1591       dev_errno = EBADF;
1592       Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1593       Emsg0(M_FATAL, 0, errmsg);
1594       return false;
1595    }
1596
1597    if (!is_tape()) {
1598       boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1599       Dmsg1(100, "===== lseek to %d\n", (int)pos);
1600       if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1601          berrno be;
1602          dev_errno = errno;
1603          Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1604             print_name(), be.bstrerror());
1605          return false;
1606       }
1607       file = rfile;
1608       block_num = rblock;
1609       file_addr = pos;
1610       return true;
1611    }
1612
1613    /* After this point, we are tape only */
1614    Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1615    if (rfile < file) {
1616       Dmsg0(100, "Rewind\n");
1617       if (!rewind(NULL)) {
1618          return false;
1619       }
1620    }
1621    if (rfile > file) {
1622       Dmsg1(100, "fsf %d\n", rfile-file);
1623       if (!fsf(rfile-file)) {
1624          Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1625          return false;
1626       }
1627       Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1628    }
1629    if (rblock < block_num) {
1630       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1631       Dmsg0(100, "bsf 1\n");
1632       bsf(1);
1633       Dmsg0(100, "fsf 1\n");
1634       fsf(1);
1635       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1636    }
1637    if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1638       /* Ignore errors as Bacula can read to the correct block */
1639       Dmsg1(100, "fsr %d\n", rblock-block_num);
1640       return fsr(rblock-block_num);
1641    } else {
1642       while (rblock > block_num) {
1643          if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1644             berrno be;
1645             dev_errno = errno;
1646             Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1647                print_name(), be.bstrerror());
1648             return false;
1649          }
1650          Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1651       }
1652    }
1653    return true;
1654 }
1655
1656
1657
1658 /*
1659  * Write an end of file on the device
1660  *   Returns: true on success
1661  *            false on failure
1662  */
1663 bool DEVICE::weof(int num)
1664 {
1665    struct mtop mt_com;
1666    int stat;
1667    Dmsg0(129, "weof_dev\n");
1668
1669    if (!is_open()) {
1670       dev_errno = EBADF;
1671       Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1672       Emsg0(M_FATAL, 0, errmsg);
1673       return false;
1674    }
1675    file_size = 0;
1676
1677    if (!is_tape()) {
1678       return true;
1679    }
1680    if (!can_append()) {
1681       Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1682       Emsg0(M_FATAL, 0, errmsg);
1683       return false;
1684    }
1685
1686    clear_eof();
1687    clear_eot();
1688    mt_com.mt_op = MTWEOF;
1689    mt_com.mt_count = num;
1690    stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1691    if (stat == 0) {
1692       block_num = 0;
1693       file += num;
1694       file_addr = 0;
1695    } else {
1696       berrno be;
1697       clrerror(MTWEOF);
1698       if (stat == -1) {
1699          Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1700             print_name(), be.bstrerror());
1701        }
1702    }
1703    return stat == 0;
1704 }
1705
1706
1707 /*
1708  * If implemented in system, clear the tape
1709  * error status.
1710  */
1711 void DEVICE::clrerror(int func)
1712 {
1713    const char *msg = NULL;
1714    char buf[100];
1715
1716    dev_errno = errno;         /* save errno */
1717    if (errno == EIO) {
1718       VolCatInfo.VolCatErrors++;
1719    }
1720
1721    if (!is_tape()) {
1722       return;
1723    }
1724
1725    if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1726       switch (func) {
1727       case -1:
1728          break;                  /* ignore message printed later */
1729       case MTWEOF:
1730          msg = "WTWEOF";
1731          clear_cap(CAP_EOF);     /* turn off feature */
1732          break;
1733 #ifdef MTEOM
1734       case MTEOM:
1735          msg = "WTEOM";
1736          clear_cap(CAP_EOM);     /* turn off feature */
1737          break;
1738 #endif
1739       case MTFSF:
1740          msg = "MTFSF";
1741          clear_cap(CAP_FSF);     /* turn off feature */
1742          break;
1743       case MTBSF:
1744          msg = "MTBSF";
1745          clear_cap(CAP_BSF);     /* turn off feature */
1746          break;
1747       case MTFSR:
1748          msg = "MTFSR";
1749          clear_cap(CAP_FSR);     /* turn off feature */
1750          break;
1751       case MTBSR:
1752          msg = "MTBSR";
1753          clear_cap(CAP_BSR);     /* turn off feature */
1754          break;
1755       case MTREW:
1756          msg = "MTREW";
1757          break;
1758 #ifdef MTSETBLK
1759       case MTSETBLK:
1760          msg = "MTSETBLK";
1761          break;
1762 #endif
1763 #ifdef MTSETDRVBUFFER
1764       case MTSETDRVBUFFER:
1765          msg = "MTSETDRVBUFFER";
1766          break;
1767 #endif
1768 #ifdef MTRESET
1769       case MTRESET:
1770          msg = "MTRESET";
1771          break;
1772 #endif
1773
1774 #ifdef MTSETBSIZ
1775       case MTSETBSIZ:
1776          msg = "MTSETBSIZ";
1777          break;
1778 #endif
1779 #ifdef MTSRSZ
1780       case MTSRSZ:
1781          msg = "MTSRSZ";
1782          break;
1783 #endif
1784 #ifdef MTLOAD
1785       case MTLOAD:
1786          msg = "MTLOAD";
1787          break;
1788 #endif
1789 #ifdef MTUNLOCK
1790       case MTUNLOCK:
1791          msg = "MTUNLOCK";
1792          break;
1793 #endif
1794       case MTOFFL:
1795          msg = "MTOFFL";
1796          break;
1797       default:
1798          bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1799          msg = buf;
1800          break;
1801       }
1802       if (msg != NULL) {
1803          dev_errno = ENOSYS;
1804          Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1805          Emsg0(M_ERROR, 0, errmsg);
1806       }
1807    }
1808
1809    /*
1810     * Now we try different methods of clearing the error
1811     *  status on the drive so that it is not locked for
1812     *  further operations.
1813     */
1814
1815    /* On some systems such as NetBSD, this clears all errors */
1816    get_os_tape_file();
1817
1818 /* Found on Solaris */
1819 #ifdef MTIOCLRERR
1820 {
1821    tape_ioctl(m_fd, MTIOCLRERR);
1822    Dmsg0(200, "Did MTIOCLRERR\n");
1823 }
1824 #endif
1825
1826 /* Typically on FreeBSD */
1827 #ifdef MTIOCERRSTAT
1828 {
1829   berrno be;
1830    /* Read and clear SCSI error status */
1831    union mterrstat mt_errstat;
1832    Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1833       be.bstrerror(dev_errno));
1834    tape_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1835 }
1836 #endif
1837
1838 /* Clear Subsystem Exception OSF1 */
1839 #ifdef MTCSE
1840 {
1841    struct mtop mt_com;
1842    mt_com.mt_op = MTCSE;
1843    mt_com.mt_count = 1;
1844    /* Clear any error condition on the tape */
1845    tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1846    Dmsg0(200, "Did MTCSE\n");
1847 }
1848 #endif
1849 }
1850
1851
1852 /*
1853  * Clear volume header
1854  */
1855 void DEVICE::clear_volhdr()
1856 {
1857    /* If we have an unused volume associated with this drive, free it */
1858    if (vol && !is_busy()) {
1859       free_volume(this);
1860    }
1861    Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1862    memset(&VolHdr, 0, sizeof(VolHdr));
1863 }
1864
1865
1866 /*
1867  * Close the device
1868  */
1869 void DEVICE::close()
1870 {
1871    Dmsg1(100, "close_dev %s\n", print_name());
1872    if (has_cap(CAP_OFFLINEUNMOUNT)) {
1873       offline();
1874    }
1875
1876    if (!is_open()) {
1877       Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1878          VolHdr.VolumeName);
1879       return;                         /* already closed */
1880    }
1881
1882    switch (dev_type) {
1883    case B_TAPE_DEV:
1884       unlock_door();
1885       tape_close(m_fd);
1886       break;
1887    default:
1888       ::close(m_fd);
1889    }
1890
1891    /* Clean up device packet so it can be reused */
1892    clear_opened();
1893    state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1894    label_type = B_BACULA_LABEL;
1895    file = block_num = 0;
1896    file_size = 0;
1897    file_addr = 0;
1898    EndFile = EndBlock = 0;
1899    openmode = 0;
1900    Slot = -1;             /* unknown slot */
1901    clear_volhdr();
1902    memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1903    if (tid) {
1904       stop_thread_timer(tid);
1905       tid = 0;
1906    }
1907 }
1908
1909 /*
1910  * This call closes the device, but it is used in DVD handling
1911  *  where we close one part and then open the next part. The
1912  *  difference between close_part() and close() is that close_part()
1913  *  saves the state information of the device (e.g. the Volume lable,
1914  *  the Volume Catalog record, ...  This permits opening and closing
1915  *  the Volume parts multiple times without losing track of what the
1916  *  main Volume parameters are.
1917  */
1918 void DEVICE::close_part(DCR *dcr)
1919 {
1920    VOLUME_LABEL saveVolHdr;
1921    VOLUME_CAT_INFO saveVolCatInfo;     /* Volume Catalog Information */
1922
1923
1924    saveVolHdr = VolHdr;               /* structure assignment */
1925    saveVolCatInfo = VolCatInfo;       /* structure assignment */
1926    close();                           /* close current part */
1927    VolHdr = saveVolHdr;               /* structure assignment */
1928    VolCatInfo = saveVolCatInfo;       /* structure assignment */
1929    dcr->VolCatInfo = saveVolCatInfo;  /* structure assignment */
1930 }
1931
1932 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1933 {
1934    switch (dev_type) {
1935    case B_DVD_DEV:
1936       return lseek_dvd(dcr, offset, whence);
1937    case B_FILE_DEV:
1938 #if defined(HAVE_WIN32)
1939       return ::_lseeki64(m_fd, (__int64)offset, whence);
1940 #else
1941       return ::lseek(m_fd, (off_t)offset, whence);
1942 #endif
1943    }
1944    return -1;
1945 }
1946
1947
1948 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1949 {
1950    Dmsg1(100, "truncate %s\n", print_name());
1951    switch (dev_type) {
1952    case B_TAPE_DEV:
1953       /* maybe we should rewind and write and eof ???? */
1954       return true;                    /* we don't really truncate tapes */
1955    case B_DVD_DEV:
1956       return truncate_dvd(dcr);
1957    case B_FILE_DEV:
1958       /* ***FIXME*** we really need to unlink() the file so that
1959        *  its name can be changed for a relabel.
1960        */
1961       if (ftruncate(m_fd, 0) != 0) {
1962          berrno be;
1963          Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1964                print_name(), be.bstrerror());
1965          return false;
1966       }
1967       return true;
1968    }
1969    return false;
1970 }
1971
1972 /* Mount the device.
1973  * If timeout, wait until the mount command returns 0.
1974  * If !timeout, try to mount the device only once.
1975  */
1976 bool DEVICE::mount(int timeout)
1977 {
1978    Dmsg0(190, "Enter mount\n");
1979    if (is_mounted()) {
1980       return true;
1981    } else if (requires_mount()) {
1982       return do_mount(1, timeout);
1983    }
1984    return true;
1985 }
1986
1987 /* Unmount the device
1988  * If timeout, wait until the unmount command returns 0.
1989  * If !timeout, try to unmount the device only once.
1990  */
1991 bool DEVICE::unmount(int timeout)
1992 {
1993    Dmsg0(90, "Enter unmount\n");
1994    if (is_mounted()) {
1995       return do_mount(0, timeout);
1996    }
1997    return true;
1998 }
1999
2000 /* (Un)mount the device */
2001 bool DEVICE::do_mount(int mount, int dotimeout)
2002 {
2003    POOL_MEM ocmd(PM_FNAME);
2004    POOLMEM *results;
2005    char *icmd;
2006    int status, timeout;
2007
2008    sm_check(__FILE__, __LINE__, false);
2009    if (mount) {
2010       if (is_mounted()) {
2011          Dmsg0(200, "======= mount=1\n");
2012          return true;
2013       }
2014       icmd = device->mount_command;
2015    } else {
2016       if (!is_mounted()) {
2017          Dmsg0(200, "======= mount=0\n");
2018          return true;
2019       }
2020       icmd = device->unmount_command;
2021    }
2022
2023    clear_freespace_ok();
2024    edit_mount_codes(ocmd, icmd);
2025
2026    Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2027
2028    if (dotimeout) {
2029       /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
2030       timeout = 1;
2031    } else {
2032       timeout = 0;
2033    }
2034    results = get_memory(4000);
2035    results[0] = 0;
2036
2037    /* If busy retry each second */
2038    Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
2039    while ((status = run_program_full_output(ocmd.c_str(),
2040                        max_open_wait/2, results)) != 0) {
2041       /* Doesn't work with internationalization (This is not a problem) */
2042       if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2043          break;
2044       }
2045       if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2046          break;
2047       }
2048       if (timeout-- > 0) {
2049          /* Sometimes the device cannot be mounted because it is already mounted.
2050           * Try to unmount it, then remount it */
2051          if (mount) {
2052             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2053             do_mount(0, 0);
2054          }
2055          bmicrosleep(1, 0);
2056          continue;
2057       }
2058       if (status != 0) {
2059          berrno be;
2060          Dmsg5(40, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2061               (mount ? "" : "un"), status, results, be.bstrerror(status));
2062          Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2063               print_name(), (mount ? "" : "un"), be.bstrerror(status));
2064       } else {
2065          Dmsg4(40, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2066               (mount ? "" : "un"), status, results);
2067          Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2068               print_name(), (mount ? "" : "un"), results);
2069       }
2070       /*
2071        * Now, just to be sure it is not mounted, try to read the
2072        *  filesystem.
2073        */
2074       DIR* dp;
2075       struct dirent *entry, *result;
2076       int name_max;
2077       int count;
2078
2079       name_max = pathconf(".", _PC_NAME_MAX);
2080       if (name_max < 1024) {
2081          name_max = 1024;
2082       }
2083
2084       if (!(dp = opendir(device->mount_point))) {
2085          berrno be;
2086          dev_errno = errno;
2087          Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2088                device->mount_point, print_name(), be.bstrerror());
2089          goto get_out;
2090       }
2091
2092       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2093       count = 0;
2094       while (1) {
2095          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2096             dev_errno = EIO;
2097             Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2098                   device->mount_point, print_name());
2099             break;
2100          }
2101          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2102             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2103             break;
2104          } else {
2105             Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2106          }
2107       }
2108       free(entry);
2109       closedir(dp);
2110
2111       Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2112
2113       if (count > 0) {
2114          /* If we got more than ., .. and .keep */
2115          /*   there must be something mounted */
2116          if (mount) {
2117             Dmsg1(100, "Did Mount by count=%d\n", count);
2118             break;
2119          } else {
2120             /* An unmount request. We failed to unmount - report an error */
2121             set_mounted(true);
2122             free_pool_memory(results);
2123             Dmsg0(200, "== error mount=1 wanted unmount\n");
2124             return false;
2125          }
2126       }
2127 get_out:
2128       set_mounted(false);
2129       sm_check(__FILE__, __LINE__, false);
2130       free_pool_memory(results);
2131       Dmsg0(200, "============ mount=0\n");
2132       return false;
2133    }
2134
2135    set_mounted(mount);              /* set/clear mounted flag */
2136    free_pool_memory(results);
2137    /* Do not check free space when unmounting */
2138    if (mount && !update_freespace()) {
2139       return false;
2140    }
2141    Dmsg1(200, "============ mount=%d\n", mount);
2142    return true;
2143 }
2144
2145 /*
2146  * Edit codes into (Un)MountCommand, Write(First)PartCommand
2147  *  %% = %
2148  *  %a = archive device name
2149  *  %e = erase (set if cannot mount and first part)
2150  *  %n = part number
2151  *  %m = mount point
2152  *  %v = last part name
2153  *
2154  *  omsg = edited output message
2155  *  imsg = input string containing edit codes (%x)
2156  *
2157  */
2158 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2159 {
2160    const char *p;
2161    const char *str;
2162    char add[20];
2163
2164    POOL_MEM archive_name(PM_FNAME);
2165
2166    omsg.c_str()[0] = 0;
2167    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2168    for (p=imsg; *p; p++) {
2169       if (*p == '%') {
2170          switch (*++p) {
2171          case '%':
2172             str = "%";
2173             break;
2174          case 'a':
2175             str = dev_name;
2176             break;
2177          case 'e':
2178             if (num_dvd_parts == 0) {
2179                if (truncating || blank_dvd) {
2180                   str = "2";
2181                } else {
2182                   str = "1";
2183                }
2184             } else {
2185                str = "0";
2186             }
2187             break;
2188          case 'n':
2189             bsnprintf(add, sizeof(add), "%d", part);
2190             str = add;
2191             break;
2192          case 'm':
2193             str = device->mount_point;
2194             break;
2195          case 'v':
2196             make_spooled_dvd_filename(this, archive_name);
2197             str = archive_name.c_str();
2198             break;
2199          default:
2200             add[0] = '%';
2201             add[1] = *p;
2202             add[2] = 0;
2203             str = add;
2204             break;
2205          }
2206       } else {
2207          add[0] = *p;
2208          add[1] = 0;
2209          str = add;
2210       }
2211       Dmsg1(1900, "add_str %s\n", str);
2212       pm_strcat(omsg, (char *)str);
2213       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2214    }
2215 }
2216
2217 /* return the last timer interval (ms) */
2218 btime_t DEVICE::get_timer_count()
2219 {
2220    btime_t old = last_timer;
2221    last_timer = get_current_btime();
2222    return last_timer - old;
2223 }
2224
2225 /* read from fd */
2226 ssize_t DEVICE::read(void *buf, size_t len)
2227 {
2228    ssize_t read_len ;
2229
2230    get_timer_count();
2231
2232    if (this->is_tape()) {
2233       read_len = tape_read(m_fd, buf, len);
2234    } else {
2235       read_len = ::read(m_fd, buf, len);
2236    }
2237
2238    last_tick = get_timer_count();
2239
2240    DevReadTime += last_tick;
2241    VolCatInfo.VolReadTime += last_tick;
2242
2243    if (read_len > 0) {          /* skip error */
2244       DevReadBytes += read_len;
2245    }
2246
2247    return read_len;
2248 }
2249
2250 /* write to fd */
2251 ssize_t DEVICE::write(const void *buf, size_t len)
2252 {
2253    ssize_t write_len ;
2254
2255    get_timer_count();
2256
2257    if (this->is_tape()) {
2258       write_len = tape_write(m_fd, buf, len);
2259    } else {
2260       write_len = ::write(m_fd, buf, len);
2261    }
2262
2263    last_tick = get_timer_count();
2264
2265    DevWriteTime += last_tick;
2266    VolCatInfo.VolWriteTime += last_tick;
2267
2268    if (write_len > 0) {         /* skip error */
2269       DevWriteBytes += write_len;
2270    }
2271
2272    return write_len;
2273 }
2274
2275 /* Return the resource name for the device */
2276 const char *DEVICE::name() const
2277 {
2278    return device->hdr.name;
2279 }
2280
2281 /* Returns file position on tape or -1 */
2282 int32_t DEVICE::get_os_tape_file()
2283 {
2284    struct mtget mt_stat;
2285
2286    if (has_cap(CAP_MTIOCGET) &&
2287        tape_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2288       return mt_stat.mt_fileno;
2289    }
2290    return -1;
2291 }
2292
2293 char *
2294 dev_vol_name(DEVICE *dev)
2295 {
2296    return dev->VolCatInfo.VolCatName;
2297 }
2298
2299
2300 /*
2301  * Free memory allocated for the device
2302  */
2303 void DEVICE::term(void)
2304 {
2305    Dmsg1(900, "term dev: %s\n", print_name());
2306    close();
2307    if (dev_name) {
2308       free_memory(dev_name);
2309       dev_name = NULL;
2310    }
2311    if (prt_name) {
2312       free_memory(prt_name);
2313       prt_name = NULL;
2314    }
2315    if (errmsg) {
2316       free_pool_memory(errmsg);
2317       errmsg = NULL;
2318    }
2319    pthread_mutex_destroy(&m_mutex);
2320    pthread_cond_destroy(&wait);
2321    pthread_cond_destroy(&wait_next_vol);
2322    pthread_mutex_destroy(&spool_mutex);
2323 // rwl_destroy(&lock);
2324    if (attached_dcrs) {
2325       delete attached_dcrs;
2326       attached_dcrs = NULL;
2327    }
2328    if (device) {
2329       device->dev = NULL;
2330    }
2331    free((char *)this);
2332 }
2333
2334 /*
2335  * This routine initializes the device wait timers
2336  */
2337 void init_device_wait_timers(DCR *dcr)
2338 {
2339    DEVICE *dev = dcr->dev;
2340    JCR *jcr = dcr->jcr;
2341
2342    /* ******FIXME******* put these on config variables */
2343    dev->min_wait = 60 * 60;
2344    dev->max_wait = 24 * 60 * 60;
2345    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2346    dev->wait_sec = dev->min_wait;
2347    dev->rem_wait_sec = dev->wait_sec;
2348    dev->num_wait = 0;
2349    dev->poll = false;
2350    dev->BadVolName[0] = 0;
2351
2352    jcr->min_wait = 60 * 60;
2353    jcr->max_wait = 24 * 60 * 60;
2354    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2355    jcr->wait_sec = jcr->min_wait;
2356    jcr->rem_wait_sec = jcr->wait_sec;
2357    jcr->num_wait = 0;
2358
2359 }
2360
2361 void init_jcr_device_wait_timers(JCR *jcr)
2362 {
2363    /* ******FIXME******* put these on config variables */
2364    jcr->min_wait = 60 * 60;
2365    jcr->max_wait = 24 * 60 * 60;
2366    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2367    jcr->wait_sec = jcr->min_wait;
2368    jcr->rem_wait_sec = jcr->wait_sec;
2369    jcr->num_wait = 0;
2370 }
2371
2372
2373 /*
2374  * The dev timers are used for waiting on a particular device
2375  *
2376  * Returns: true if time doubled
2377  *          false if max time expired
2378  */
2379 bool double_dev_wait_time(DEVICE *dev)
2380 {
2381    dev->wait_sec *= 2;               /* double wait time */
2382    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2383       dev->wait_sec = dev->max_wait;
2384    }
2385    dev->num_wait++;
2386    dev->rem_wait_sec = dev->wait_sec;
2387    if (dev->num_wait >= dev->max_num_wait) {
2388       return false;
2389    }
2390    return true;
2391 }
2392
2393
2394 void set_os_device_parameters(DCR *dcr)
2395 {
2396    DEVICE *dev = dcr->dev;
2397
2398    if (strcmp(dev->dev_name, "/dev/null") == 0) {
2399       return;                            /* no use trying to set /dev/null */
2400    }
2401
2402 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2403    struct mtop mt_com;
2404
2405    Dmsg0(050, "In set_os_device_parameters\n");
2406 #if defined(MTSETBLK)
2407    if (dev->min_block_size == dev->max_block_size &&
2408        dev->min_block_size == 0) {    /* variable block mode */
2409       mt_com.mt_op = MTSETBLK;
2410       mt_com.mt_count = 0;
2411       Dmsg0(050, "Set block size to zero\n");
2412       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2413          dev->clrerror(MTSETBLK);
2414       }
2415    }
2416 #endif
2417 #if defined(MTSETDRVBUFFER)
2418    if (getpid() == 0) {          /* Only root can do this */
2419       mt_com.mt_op = MTSETDRVBUFFER;
2420       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2421       if (!dev->has_cap(CAP_TWOEOF)) {
2422          mt_com.mt_count |= MT_ST_TWO_FM;
2423       }
2424       if (dev->has_cap(CAP_EOM)) {
2425          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2426       }
2427       Dmsg0(050, "MTSETDRVBUFFER\n");
2428       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2429          dev->clrerror(MTSETDRVBUFFER);
2430       }
2431    }
2432 #endif
2433    return;
2434 #endif
2435
2436 #ifdef HAVE_NETBSD_OS
2437    struct mtop mt_com;
2438    if (dev->min_block_size == dev->max_block_size &&
2439        dev->min_block_size == 0) {    /* variable block mode */
2440       mt_com.mt_op = MTSETBSIZ;
2441       mt_com.mt_count = 0;
2442       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2443          dev->clrerror(MTSETBSIZ);
2444       }
2445       /* Get notified at logical end of tape */
2446       mt_com.mt_op = MTEWARN;
2447       mt_com.mt_count = 1;
2448       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2449          dev->clrerror(MTEWARN);
2450       }
2451    }
2452    return;
2453 #endif
2454
2455 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2456    struct mtop mt_com;
2457    if (dev->min_block_size == dev->max_block_size &&
2458        dev->min_block_size == 0) {    /* variable block mode */
2459       mt_com.mt_op = MTSETBSIZ;
2460       mt_com.mt_count = 0;
2461       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2462          dev->clrerror(MTSETBSIZ);
2463       }
2464    }
2465 #if defined(MTIOCSETEOTMODEL)
2466    uint32_t neof;
2467    if (dev->has_cap(CAP_TWOEOF)) {
2468       neof = 2;
2469    } else {
2470       neof = 1;
2471    }
2472    if (ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2473       berrno be;
2474       dev->dev_errno = errno;         /* save errno */
2475       Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2476             dev->print_name(), be.bstrerror(dev->dev_errno));
2477       Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2478    }
2479 #endif
2480    return;
2481 #endif
2482
2483 #ifdef HAVE_SUN_OS
2484    struct mtop mt_com;
2485    if (dev->min_block_size == dev->max_block_size &&
2486        dev->min_block_size == 0) {    /* variable block mode */
2487       mt_com.mt_op = MTSRSZ;
2488       mt_com.mt_count = 0;
2489       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2490          dev->clrerror(MTSRSZ);
2491       }
2492    }
2493    return;
2494 #endif
2495 }
2496
2497 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2498 {
2499    Dmsg0(050, "dev_get_os_pos\n");
2500    return dev->has_cap(CAP_MTIOCGET) &&
2501           tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2502           mt_stat->mt_fileno >= 0;
2503 }
2504
2505 static char *modes[] = {
2506    "CREATE_READ_WRITE",
2507    "OPEN_READ_WRITE",
2508    "OPEN_READ_ONLY",
2509    "OPEN_WRITE_ONLY"
2510 };
2511
2512
2513 static char *mode_to_str(int mode)
2514 {
2515    static char buf[100];
2516    if (mode < 1 || mode > 4) {
2517       bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2518       return buf;
2519     }
2520    return modes[mode-1];
2521 }