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