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

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