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

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