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