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   berrno be;
1716    /* Read and clear SCSI error status */
1717    union mterrstat mt_errstat;
1718    Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1719       be.strerror(dev_errno));
1720    tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1721 }
1722 #endif
1723
1724 /* Clear Subsystem Exception OSF1 */
1725 #ifdef MTCSE
1726 {
1727    struct mtop mt_com;
1728    mt_com.mt_op = MTCSE;
1729    mt_com.mt_count = 1;
1730    /* Clear any error condition on the tape */
1731    tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1732    Dmsg0(200, "Did MTCSE\n");
1733 }
1734 #endif
1735 }
1736
1737 /*
1738  * Close the device
1739  */
1740 void DEVICE::close()
1741 {
1742    Dmsg1(100, "close_dev %s\n", print_name());
1743    if (has_cap(CAP_OFFLINEUNMOUNT)) {
1744       offline();
1745    }
1746    if (fd >= 0) {
1747       if (is_tape()) {
1748          tape_close(fd);
1749       } else {
1750          ::close(fd);
1751       }
1752    } else {
1753       Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1754          VolHdr.VolumeName);
1755       return;                         /* already closed */
1756    }
1757
1758    if (is_dvd() && !unmount_dvd(this, 1)) {
1759       Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1760    }
1761
1762    /* Remove the last part file if it is empty */
1763    if (num_parts > 0) {
1764       struct stat statp;
1765       POOL_MEM archive_name(PM_FNAME);
1766       part = num_parts;
1767       Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1768       make_spooled_dvd_filename(this, archive_name);
1769       /* Check that the part file is empty */
1770       if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1771          Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1772          unlink(archive_name.c_str());
1773       }
1774    }
1775
1776    /* Clean up device packet so it can be reused */
1777    clear_opened();
1778    state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1779    label_type = B_BACULA_LABEL;
1780    file = block_num = 0;
1781    file_size = 0;
1782    file_addr = 0;
1783    part = 0;
1784    num_parts = 0;
1785    part_size = 0;
1786    part_start = 0;
1787    EndFile = EndBlock = 0;
1788    free_volume(this);
1789    memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1790    memset(&VolHdr, 0, sizeof(VolHdr));
1791    if (tid) {
1792       stop_thread_timer(tid);
1793       tid = 0;
1794    }
1795    openmode = 0;
1796 }
1797
1798
1799
1800 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1801 {
1802    Dmsg1(100, "truncate_dev %s\n", print_name());
1803    if (is_tape()) {
1804       return true;                    /* we don't really truncate tapes */
1805       /* maybe we should rewind and write and eof ???? */
1806    }
1807
1808    if (is_dvd()) {
1809       return truncate_dvd(dcr);
1810    }
1811
1812    if (ftruncate(fd, 0) != 0) {
1813       berrno be;
1814       Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1815             print_name(), be.strerror());
1816       return false;
1817    }
1818    return true;
1819 }
1820
1821 /* Mount the device.
1822  * If timeout, wait until the mount command returns 0.
1823  * If !timeout, try to mount the device only once.
1824  */
1825 bool DEVICE::mount(int timeout)
1826 {
1827    Dmsg0(190, "Enter mount\n");
1828    if (is_mounted()) {
1829       return true;
1830    } else if (requires_mount()) {
1831       return do_mount(1, timeout);
1832    }
1833    return true;
1834 }
1835
1836 /* Unmount the device
1837  * If timeout, wait until the unmount command returns 0.
1838  * If !timeout, try to unmount the device only once.
1839  */
1840 bool DEVICE::unmount(int timeout)
1841 {
1842    Dmsg0(90, "Enter unmount_dvd\n");
1843    if (is_mounted()) {
1844       return do_mount(0, timeout);
1845    }
1846    return true;
1847 }
1848
1849 /* (Un)mount the device */
1850 bool DEVICE::do_mount(int mount, int dotimeout)
1851 {
1852    POOL_MEM ocmd(PM_FNAME);
1853    POOLMEM *results;
1854    char *icmd;
1855    int status, timeout;
1856
1857    sm_check(__FILE__, __LINE__, false);
1858    if (mount) {
1859       if (is_mounted()) {
1860          Dmsg0(200, "======= mount=1\n");
1861          return true;
1862       }
1863       icmd = device->mount_command;
1864    } else {
1865       if (!is_mounted()) {
1866          Dmsg0(200, "======= mount=0\n");
1867          return true;
1868       }
1869       icmd = device->unmount_command;
1870    }
1871
1872    edit_mount_codes(ocmd, icmd);
1873
1874    Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1875
1876    if (dotimeout) {
1877       /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1878       timeout = 1;
1879    } else {
1880       timeout = 0;
1881    }
1882    results = get_memory(2000);
1883    results[0] = 0;
1884    /* If busy retry each second */
1885    while ((status = run_program_full_output(ocmd.c_str(),
1886                        max_open_wait/2, results)) != 0) {
1887       /* Doesn't work with internationalisation (This is not a problem) */
1888       if (fnmatch("*is already mounted on", results, 0) == 0) {
1889          break;
1890       }
1891       if (timeout-- > 0) {
1892          /* Sometimes the device cannot be mounted because it is already mounted.
1893           * Try to unmount it, then remount it */
1894          if (mount) {
1895             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1896             do_mount(0, 0);
1897          }
1898          bmicrosleep(1, 0);
1899          continue;
1900       }
1901       Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1902       Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1903            print_name(), results);
1904       /*
1905        * Now, just to be sure it is not mounted, try to read the
1906        *  filesystem.
1907        */
1908       DIR* dp;
1909       struct dirent *entry, *result;
1910       int name_max;
1911       int count;
1912
1913       name_max = pathconf(".", _PC_NAME_MAX);
1914       if (name_max < 1024) {
1915          name_max = 1024;
1916       }
1917
1918       if (!(dp = opendir(device->mount_point))) {
1919          berrno be;
1920          dev_errno = errno;
1921          Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1922                device->mount_point, print_name(), be.strerror());
1923          goto get_out;
1924       }
1925
1926       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1927       count = 0;
1928       while (1) {
1929          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1930             dev_errno = EIO;
1931             Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1932                   device->mount_point, print_name());
1933             break;
1934          }
1935          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1936             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1937             break;
1938          } else {
1939             Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1940          }
1941       }
1942       free(entry);
1943       closedir(dp);
1944
1945       Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1946
1947       if (count > 0) {
1948          mount = 1;                      /* If we got more than ., .. and .keep */
1949          break;                          /*   there must be something mounted */
1950       }
1951 get_out:
1952       set_mounted(false);
1953       sm_check(__FILE__, __LINE__, false);
1954       free_pool_memory(results);
1955       Dmsg0(200, "============ mount=0\n");
1956       return false;
1957    }
1958
1959    set_mounted(mount);              /* set/clear mounted flag */
1960    free_pool_memory(results);
1961    Dmsg1(200, "============ mount=%d\n", mount);
1962    return true;
1963 }
1964
1965 /*
1966  * Edit codes into (Un)MountCommand, Write(First)PartCommand
1967  *  %% = %
1968  *  %a = archive device name
1969  *  %e = erase (set if cannot mount and first part)
1970  *  %n = part number
1971  *  %m = mount point
1972  *  %v = last part name
1973  *
1974  *  omsg = edited output message
1975  *  imsg = input string containing edit codes (%x)
1976  *
1977  */
1978 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1979 {
1980    const char *p;
1981    const char *str;
1982    char add[20];
1983
1984    POOL_MEM archive_name(PM_FNAME);
1985
1986    omsg.c_str()[0] = 0;
1987    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1988    for (p=imsg; *p; p++) {
1989       if (*p == '%') {
1990          switch (*++p) {
1991          case '%':
1992             str = "%";
1993             break;
1994          case 'a':
1995             str = dev_name;
1996             break;
1997          case 'e':
1998             if (num_parts == 0) {
1999                str = "1";
2000             } else {
2001                str = "0";
2002             }
2003             break;
2004          case 'n':
2005             bsnprintf(add, sizeof(add), "%d", part);
2006             str = add;
2007             break;
2008          case 'm':
2009             str = device->mount_point;
2010             break;
2011          case 'v':
2012             make_spooled_dvd_filename(this, archive_name);
2013             str = archive_name.c_str();
2014             break;
2015          default:
2016             add[0] = '%';
2017             add[1] = *p;
2018             add[2] = 0;
2019             str = add;
2020             break;
2021          }
2022       } else {
2023          add[0] = *p;
2024          add[1] = 0;
2025          str = add;
2026       }
2027       Dmsg1(1900, "add_str %s\n", str);
2028       pm_strcat(omsg, (char *)str);
2029       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2030    }
2031 }
2032
2033
2034 /* Return the resource name for the device */
2035 const char *DEVICE::name() const
2036 {
2037    return device->hdr.name;
2038 }
2039
2040 char *
2041 dev_vol_name(DEVICE *dev)
2042 {
2043    return dev->VolCatInfo.VolCatName;
2044 }
2045
2046 uint32_t dev_block(DEVICE *dev)
2047 {
2048    update_pos_dev(dev);
2049    return dev->block_num;
2050 }
2051
2052 uint32_t dev_file(DEVICE *dev)
2053 {
2054    update_pos_dev(dev);
2055    return dev->file;
2056 }
2057
2058 /*
2059  * Free memory allocated for the device
2060  */
2061 void DEVICE::term(void)
2062 {
2063    Dmsg1(900, "term dev: %s\n", print_name());
2064    close();
2065    if (dev_name) {
2066       free_memory(dev_name);
2067       dev_name = NULL;
2068    }
2069    if (prt_name) {
2070       free_memory(prt_name);
2071       prt_name = NULL;
2072    }
2073    if (errmsg) {
2074       free_pool_memory(errmsg);
2075       errmsg = NULL;
2076    }
2077    pthread_mutex_destroy(&mutex);
2078    pthread_cond_destroy(&wait);
2079    pthread_cond_destroy(&wait_next_vol);
2080    pthread_mutex_destroy(&spool_mutex);
2081    rwl_destroy(&lock);
2082    if (attached_dcrs) {
2083       delete attached_dcrs;
2084       attached_dcrs = NULL;
2085    }
2086    if (device) {
2087       device->dev = NULL;
2088    }
2089    free((char *)this);
2090 }
2091
2092 /*
2093  * This routine initializes the device wait timers
2094  */
2095 void init_device_wait_timers(DCR *dcr)
2096 {
2097    DEVICE *dev = dcr->dev;
2098    JCR *jcr = dcr->jcr;
2099
2100    /* ******FIXME******* put these on config variables */
2101    dev->min_wait = 60 * 60;
2102    dev->max_wait = 24 * 60 * 60;
2103    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2104    dev->wait_sec = dev->min_wait;
2105    dev->rem_wait_sec = dev->wait_sec;
2106    dev->num_wait = 0;
2107    dev->poll = false;
2108    dev->BadVolName[0] = 0;
2109
2110    jcr->min_wait = 60 * 60;
2111    jcr->max_wait = 24 * 60 * 60;
2112    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2113    jcr->wait_sec = jcr->min_wait;
2114    jcr->rem_wait_sec = jcr->wait_sec;
2115    jcr->num_wait = 0;
2116
2117 }
2118
2119 void init_jcr_device_wait_timers(JCR *jcr)
2120 {
2121    /* ******FIXME******* put these on config variables */
2122    jcr->min_wait = 60 * 60;
2123    jcr->max_wait = 24 * 60 * 60;
2124    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2125    jcr->wait_sec = jcr->min_wait;
2126    jcr->rem_wait_sec = jcr->wait_sec;
2127    jcr->num_wait = 0;
2128 }
2129
2130
2131 /*
2132  * The dev timers are used for waiting on a particular device
2133  *
2134  * Returns: true if time doubled
2135  *          false if max time expired
2136  */
2137 bool double_dev_wait_time(DEVICE *dev)
2138 {
2139    dev->wait_sec *= 2;               /* double wait time */
2140    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2141       dev->wait_sec = dev->max_wait;
2142    }
2143    dev->num_wait++;
2144    dev->rem_wait_sec = dev->wait_sec;
2145    if (dev->num_wait >= dev->max_num_wait) {
2146       return false;
2147    }
2148    return true;
2149 }
2150
2151
2152 void set_os_device_parameters(DEVICE *dev)
2153 {
2154 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2155    struct mtop mt_com;
2156    if (dev->min_block_size == dev->max_block_size &&
2157        dev->min_block_size == 0) {    /* variable block mode */
2158       mt_com.mt_op = MTSETBLK;
2159       mt_com.mt_count = 0;
2160       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2161          dev->clrerror(MTSETBLK);
2162       }
2163       mt_com.mt_op = MTSETDRVBUFFER;
2164       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2165       if (!dev->has_cap(CAP_TWOEOF)) {
2166          mt_com.mt_count |= MT_ST_TWO_FM;
2167       }
2168       if (dev->has_cap(CAP_EOM)) {
2169          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2170       }
2171       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2172          dev->clrerror(MTSETBLK);
2173       }
2174    }
2175    return;
2176 #endif
2177
2178 #ifdef HAVE_NETBSD_OS
2179    struct mtop mt_com;
2180    if (dev->min_block_size == dev->max_block_size &&
2181        dev->min_block_size == 0) {    /* variable block mode */
2182       mt_com.mt_op = MTSETBSIZ;
2183       mt_com.mt_count = 0;
2184       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2185          dev->clrerror(MTSETBSIZ);
2186       }
2187       /* Get notified at logical end of tape */
2188       mt_com.mt_op = MTEWARN;
2189       mt_com.mt_count = 1;
2190       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2191          dev->clrerror(MTEWARN);
2192       }
2193    }
2194    return;
2195 #endif
2196
2197 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2198    struct mtop mt_com;
2199    if (dev->min_block_size == dev->max_block_size &&
2200        dev->min_block_size == 0) {    /* variable block mode */
2201       mt_com.mt_op = MTSETBSIZ;
2202       mt_com.mt_count = 0;
2203       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2204          dev->clrerror(MTSETBSIZ);
2205       }
2206    }
2207    return;
2208 #endif
2209
2210 #ifdef HAVE_SUN_OS
2211    struct mtop mt_com;
2212    if (dev->min_block_size == dev->max_block_size &&
2213        dev->min_block_size == 0) {    /* variable block mode */
2214       mt_com.mt_op = MTSRSZ;
2215       mt_com.mt_count = 0;
2216       if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2217          dev->clrerror(MTSRSZ);
2218       }
2219    }
2220    return;
2221 #endif
2222 }
2223
2224 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2225 {
2226    return dev->has_cap(CAP_MTIOCGET) &&
2227           tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2228           mt_stat->mt_fileno >= 0;
2229 }
2230
2231 static char *modes[] = {
2232    "CREATE_READ_WRITE",
2233    "OPEN_READ_WRITE",
2234    "OPEN_READ_ONLY",
2235    "OPEN_WRITE_ONLY"
2236 };
2237
2238
2239 static char *mode_to_str(int mode)
2240 {
2241    return modes[mode-1];
2242 }