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