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