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 (S_ISCHR(statp.st_mode)) {
 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(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 = ::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() && (ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
 395             berrno be;
 396             dev_errno = errno;           /* set error status from rewind */
 397             ::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             ::close(m_fd);
 408             m_fd = ::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_TAPE_DEV:
1849       unlock_door();
1850       tape_close(m_fd);
1851       break;
1852    default:
1853       ::close(m_fd);
1854    }
1855
1856    /* Clean up device packet so it can be reused */
1857    clear_opened();
1858    /*
1859     * Be careful not to clear items needed by the DVD driver
1860     *    when it is closing a single part.
1861     */
1862    state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1863               ST_MOUNTED|ST_MEDIA|ST_SHORT);
1864    label_type = B_BACULA_LABEL;
1865    file = block_num = 0;
1866    file_size = 0;
1867    file_addr = 0;
1868    EndFile = EndBlock = 0;
1869    openmode = 0;
1870    Slot = -1;             /* unknown slot */
1871    clear_volhdr();
1872    memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1873    if (tid) {
1874       stop_thread_timer(tid);
1875       tid = 0;
1876    }
1877 }
1878
1879 /*
1880  * This call closes the device, but it is used in DVD handling
1881  *  where we close one part and then open the next part. The
1882  *  difference between close_part() and close() is that close_part()
1883  *  saves the state information of the device (e.g. the Volume lable,
1884  *  the Volume Catalog record, ...  This permits opening and closing
1885  *  the Volume parts multiple times without losing track of what the
1886  *  main Volume parameters are.
1887  */
1888 void DEVICE::close_part(DCR * /*dcr*/)
1889 {
1890    VOLUME_LABEL saveVolHdr;
1891    VOLUME_CAT_INFO saveVolCatInfo;     /* Volume Catalog Information */
1892
1893
1894    saveVolHdr = VolHdr;               /* structure assignment */
1895    saveVolCatInfo = VolCatInfo;       /* structure assignment */
1896    close();                           /* close current part */
1897    VolHdr = saveVolHdr;               /* structure assignment */
1898    VolCatInfo = saveVolCatInfo;       /* structure assignment */
1899 }
1900
1901 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1902 {
1903    switch (dev_type) {
1904    case B_DVD_DEV:
1905       return lseek_dvd(dcr, offset, whence);
1906    case B_FILE_DEV:
1907 #if defined(HAVE_WIN32)
1908       return ::_lseeki64(m_fd, (__int64)offset, whence);
1909 #else
1910       return ::lseek(m_fd, (off_t)offset, whence);
1911 #endif
1912    }
1913    return -1;
1914 }
1915
1916
1917 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1918 {
1919    struct stat st;
1920
1921    Dmsg1(100, "truncate %s\n", print_name());
1922    switch (dev_type) {
1923    case B_VTL_DEV:
1924    case B_TAPE_DEV:
1925       /* maybe we should rewind and write and eof ???? */
1926       return true;                    /* we don't really truncate tapes */
1927    case B_DVD_DEV:
1928       return truncate_dvd(dcr);
1929    case B_FILE_DEV:
1930       if (ftruncate(m_fd, 0) != 0) {
1931          berrno be;
1932          Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1933                print_name(), be.bstrerror());
1934          return false;
1935       }
1936
1937       /*
1938        * Check for a successful ftruncate() and issue a work-around for devices
1939        * (mostly cheap NAS) that don't support truncation.
1940        * Workaround supplied by Martin Schmid as a solution to bug #1011.
1941        * 1. close file
1942        * 2. delete file
1943        * 3. open new file with same mode
1944        * 4. change ownership to original
1945        */
1946
1947       if (fstat(m_fd, &st) != 0) {
1948          berrno be;
1949          Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
1950                print_name(), be.bstrerror());
1951          return false;
1952       }
1953
1954       if (st.st_size != 0) {             /* ftruncate() didn't work */
1955          POOL_MEM archive_name(PM_FNAME);
1956
1957          pm_strcpy(archive_name, dev_name);
1958          if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
1959             pm_strcat(archive_name, "/");
1960          }
1961          pm_strcat(archive_name, dcr->VolumeName);
1962
1963          Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
1964                print_name(), archive_name.c_str());
1965
1966          /* Close file and blow it away */
1967          ::close(m_fd);
1968          ::unlink(archive_name.c_str());
1969
1970          /* Recreate the file -- of course, empty */
1971          set_mode(CREATE_READ_WRITE);
1972          if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
1973             berrno be;
1974             dev_errno = errno;
1975             Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
1976                   be.bstrerror());
1977             Dmsg1(100, "reopen failed: %s", errmsg);
1978             Emsg0(M_FATAL, 0, errmsg);
1979             return false;
1980          }
1981
1982          /* Reset proper owner */
1983          chown(archive_name.c_str(), st.st_uid, st.st_gid);
1984       }
1985
1986       return true;
1987    }
1988    return false;
1989 }
1990
1991 /* Mount the device.
1992  * If timeout, wait until the mount command returns 0.
1993  * If !timeout, try to mount the device only once.
1994  */
1995 bool DEVICE::mount(int timeout)
1996 {
1997    Dmsg0(190, "Enter mount\n");
1998    if (is_mounted()) {
1999       return true;
2000    } else if (requires_mount()) {
2001       return do_mount(1, timeout);
2002    }
2003    return true;
2004 }
2005
2006 /* Unmount the device
2007  * If timeout, wait until the unmount command returns 0.
2008  * If !timeout, try to unmount the device only once.
2009  */
2010 bool DEVICE::unmount(int timeout)
2011 {
2012    Dmsg0(100, "Enter unmount\n");
2013    if (is_mounted()) {
2014       return do_mount(0, timeout);
2015    }
2016    return true;
2017 }
2018
2019 /* (Un)mount the device */
2020 bool DEVICE::do_mount(int mount, int dotimeout)
2021 {
2022    POOL_MEM ocmd(PM_FNAME);
2023    POOLMEM *results;
2024    char *icmd;
2025    int status, timeout;
2026
2027    Dsm_check(1);
2028    if (mount) {
2029       if (is_mounted()) {
2030          Dmsg0(200, "======= mount=1\n");
2031          return true;
2032       }
2033       icmd = device->mount_command;
2034    } else {
2035       if (!is_mounted()) {
2036          Dmsg0(200, "======= mount=0\n");
2037          return true;
2038       }
2039       icmd = device->unmount_command;
2040    }
2041
2042    clear_freespace_ok();
2043    edit_mount_codes(ocmd, icmd);
2044
2045    Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2046
2047    if (dotimeout) {
2048       /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
2049       timeout = 1;
2050    } else {
2051       timeout = 0;
2052    }
2053    results = get_memory(4000);
2054
2055    /* If busy retry each second */
2056    Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
2057    while ((status = run_program_full_output(ocmd.c_str(),
2058                        max_open_wait/2, results)) != 0) {
2059       /* Doesn't work with internationalization (This is not a problem) */
2060       if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2061          break;
2062       }
2063       if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2064          break;
2065       }
2066       if (timeout-- > 0) {
2067          /* Sometimes the device cannot be mounted because it is already mounted.
2068           * Try to unmount it, then remount it */
2069          if (mount) {
2070             Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2071             do_mount(0, 0);
2072          }
2073          bmicrosleep(1, 0);
2074          continue;
2075       }
2076       if (status != 0) {
2077          berrno be;
2078          Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2079               (mount ? "" : "un"), status, results, be.bstrerror(status));
2080          Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2081               print_name(), (mount ? "" : "un"), be.bstrerror(status));
2082       } else {
2083          Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2084               (mount ? "" : "un"), status, results);
2085          Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2086               print_name(), (mount ? "" : "un"), results);
2087       }
2088       /*
2089        * Now, just to be sure it is not mounted, try to read the
2090        *  filesystem.
2091        */
2092       DIR* dp;
2093       struct dirent *entry, *result;
2094       int name_max;
2095       int count;
2096
2097       name_max = pathconf(".", _PC_NAME_MAX);
2098       if (name_max < 1024) {
2099          name_max = 1024;
2100       }
2101
2102       if (!(dp = opendir(device->mount_point))) {
2103          berrno be;
2104          dev_errno = errno;
2105          Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2106                device->mount_point, print_name(), be.bstrerror());
2107          goto get_out;
2108       }
2109
2110       entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2111       count = 0;
2112       while (1) {
2113          if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2114             dev_errno = EIO;
2115             Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2116                   device->mount_point, print_name());
2117             break;
2118          }
2119          if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2120             count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2121             break;
2122          } else {
2123             Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2124          }
2125       }
2126       free(entry);
2127       closedir(dp);
2128
2129       Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2130
2131       if (count > 0) {
2132          /* If we got more than ., .. and .keep */
2133          /*   there must be something mounted */
2134          if (mount) {
2135             Dmsg1(100, "Did Mount by count=%d\n", count);
2136             break;
2137          } else {
2138             /* An unmount request. We failed to unmount - report an error */
2139             set_mounted(true);
2140             free_pool_memory(results);
2141             Dmsg0(200, "== error mount=1 wanted unmount\n");
2142             return false;
2143          }
2144       }
2145 get_out:
2146       set_mounted(false);
2147       free_pool_memory(results);
2148       Dmsg0(200, "============ mount=0\n");
2149       Dsm_check(1);
2150       return false;
2151    }
2152
2153    set_mounted(mount);              /* set/clear mounted flag */
2154    free_pool_memory(results);
2155    /* Do not check free space when unmounting */
2156    if (mount && !update_freespace()) {
2157       return false;
2158    }
2159    Dmsg1(200, "============ mount=%d\n", mount);
2160    return true;
2161 }
2162
2163 /*
2164  * Edit codes into (Un)MountCommand, Write(First)PartCommand
2165  *  %% = %
2166  *  %a = archive device name
2167  *  %e = erase (set if cannot mount and first part)
2168  *  %n = part number
2169  *  %m = mount point
2170  *  %v = last part name
2171  *
2172  *  omsg = edited output message
2173  *  imsg = input string containing edit codes (%x)
2174  *
2175  */
2176 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2177 {
2178    const char *p;
2179    const char *str;
2180    char add[20];
2181
2182    POOL_MEM archive_name(PM_FNAME);
2183
2184    omsg.c_str()[0] = 0;
2185    Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2186    for (p=imsg; *p; p++) {
2187       if (*p == '%') {
2188          switch (*++p) {
2189          case '%':
2190             str = "%";
2191             break;
2192          case 'a':
2193             str = dev_name;
2194             break;
2195          case 'e':
2196             if (num_dvd_parts == 0) {
2197                if (truncating || blank_dvd) {
2198                   str = "2";
2199                } else {
2200                   str = "1";
2201                }
2202             } else {
2203                str = "0";
2204             }
2205             break;
2206          case 'n':
2207             bsnprintf(add, sizeof(add), "%d", part);
2208             str = add;
2209             break;
2210          case 'm':
2211             str = device->mount_point;
2212             break;
2213          case 'v':
2214             make_spooled_dvd_filename(this, archive_name);
2215             str = archive_name.c_str();
2216             break;
2217          default:
2218             add[0] = '%';
2219             add[1] = *p;
2220             add[2] = 0;
2221             str = add;
2222             break;
2223          }
2224       } else {
2225          add[0] = *p;
2226          add[1] = 0;
2227          str = add;
2228       }
2229       Dmsg1(1900, "add_str %s\n", str);
2230       pm_strcat(omsg, (char *)str);
2231       Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2232    }
2233 }
2234
2235 /* return the last timer interval (ms)
2236  * or 0 if something goes wrong
2237  */
2238 btime_t DEVICE::get_timer_count()
2239 {
2240    btime_t temp = last_timer;
2241    last_timer = get_current_btime();
2242    temp = last_timer - temp;   /* get elapsed time */
2243    return (temp>0)?temp:0;     /* take care of skewed clock */
2244 }
2245
2246 /* read from fd */
2247 ssize_t DEVICE::read(void *buf, size_t len)
2248 {
2249    ssize_t read_len ;
2250
2251    get_timer_count();
2252
2253    if (this->is_tape()) {
2254       read_len = tape_read(m_fd, buf, len);
2255    } else {
2256       read_len = ::read(m_fd, buf, len);
2257    }
2258
2259    last_tick = get_timer_count();
2260
2261    DevReadTime += last_tick;
2262    VolCatInfo.VolReadTime += last_tick;
2263
2264    if (read_len > 0) {          /* skip error */
2265       DevReadBytes += read_len;
2266    }
2267
2268    return read_len;
2269 }
2270
2271 /* write to fd */
2272 ssize_t DEVICE::write(const void *buf, size_t len)
2273 {
2274    ssize_t write_len ;
2275
2276    get_timer_count();
2277
2278    if (this->is_tape()) {
2279       write_len = tape_write(m_fd, buf, len);
2280    } else {
2281       write_len = ::write(m_fd, buf, len);
2282    }
2283
2284    last_tick = get_timer_count();
2285
2286    DevWriteTime += last_tick;
2287    VolCatInfo.VolWriteTime += last_tick;
2288
2289    if (write_len > 0) {         /* skip error */
2290       DevWriteBytes += write_len;
2291    }
2292
2293    return write_len;
2294 }
2295
2296 /* Return the resource name for the device */
2297 const char *DEVICE::name() const
2298 {
2299    return device->hdr.name;
2300 }
2301
2302 /* Returns file position on tape or -1 */
2303 int32_t DEVICE::get_os_tape_file()
2304 {
2305    struct mtget mt_stat;
2306
2307    if (has_cap(CAP_MTIOCGET) &&
2308        tape_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2309       return mt_stat.mt_fileno;
2310    }
2311    return -1;
2312 }
2313
2314 char *
2315 dev_vol_name(DEVICE *dev)
2316 {
2317    return dev->VolCatInfo.VolCatName;
2318 }
2319
2320
2321 /*
2322  * Free memory allocated for the device
2323  */
2324 void DEVICE::term(void)
2325 {
2326    Dmsg1(900, "term dev: %s\n", print_name());
2327    close();
2328    if (dev_name) {
2329       free_memory(dev_name);
2330       dev_name = NULL;
2331    }
2332    if (prt_name) {
2333       free_memory(prt_name);
2334       prt_name = NULL;
2335    }
2336    if (errmsg) {
2337       free_pool_memory(errmsg);
2338       errmsg = NULL;
2339    }
2340    pthread_mutex_destroy(&m_mutex);
2341    pthread_cond_destroy(&wait);
2342    pthread_cond_destroy(&wait_next_vol);
2343    pthread_mutex_destroy(&spool_mutex);
2344 // rwl_destroy(&lock);
2345    if (attached_dcrs) {
2346       delete attached_dcrs;
2347       attached_dcrs = NULL;
2348    }
2349    if (device) {
2350       device->dev = NULL;
2351    }
2352    free((char *)this);
2353 }
2354
2355 /*
2356  * This routine initializes the device wait timers
2357  */
2358 void init_device_wait_timers(DCR *dcr)
2359 {
2360    DEVICE *dev = dcr->dev;
2361    JCR *jcr = dcr->jcr;
2362
2363    /* ******FIXME******* put these on config variables */
2364    dev->min_wait = 60 * 60;
2365    dev->max_wait = 24 * 60 * 60;
2366    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2367    dev->wait_sec = dev->min_wait;
2368    dev->rem_wait_sec = dev->wait_sec;
2369    dev->num_wait = 0;
2370    dev->poll = false;
2371    dev->BadVolName[0] = 0;
2372
2373    jcr->min_wait = 60 * 60;
2374    jcr->max_wait = 24 * 60 * 60;
2375    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2376    jcr->wait_sec = jcr->min_wait;
2377    jcr->rem_wait_sec = jcr->wait_sec;
2378    jcr->num_wait = 0;
2379
2380 }
2381
2382 void init_jcr_device_wait_timers(JCR *jcr)
2383 {
2384    /* ******FIXME******* put these on config variables */
2385    jcr->min_wait = 60 * 60;
2386    jcr->max_wait = 24 * 60 * 60;
2387    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
2388    jcr->wait_sec = jcr->min_wait;
2389    jcr->rem_wait_sec = jcr->wait_sec;
2390    jcr->num_wait = 0;
2391 }
2392
2393
2394 /*
2395  * The dev timers are used for waiting on a particular device
2396  *
2397  * Returns: true if time doubled
2398  *          false if max time expired
2399  */
2400 bool double_dev_wait_time(DEVICE *dev)
2401 {
2402    dev->wait_sec *= 2;               /* double wait time */
2403    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
2404       dev->wait_sec = dev->max_wait;
2405    }
2406    dev->num_wait++;
2407    dev->rem_wait_sec = dev->wait_sec;
2408    if (dev->num_wait >= dev->max_num_wait) {
2409       return false;
2410    }
2411    return true;
2412 }
2413
2414
2415 void set_os_device_parameters(DCR *dcr)
2416 {
2417    DEVICE *dev = dcr->dev;
2418
2419    if (strcmp(dev->dev_name, "/dev/null") == 0) {
2420       return;                            /* no use trying to set /dev/null */
2421    }
2422
2423 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2424    struct mtop mt_com;
2425
2426    Dmsg0(100, "In set_os_device_parameters\n");
2427 #if defined(MTSETBLK)
2428    if (dev->min_block_size == dev->max_block_size &&
2429        dev->min_block_size == 0) {    /* variable block mode */
2430       mt_com.mt_op = MTSETBLK;
2431       mt_com.mt_count = 0;
2432       Dmsg0(100, "Set block size to zero\n");
2433       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2434          dev->clrerror(MTSETBLK);
2435       }
2436    }
2437 #endif
2438 #if defined(MTSETDRVBUFFER)
2439    if (getuid() == 0) {          /* Only root can do this */
2440       mt_com.mt_op = MTSETDRVBUFFER;
2441       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2442       if (!dev->has_cap(CAP_TWOEOF)) {
2443          mt_com.mt_count |= MT_ST_TWO_FM;
2444       }
2445       if (dev->has_cap(CAP_EOM)) {
2446          mt_com.mt_count |= MT_ST_FAST_MTEOM;
2447       }
2448       Dmsg0(100, "MTSETDRVBUFFER\n");
2449       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2450          dev->clrerror(MTSETDRVBUFFER);
2451       }
2452    }
2453 #endif
2454    return;
2455 #endif
2456
2457 #ifdef HAVE_NETBSD_OS
2458    struct mtop mt_com;
2459    if (dev->min_block_size == dev->max_block_size &&
2460        dev->min_block_size == 0) {    /* variable block mode */
2461       mt_com.mt_op = MTSETBSIZ;
2462       mt_com.mt_count = 0;
2463       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2464          dev->clrerror(MTSETBSIZ);
2465       }
2466       /* Get notified at logical end of tape */
2467       mt_com.mt_op = MTEWARN;
2468       mt_com.mt_count = 1;
2469       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2470          dev->clrerror(MTEWARN);
2471       }
2472    }
2473    return;
2474 #endif
2475
2476 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2477    struct mtop mt_com;
2478    if (dev->min_block_size == dev->max_block_size &&
2479        dev->min_block_size == 0) {    /* variable block mode */
2480       mt_com.mt_op = MTSETBSIZ;
2481       mt_com.mt_count = 0;
2482       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2483          dev->clrerror(MTSETBSIZ);
2484       }
2485    }
2486 #if defined(MTIOCSETEOTMODEL)
2487    uint32_t neof;
2488    if (dev->has_cap(CAP_TWOEOF)) {
2489       neof = 2;
2490    } else {
2491       neof = 1;
2492    }
2493    if (ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2494       berrno be;
2495       dev->dev_errno = errno;         /* save errno */
2496       Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2497             dev->print_name(), be.bstrerror(dev->dev_errno));
2498       Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2499    }
2500 #endif
2501    return;
2502 #endif
2503
2504 #ifdef HAVE_SUN_OS
2505    struct mtop mt_com;
2506    if (dev->min_block_size == dev->max_block_size &&
2507        dev->min_block_size == 0) {    /* variable block mode */
2508       mt_com.mt_op = MTSRSZ;
2509       mt_com.mt_count = 0;
2510       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2511          dev->clrerror(MTSRSZ);
2512       }
2513    }
2514    return;
2515 #endif
2516 }
2517
2518 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2519 {
2520    Dmsg0(100, "dev_get_os_pos\n");
2521    return dev->has_cap(CAP_MTIOCGET) &&
2522           tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2523           mt_stat->mt_fileno >= 0;
2524 }
2525
2526 static const char *modes[] = {
2527    "CREATE_READ_WRITE",
2528    "OPEN_READ_WRITE",
2529    "OPEN_READ_ONLY",
2530    "OPEN_WRITE_ONLY"
2531 };
2532
2533
2534 static const char *mode_to_str(int mode)
2535 {
2536    static char buf[100];
2537    if (mode < 1 || mode > 4) {
2538       bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2539       return buf;
2540     }
2541    return modes[mode-1];
2542 }