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