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

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