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