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    clear_eof();         /* remove EOF flag */
 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          set_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    }
1289    if (at_eot()) {
1290       Dmsg0(200, "ST_EOT set on exit FSF\n");
1291    }
1292    Dmsg1(200, "Return from FSF file=%d\n", file);
1293    return stat == 0;
1294 }
1295
1296 /*
1297  * Backward space a file
1298  *  Returns: false on failure
1299  *           true  on success
1300  */
1301 bool DEVICE::bsf(int num)
1302 {
1303    struct mtop mt_com;
1304    int stat;
1305
1306    if (fd < 0) {
1307       dev_errno = EBADF;
1308       Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1309       Emsg0(M_FATAL, 0, errmsg);
1310       return false;
1311    }
1312
1313    if (!is_tape()) {
1314       Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1315          print_name());
1316       return false;
1317    }
1318    Dmsg0(29, "bsf\n");
1319    clear_eot();
1320    clear_eof();
1321    file -= num;
1322    file_addr = 0;
1323    file_size = 0;
1324    mt_com.mt_op = MTBSF;
1325    mt_com.mt_count = num;
1326    stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1327    if (stat < 0) {
1328       berrno be;
1329       clrerror(MTBSF);
1330       Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1331          print_name(), be.strerror());
1332    }
1333    update_pos_dev(this);
1334    return stat == 0;
1335 }
1336
1337
1338 /*
1339  * Foward space num records
1340  *  Returns: false on failure
1341  *           true  on success
1342  */
1343 bool DEVICE::fsr(int num)
1344 {
1345    struct mtop mt_com;
1346    int stat;
1347
1348    if (fd < 0) {
1349       dev_errno = EBADF;
1350       Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1351       Emsg0(M_FATAL, 0, errmsg);
1352       return false;
1353    }
1354
1355    if (!is_tape()) {
1356       return false;
1357    }
1358    if (!has_cap(CAP_FSR)) {
1359       Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1360       return false;
1361    }
1362
1363    Dmsg1(29, "fsr %d\n", num);
1364    mt_com.mt_op = MTFSR;
1365    mt_com.mt_count = num;
1366    stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1367    if (stat == 0) {
1368       clear_eof();
1369       block_num += num;
1370    } else {
1371       berrno be;
1372       struct mtget mt_stat;
1373       clrerror(MTFSR);
1374       Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1375       if (dev_get_os_pos(this, &mt_stat)) {
1376          Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1377             block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1378          file = mt_stat.mt_fileno;
1379          block_num = mt_stat.mt_blkno;
1380       } else {
1381          if (at_eof()) {
1382             set_eot();
1383          } else {
1384             set_ateof();
1385          }
1386       }
1387       Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1388          num, print_name(), be.strerror());
1389    }
1390    update_pos_dev(this);
1391    return stat == 0;
1392 }
1393
1394 /*
1395  * Backward space a record
1396  *   Returns:  false on failure
1397  *             true  on success
1398  */
1399 bool DEVICE::bsr(int num)
1400 {
1401    struct mtop mt_com;
1402    int stat;
1403
1404    if (fd < 0) {
1405       dev_errno = EBADF;
1406       Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1407       Emsg0(M_FATAL, 0, errmsg);
1408       return false;
1409    }
1410
1411    if (!is_tape()) {
1412       return false;
1413    }
1414
1415    if (!has_cap(CAP_BSR)) {
1416       Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1417       return false;
1418    }
1419
1420    Dmsg0(29, "bsr_dev\n");
1421    block_num -= num;
1422    clear_eof();
1423    clear_eot();
1424    mt_com.mt_op = MTBSR;
1425    mt_com.mt_count = num;
1426    stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1427    if (stat < 0) {
1428       berrno be;
1429       clrerror(MTBSR);
1430       Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1431          print_name(), be.strerror());
1432    }
1433    update_pos_dev(this);
1434    return stat == 0;
1435 }
1436
1437 /*
1438  * Reposition the device to file, block
1439  * Returns: false on failure
1440  *          true  on success
1441  */
1442 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1443 {
1444    if (fd < 0) {
1445       dev_errno = EBADF;
1446       Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1447       Emsg0(M_FATAL, 0, errmsg);
1448       return false;
1449    }
1450
1451    if (!is_tape()) {
1452       off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1453       Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1454       if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1455          berrno be;
1456          dev_errno = errno;
1457          Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1458             print_name(), be.strerror());
1459          return false;
1460       }
1461       file = rfile;
1462       block_num = rblock;
1463       file_addr = pos;
1464       return true;
1465    }
1466    Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1467       file, block_num, rfile, rblock);
1468    if (rfile < file) {
1469       Dmsg0(100, "Rewind\n");
1470       if (!rewind(NULL)) {
1471          return false;
1472       }
1473    }
1474    if (rfile > file) {
1475       Dmsg1(100, "fsf %d\n", rfile-file);
1476       if (!fsf(rfile-file)) {
1477          Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1478          return false;
1479       }
1480       Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1481    }
1482    if (rblock < block_num) {
1483       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1484       Dmsg0(100, "bsf 1\n");
1485       bsf(1);
1486       Dmsg0(100, "fsf_dev 1\n");
1487       fsf(1);
1488       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1489    }
1490    if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1491       /* Ignore errors as Bacula can read to the correct block */
1492       Dmsg1(100, "fsr %d\n", rblock-block_num);
1493       return fsr(rblock-block_num);
1494    }
1495    return true;
1496 }
1497
1498
1499
1500 /*
1501  * Write an end of file on the device
1502  *   Returns: true on success
1503  *            false on failure
1504  */
1505 bool DEVICE::weof(int num)
1506 {
1507    struct mtop mt_com;
1508    int stat;
1509    Dmsg0(129, "weof_dev\n");
1510
1511    if (fd < 0) {
1512       dev_errno = EBADF;
1513       Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1514       Emsg0(M_FATAL, 0, errmsg);
1515       return false;
1516    }
1517    file_size = 0;
1518
1519    if (!is_tape()) {
1520       return true;
1521    }
1522    if (!can_append()) {
1523       Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1524       Emsg0(M_FATAL, 0, errmsg);
1525       return false;
1526    }
1527
1528    clear_eof();
1529    clear_eot();
1530    mt_com.mt_op = MTWEOF;
1531    mt_com.mt_count = num;
1532    stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1533    if (stat == 0) {
1534       block_num = 0;
1535       file += num;
1536       file_addr = 0;
1537    } else {
1538       berrno be;
1539       clrerror(MTWEOF);
1540       if (stat == -1) {
1541          Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1542             print_name(), be.strerror());
1543        }
1544    }
1545    return stat == 0;
1546 }
1547
1548
1549 /*
1550  * If implemented in system, clear the tape
1551  * error status.
1552  */
1553 void DEVICE::clrerror(int func)
1554 {
1555    const char *msg = NULL;
1556    struct mtget mt_stat;
1557    char buf[100];
1558
1559    dev_errno = errno;         /* save errno */
1560    if (errno == EIO) {
1561       VolCatInfo.VolCatErrors++;
1562    }
1563
1564    if (!is_tape()) {
1565       return;
1566    }
1567    if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1568       switch (func) {
1569       case -1:
1570          Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1571          break;
1572       case MTWEOF:
1573          msg = "WTWEOF";
1574          capabilities &= ~CAP_EOF; /* turn off feature */
1575          break;
1576 #ifdef MTEOM
1577       case MTEOM:
1578          msg = "WTEOM";
1579          capabilities &= ~CAP_EOM; /* turn off feature */
1580          break;
1581 #endif
1582       case MTFSF:
1583          msg = "MTFSF";
1584          capabilities &= ~CAP_FSF; /* turn off feature */
1585          break;
1586       case MTBSF:
1587          msg = "MTBSF";
1588          capabilities &= ~CAP_BSF; /* turn off feature */
1589          break;
1590       case MTFSR:
1591          msg = "MTFSR";
1592          capabilities &= ~CAP_FSR; /* turn off feature */
1593          break;
1594       case MTBSR:
1595          msg = "MTBSR";
1596          capabilities &= ~CAP_BSR; /* turn off feature */
1597          break;
1598       case MTREW:
1599          msg = "MTREW";
1600          break;
1601 #ifdef MTSETBLK
1602       case MTSETBLK:
1603          msg = "MTSETBLK";
1604          break;
1605 #endif
1606 #ifdef MTSETBSIZ
1607       case MTSETBSIZ:
1608          msg = "MTSETBSIZ";
1609          break;
1610 #endif
1611 #ifdef MTSRSZ
1612       case MTSRSZ:
1613          msg = "MTSRSZ";
1614          break;
1615 #endif
1616 #ifdef MTLOAD
1617       case MTLOAD:
1618          msg = "MTLOAD";
1619          break;
1620 #endif
1621 #ifdef MTUNLOCK
1622       case MTUNLOCK:
1623          msg = "MTUNLOCK";
1624          break;
1625 #endif
1626       case MTOFFL:
1627          msg = "MTOFFL";
1628          break;
1629       default:
1630          bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1631          msg = buf;
1632          break;
1633       }
1634       if (msg != NULL) {
1635          dev_errno = ENOSYS;
1636          Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1637          Emsg0(M_ERROR, 0, errmsg);
1638       }
1639    }
1640
1641    /*
1642     * Now we try different methods of clearing the error
1643     *  status on the drive so that it is not locked for
1644     *  further operations.
1645     */
1646
1647    /* On some systems such as NetBSD, this clears all errors */
1648    ioctl(fd, MTIOCGET, (char *)&mt_stat);
1649
1650 /* Found on Linux */
1651 #ifdef MTIOCLRERR
1652 {
1653    struct mtop mt_com;
1654    mt_com.mt_op = MTIOCLRERR;
1655    mt_com.mt_count = 1;
1656    /* Clear any error condition on the tape */
1657    ioctl(fd, MTIOCTOP, (char *)&mt_com);
1658    Dmsg0(200, "Did MTIOCLRERR\n");
1659 }
1660 #endif
1661
1662 /* Typically on FreeBSD */
1663 #ifdef MTIOCERRSTAT
1664 {
1665    /* Read and clear SCSI error status */
1666    union mterrstat mt_errstat;
1667    Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1668       strerror(dev_errno));
1669    ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1670 }
1671 #endif
1672
1673 /* Clear Subsystem Exception OSF1 */
1674 #ifdef MTCSE
1675 {
1676    struct mtop mt_com;
1677    mt_com.mt_op = MTCSE;
1678    mt_com.mt_count = 1;
1679    /* Clear any error condition on the tape */
1680    ioctl(fd, MTIOCTOP, (char *)&mt_com);
1681    Dmsg0(200, "Did MTCSE\n");
1682 }
1683 #endif
1684 }
1685
1686 /*
1687  * Close the device
1688  */
1689 void DEVICE::close()
1690 {
1691    Dmsg1(100, "close_dev %s\n", print_name());
1692    if (has_cap(CAP_OFFLINEUNMOUNT)) {
1693       offline();
1694    }
1695    if (fd >= 0) {
1696       ::close(fd);
1697    } else {
1698       Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1699          VolHdr.VolumeName);
1700       return;                         /* already closed */
1701    }
1702
1703    if (is_dvd() && !unmount_dvd(this, 1)) {
1704       Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1705    }
1706
1707    /* Remove the last part file if it is empty */
1708    if (num_parts > 0) {
1709       struct stat statp;
1710       POOL_MEM archive_name(PM_FNAME);
1711       part = num_parts;
1712       Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1713       make_spooled_dvd_filename(this, archive_name);
1714       /* Check that the part file is empty */
1715       if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1716          Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1717          unlink(archive_name.c_str());
1718       }
1719    }
1720
1721    /* Clean up device packet so it can be reused */
1722    clear_opened();
1723    state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1724    label_type = B_BACULA_LABEL;
1725    file = block_num = 0;
1726    file_size = 0;
1727    file_addr = 0;
1728    part = 0;
1729    num_parts = 0;
1730    part_size = 0;
1731    part_start = 0;
1732    EndFile = EndBlock = 0;
1733    free_volume(this);
1734    memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1735    memset(&VolHdr, 0, sizeof(VolHdr));
1736    if (tid) {
1737       stop_thread_timer(tid);
1738       tid = 0;
1739    }
1740    openmode = 0;
1741 }
1742
1743
1744
1745 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1746 {
1747    Dmsg1(100, "truncate_dev %s\n", print_name());
1748    if (is_tape()) {
1749       return true;                    /* we don't really truncate tapes */
1750       /* maybe we should rewind and write and eof ???? */
1751    }
1752
1753    if (is_dvd()) {
1754       return truncate_dvd(dcr);
1755    }
1756
1757    if (ftruncate(fd, 0) != 0) {
1758       berrno be;
1759       Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1760             print_name(), be.strerror());
1761       return false;
1762    }
1763    return true;
1764 }
1765
1766 /* Mount the device.
1767  * If timeout, wait until the mount command returns 0.
1768  * If !timeout, try to mount the device only once.
1769  */
1770 bool DEVICE::mount(int timeout)
1771 {
1772    Dmsg0(190, "Enter mount\n");
1773    if (is_mounted()) {
1774       return true;
1775    } else if (requires_mount()) {
1776       return do_mount(1, timeout);
1777    }
1778    return true;
1779 }
1780
1781 /* Unmount the device
1782  * If timeout, wait until the unmount command returns 0.
1783  * If !timeout, try to unmount the device only once.
1784  */
1785 bool DEVICE::unmount(int timeout)
1786 {
1787    Dmsg0(90, "Enter unmount_dvd\n");
1788    if (is_mounted()) {
1789       return do_mount(0, timeout);
1790    }
1791    return true;
1792 }
1793
1794 /* (Un)mount the device */
1795 bool DEVICE::do_mount(int mount, int dotimeout)
1796 {
1797    POOL_MEM ocmd(PM_FNAME);
1798    POOLMEM *results;
1799    char *icmd;
1800    int status, timeout;
1801
1802    sm_check(__FILE__, __LINE__, false);
1803    if (mount) {
1804       if (is_mounted()) {
1805          Dmsg0(200, "======= mount=1\n");
1806          return true;
1807       }
1808       icmd = device->mount_command;
1809    } else {
1810       if (!is_mounted()) {
1811          Dmsg0(200, "======= mount=0\n");
1812          return true;
1813       }
1814       icmd = device->unmount_command;
1815    }
1816
1817    edit_mount_codes(ocmd, icmd);
1818
1819    Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1820
1821    if (dotimeout) {
1822       /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1823       timeout = 1;
1824    } else {
1825       timeout = 0;
1826    }
1827    results = get_memory(2000);
1828    results[0] = 0;
1829    /* If busy retry each second */
1830    while ((status = run_program_full_output(ocmd.c_str(),
1831                        max_open_wait/2, results)) != 0) {
1832       /* Doesn't work with internationalisation (This is not a problem) */
1833       if (fnmatch("*is already mounted on", results, 0) == 0) {
1834          break;
1835       }
1836       if (timeout-- > 0) {
1837          /* Sometimes the device cannot be mounted because it is already mounted.
1838           * Try to unmount it, then remount it */
1839          if (mount) {
1840             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1841             do_mount(0, 0);
1842          }
1843          bmicrosleep(1, 0);
1844          continue;
1845       }
1846       Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1847       Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1848            print_name(), results);
1849       /*
1850        * Now, just to be sure it is not mounted, try to read the
1851        *  filesystem.
1852        */
1853       DIR* dp;
1854       struct dirent *entry, *result;
1855       int name_max;
1856       int count;
1857
1858       name_max = pathconf(".", _PC_NAME_MAX);
1859       if (name_max < 1024) {
1860          name_max = 1024;
1861       }
1862
1863       if (!(dp = opendir(device->mount_point))) {
1864          berrno be;
1865          dev_errno = errno;
1866          Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1867                device->mount_point, print_name(), be.strerror());
1868          goto get_out;
1869       }
1870
1871       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1872       count = 0;
1873       while (1) {
1874          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1875             dev_errno = EIO;
1876             Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1877                   device->mount_point, print_name());
1878             break;
1879          }
1880          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1881             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1882             break;
1883          } else {
1884             Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1885          }
1886       }
1887       free(entry);
1888       closedir(dp);
1889
1890       Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1891
1892       if (count > 0) {
1893          mount = 1;                      /* If we got more than ., .. and .keep */
1894          break;                          /*   there must be something mounted */
1895       }
1896 get_out:
1897       set_mounted(false);
1898       sm_check(__FILE__, __LINE__, false);
1899       free_pool_memory(results);
1900       Dmsg0(200, "============ mount=0\n");
1901       return false;
1902    }
1903
1904    set_mounted(mount);              /* set/clear mounted flag */
1905    free_pool_memory(results);
1906    Dmsg1(200, "============ mount=%d\n", mount);
1907    return true;
1908 }
1909
1910 /*
1911  * Edit codes into (Un)MountCommand, Write(First)PartCommand
1912  *  %% = %
1913  *  %a = archive device name
1914  *  %e = erase (set if cannot mount and first part)
1915  *  %n = part number
1916  *  %m = mount point
1917  *  %v = last part name
1918  *
1919  *  omsg = edited output message
1920  *  imsg = input string containing edit codes (%x)
1921  *
1922  */
1923 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1924 {
1925    const char *p;
1926    const char *str;
1927    char add[20];
1928
1929    POOL_MEM archive_name(PM_FNAME);
1930
1931    omsg.c_str()[0] = 0;
1932    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1933    for (p=imsg; *p; p++) {
1934       if (*p == '%') {
1935          switch (*++p) {
1936          case '%':
1937             str = "%";
1938             break;
1939          case 'a':
1940             str = dev_name;
1941             break;
1942          case 'e':
1943             if (num_parts == 0) {
1944                str = "1";
1945             } else {
1946                str = "0";
1947             }
1948             break;
1949          case 'n':
1950             bsnprintf(add, sizeof(add), "%d", part);
1951             str = add;
1952             break;
1953          case 'm':
1954             str = device->mount_point;
1955             break;
1956          case 'v':
1957             make_spooled_dvd_filename(this, archive_name);
1958             str = archive_name.c_str();
1959             break;
1960          default:
1961             add[0] = '%';
1962             add[1] = *p;
1963             add[2] = 0;
1964             str = add;
1965             break;
1966          }
1967       } else {
1968          add[0] = *p;
1969          add[1] = 0;
1970          str = add;
1971       }
1972       Dmsg1(1900, "add_str %s\n", str);
1973       pm_strcat(omsg, (char *)str);
1974       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
1975    }
1976 }
1977
1978
1979 /* Return the resource name for the device */
1980 const char *DEVICE::name() const
1981 {
1982    return device->hdr.name;
1983 }
1984
1985 char *
1986 dev_vol_name(DEVICE *dev)
1987 {
1988    return dev->VolCatInfo.VolCatName;
1989 }
1990
1991 uint32_t dev_block(DEVICE *dev)
1992 {
1993    update_pos_dev(dev);
1994    return dev->block_num;
1995 }
1996
1997 uint32_t dev_file(DEVICE *dev)
1998 {
1999    update_pos_dev(dev);
2000    return dev->file;
2001 }
2002
2003 /*
2004  * Free memory allocated for the device
2005  */
2006 void DEVICE::term(void)
2007 {
2008    Dmsg1(900, "term dev: %s\n", print_name());
2009    close();
2010    if (dev_name) {
2011       free_memory(dev_name);
2012       dev_name = NULL;
2013    }
2014    if (prt_name) {
2015       free_memory(prt_name);
2016       prt_name = NULL;
2017    }
2018    if (errmsg) {
2019       free_pool_memory(errmsg);
2020       errmsg = NULL;
2021    }
2022    pthread_mutex_destroy(&mutex);
2023    pthread_cond_destroy(&wait);
2024    pthread_cond_destroy(&wait_next_vol);
2025    pthread_mutex_destroy(&spool_mutex);
2026    rwl_destroy(&lock);
2027    if (attached_dcrs) {
2028       delete attached_dcrs;
2029       attached_dcrs = NULL;
2030    }
2031    if (device) {
2032       device->dev = NULL;
2033    }
2034    free((char *)this);
2035 }
2036
2037 /*
2038  * This routine initializes the device wait timers
2039  */
2040 void init_device_wait_timers(DCR *dcr)
2041 {
2042    DEVICE *dev = dcr->dev;
2043    JCR *jcr = dcr->jcr;
2044
2045    /* ******FIXME******* put these on config variables */
2046    dev->min_wait = 60 * 60;
2047    dev->max_wait = 24 * 60 * 60;
2048    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2049    dev->wait_sec = dev->min_wait;
2050    dev->rem_wait_sec = dev->wait_sec;
2051    dev->num_wait = 0;
2052    dev->poll = false;
2053    dev->BadVolName[0] = 0;
2054
2055    jcr->min_wait = 60 * 60;
2056    jcr->max_wait = 24 * 60 * 60;
2057    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2058    jcr->wait_sec = jcr->min_wait;
2059    jcr->rem_wait_sec = jcr->wait_sec;
2060    jcr->num_wait = 0;
2061
2062 }
2063
2064 void init_jcr_device_wait_timers(JCR *jcr)
2065 {
2066    /* ******FIXME******* put these on config variables */
2067    jcr->min_wait = 60 * 60;
2068    jcr->max_wait = 24 * 60 * 60;
2069    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2070    jcr->wait_sec = jcr->min_wait;
2071    jcr->rem_wait_sec = jcr->wait_sec;
2072    jcr->num_wait = 0;
2073 }
2074
2075
2076 /*
2077  * The dev timers are used for waiting on a particular device
2078  *
2079  * Returns: true if time doubled
2080  *          false if max time expired
2081  */
2082 bool double_dev_wait_time(DEVICE *dev)
2083 {
2084    dev->wait_sec *= 2;               /* double wait time */
2085    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2086       dev->wait_sec = dev->max_wait;
2087    }
2088    dev->num_wait++;
2089    dev->rem_wait_sec = dev->wait_sec;
2090    if (dev->num_wait >= dev->max_num_wait) {
2091       return false;
2092    }
2093    return true;
2094 }
2095
2096
2097 void set_os_device_parameters(DEVICE *dev)
2098 {
2099 #ifdef HAVE_LINUX_OS
2100    struct mtop mt_com;
2101    if (dev->min_block_size == dev->max_block_size &&
2102        dev->min_block_size == 0) {    /* variable block mode */
2103       mt_com.mt_op = MTSETBLK;
2104       mt_com.mt_count = 0;
2105       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2106          dev->clrerror(MTSETBLK);
2107       }
2108       mt_com.mt_op = MTSETDRVBUFFER;
2109       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2110       if (!dev->has_cap(CAP_TWOEOF)) {
2111          mt_com.mt_count |= MT_ST_TWO_FM;
2112       }
2113       if (dev->has_cap(CAP_EOM)) {
2114          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2115       }
2116       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2117          dev->clrerror(MTSETBLK);
2118       }
2119    }
2120    return;
2121 #endif
2122
2123 #ifdef HAVE_NETBSD_OS
2124    struct mtop mt_com;
2125    if (dev->min_block_size == dev->max_block_size &&
2126        dev->min_block_size == 0) {    /* variable block mode */
2127       mt_com.mt_op = MTSETBSIZ;
2128       mt_com.mt_count = 0;
2129       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2130          dev->clrerror(MTSETBSIZ);
2131       }
2132       /* Get notified at logical end of tape */
2133       mt_com.mt_op = MTEWARN;
2134       mt_com.mt_count = 1;
2135       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2136          dev->clrerror(MTEWARN);
2137       }
2138    }
2139    return;
2140 #endif
2141
2142 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2143    struct mtop mt_com;
2144    if (dev->min_block_size == dev->max_block_size &&
2145        dev->min_block_size == 0) {    /* variable block mode */
2146       mt_com.mt_op = MTSETBSIZ;
2147       mt_com.mt_count = 0;
2148       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2149          dev->clrerror(MTSETBSIZ);
2150       }
2151    }
2152    return;
2153 #endif
2154
2155 #ifdef HAVE_SUN_OS
2156    struct mtop mt_com;
2157    if (dev->min_block_size == dev->max_block_size &&
2158        dev->min_block_size == 0) {    /* variable block mode */
2159       mt_com.mt_op = MTSRSZ;
2160       mt_com.mt_count = 0;
2161       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2162          dev->clrerror(MTSRSZ);
2163       }
2164    }
2165    return;
2166 #endif
2167 }
2168
2169 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2170 {
2171    return dev->has_cap(CAP_MTIOCGET) &&
2172           ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2173           mt_stat->mt_fileno >= 0;
2174 }
2175
2176 static char *modes[] = {
2177    "CREATE_READ_WRITE",
2178    "OPEN_READ_WRITE",
2179    "OPEN_READ_ONLY",
2180    "OPEN_WRITE_ONLY"
2181 };
2182
2183
2184 static char *mode_to_str(int mode)
2185 {
2186    return modes[mode-1];
2187 }