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

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