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