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

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