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

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