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

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