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

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