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