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

   1 /*
   2  *
   3  *   dev.c  -- low level operations on device (storage device)
   4  *
   5  *              Kern Sibbald, MM
   6  *
   7  *     NOTE!!!! None of these routines are reentrant. You must
   8  *        use lock_device() and unlock_device() at a higher level,
   9  *        or use the xxx_device() equivalents.  By moving the
  10  *        thread synchronization to a higher level, we permit
  11  *        the higher level routines to "seize" the device and
  12  *        to carry out operations without worrying about who
  13  *        set what lock (i.e. race conditions).
  14  *
  15  *     Note, this is the device dependent code, and my have
  16  *           to be modified for each system, but is meant to
  17  *           be as "generic" as possible.
  18  *
  19  *     The purpose of this code is to develop a SIMPLE Storage
  20  *     daemon. More complicated coding (double buffering, writer
  21  *     thread, ...) is left for a later version.
  22  *
  23  *     Unfortunately, I have had to add more and more complication
  24  *     to this code. This was not foreseen as noted above, and as
  25  *     a consequence has lead to something more contorted than is
  26  *     really necessary -- KES.  Note, this contortion has been
  27  *     corrected to a large extent by a rewrite (Apr MMI).
  28  *
  29  *   Version $Id$
  30  */
  31 /*
  32    Copyright (C) 2000-2005 Kern Sibbald
  33
  34    This program is free software; you can redistribute it and/or
  35    modify it under the terms of the GNU General Public License
  36    version 2 as ammended with additional clauses defined in the
  37    file LICENSE in the main source directory.
  38
  39    This program is distributed in the hope that it will be useful,
  40    but WITHOUT ANY WARRANTY; without even the implied warranty of
  41    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  42    the file LICENSE for additional details.
  43
  44  */
  45
  46 /*
  47  * Handling I/O errors and end of tape conditions are a bit tricky.
  48  * This is how it is currently done when writting.
  49  * On either an I/O error or end of tape,
  50  * we will stop writing on the physical device (no I/O recovery is
  51  * attempted at least in this daemon). The state flag will be sent
  52  * to include ST_EOT, which is ephimeral, and ST_WEOT, which is
  53  * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
  54  * cleared only when the problem goes away.  Now when ST_WEOT
  55  * is set all calls to write_block_to_device() call the fix_up
  56  * routine. In addition, all threads are blocked
  57  * from writing on the tape by calling lock_dev(), and thread other
  58  * than the first thread to hit the EOT will block on a condition
  59  * variable. The first thread to hit the EOT will continue to
  60  * be able to read and write the tape (he sort of tunnels through
  61  * the locking mechanism -- see lock_dev() for details).
  62  *
  63  * Now presumably somewhere higher in the chain of command
  64  * (device.c), someone will notice the EOT condition and
  65  * get a new tape up, get the tape label read, and mark
  66  * the label for rewriting. Then this higher level routine
  67  * will write the unwritten buffer to the new volume.
  68  * Finally, he will release
  69  * any blocked threads by doing a broadcast on the condition
  70  * variable.  At that point, we should be totally back in
  71  * business with no lost data.
  72  */
  73
  74
  75 #include "bacula.h"
  76 #include "stored.h"
  77
  78 #ifndef O_NONBLOCK
  79 #define O_NONBLOCK 0
  80 #endif
  81
  82 /* Functions in dvd.c */
  83 void get_filename(DEVICE *dev, char *VolName, POOL_MEM& archive_name);
  84 void update_free_space_dev(DEVICE* dev);
  85
  86
  87 /* Forward referenced functions */
  88 void set_os_device_parameters(DEVICE *dev);
  89 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
  90 static void open_tape_device(DEVICE *dev, int mode);
  91 static void open_file_device(DEVICE *dev, int mode);
  92
  93 /*
  94  * Allocate and initialize the DEVICE structure
  95  * Note, if dev is non-NULL, it is already allocated,
  96  * thus we neither allocate it nor free it. This allows
  97  * the caller to put the packet in shared memory.
  98  *
  99  *  Note, for a tape, the device->device_name is the device name
 100  *     (e.g. /dev/nst0), and for a file, the device name
 101  *     is the directory in which the file will be placed.
 102  *
 103  */
 104 DEVICE *
 105 init_dev(JCR *jcr, DEVRES *device)
 106 {
 107    struct stat statp;
 108    bool tape, fifo;
 109    int errstat;
 110    DCR *dcr = NULL;
 111    DEVICE *dev;
 112
 113    /* Check that device is available */
 114    if (stat(device->device_name, &statp) < 0) {
 115       berrno be;
 116       Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
 117          device->device_name, be.strerror());
 118       return NULL;
 119    }
 120
 121
 122    tape = false;
 123    fifo = false;
 124    if (S_ISDIR(statp.st_mode)) {
 125       tape = false;
 126    } else if (S_ISCHR(statp.st_mode)) {
 127       tape = true;
 128    } else if (S_ISFIFO(statp.st_mode)) {
 129       fifo = true;
 130    } else if (!(device->cap_bits & CAP_REQMOUNT)) {
 131       Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory. st_mode=%x\n"),
 132          device->device_name, statp.st_mode);
 133       return NULL;
 134    }
 135
 136    dev = (DEVICE *)get_memory(sizeof(DEVICE));
 137    memset(dev, 0, sizeof(DEVICE));
 138    dev->state = ST_MALLOC;
 139
 140    /* Copy user supplied device parameters from Resource */
 141    dev->dev_name = get_memory(strlen(device->device_name)+1);
 142    pm_strcpy(dev->dev_name, device->device_name);
 143    dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
 144    /* We edit "Resource-name" (physical-name) */
 145    Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
 146    dev->capabilities = device->cap_bits;
 147    dev->min_block_size = device->min_block_size;
 148    dev->max_block_size = device->max_block_size;
 149    dev->max_volume_size = device->max_volume_size;
 150    dev->max_file_size = device->max_file_size;
 151    dev->volume_capacity = device->volume_capacity;
 152    dev->max_rewind_wait = device->max_rewind_wait;
 153    dev->max_open_wait = device->max_open_wait;
 154    dev->max_open_vols = device->max_open_vols;
 155    dev->vol_poll_interval = device->vol_poll_interval;
 156    dev->max_spool_size = device->max_spool_size;
 157    dev->drive_index = device->drive_index;
 158    dev->autoselect = device->autoselect;
 159    if (tape) { /* No parts on tapes */
 160       dev->max_part_size = 0;
 161    }
 162    else {
 163       dev->max_part_size = device->max_part_size;
 164    }
 165    /* Sanity check */
 166    if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
 167       dev->vol_poll_interval = 60;
 168    }
 169    dev->device = device;
 170
 171    if (tape) {
 172       dev->state |= ST_TAPE;
 173    } else if (fifo) {
 174       dev->state |= ST_FIFO;
 175       dev->capabilities |= CAP_STREAM; /* set stream device */
 176    } else {
 177       dev->state |= ST_FILE;
 178    }
 179
 180    /* If the device requires mount :
 181     * - Check that the mount point is available
 182     * - Check that (un)mount commands are defined
 183     */
 184    if (dev->is_file() && dev->requires_mount()) {
 185       if (stat(device->mount_point, &statp) < 0) {
 186          berrno be;
 187          dev->dev_errno = errno;
 188          Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
 189             device->mount_point, be.strerror());
 190          return NULL;
 191       }
 192       if (!device->mount_command || !device->unmount_command) {
 193          Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
 194       }
 195       if (!device->write_part_command) {
 196          Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
 197       }
 198       dev->state |= ST_DVD;
 199    }
 200
 201    if (dev->max_block_size > 1000000) {
 202       Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
 203          dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
 204       dev->max_block_size = 0;
 205    }
 206    if (dev->max_block_size % TAPE_BSIZE != 0) {
 207       Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
 208          dev->max_block_size, dev->print_name());
 209    }
 210
 211    dev->errmsg = get_pool_memory(PM_EMSG);
 212    *dev->errmsg = 0;
 213
 214    if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
 215       berrno be;
 216       dev->dev_errno = errstat;
 217       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 218       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 219    }
 220    if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
 221       berrno be;
 222       dev->dev_errno = errstat;
 223       Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
 224       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 225    }
 226    if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
 227       berrno be;
 228       dev->dev_errno = errstat;
 229       Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
 230       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 231    }
 232    if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
 233       berrno be;
 234       dev->dev_errno = errstat;
 235       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 236       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 237    }
 238    if ((errstat = rwl_init(&dev->lock)) != 0) {
 239       berrno be;
 240       dev->dev_errno = errstat;
 241       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 242       Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
 243    }
 244
 245    dev->fd = -1;
 246    dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
 247    Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
 248
 249    return dev;
 250 }
 251
 252 /*
 253  * Open the device with the operating system and
 254  * initialize buffer pointers.
 255  *
 256  * Returns:  -1  on error
 257  *           fd  on success
 258  *
 259  * Note, for a tape, the VolName is the name we give to the
 260  *    volume (not really used here), but for a file, the
 261  *    VolName represents the name of the file to be created/opened.
 262  *    In the case of a file, the full name is the device name
 263  *    (archive_name) with the VolName concatenated.
 264  */
 265 int
 266 DEVICE::open(char *VolName, int mode)
 267 {
 268    if (is_open()) {
 269       if (openmode == mode) {
 270          return fd;
 271       } else {
 272         ::close(fd); /* use system close so correct mode will be used on open */
 273       }
 274    }
 275    if (VolName) {
 276       bstrncpy(VolCatInfo.VolCatName, VolName, sizeof(VolCatInfo.VolCatName));
 277    } else {
 278       VolCatInfo.VolCatName[0] = 0;
 279    }
 280
 281    Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%d\n", is_tape(),
 282          dev_name, VolCatInfo.VolCatName, mode);
 283    state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
 284    label_type = B_BACULA_LABEL;
 285    if (is_tape() || is_fifo()) {
 286       open_tape_device(this, mode);
 287    } else {
 288       Dmsg1(100, "call open_file_device mode=%d\n", mode);
 289       open_file_device(this, mode);
 290    }
 291    return fd;
 292 }
 293
 294 static void open_tape_device(DEVICE *dev, int mode)
 295 {
 296    int nonblocking = 0;;
 297    dev->file_size = 0;
 298    int timeout;
 299    int ioerrcnt = 10;
 300    Dmsg0(29, "open dev: device is tape\n");
 301
 302    if (mode == OPEN_READ_WRITE) {
 303       dev->mode = O_RDWR | O_BINARY;
 304    } else if (mode == OPEN_READ_ONLY) {
 305       dev->mode = O_RDONLY | O_BINARY;
 306    } else if (mode == OPEN_WRITE_ONLY) {
 307       dev->mode = O_WRONLY | O_BINARY;
 308    } else {
 309       Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
 310    }
 311    timeout = dev->max_open_wait;
 312    errno = 0;
 313    if (dev->open_nowait) {
 314        /* Set wait counters to zero for no wait */
 315        timeout = ioerrcnt = 0;
 316        /* Open drive in non-block mode */
 317        nonblocking = O_NONBLOCK;
 318    }
 319    if (dev->is_fifo() && timeout) {
 320       /* Set open timer */
 321       dev->tid = start_thread_timer(pthread_self(), timeout);
 322    }
 323    /* If busy retry each second for max_open_wait seconds */
 324 open_again:
 325    Dmsg1(500, "Try open %s\n", dev->dev_name);
 326    while ((dev->fd = open(dev->dev_name, dev->mode, MODE_RW+nonblocking)) < 0) {
 327       berrno be;
 328       Dmsg2(500, "Open error errno=%d ERR=%s\n", errno, be.strerror());
 329       if (errno == EINTR || errno == EAGAIN) {
 330          Dmsg0(500, "Continue open\n");
 331          continue;
 332       }
 333       /* Busy wait for specified time (default = 5 mins) */
 334       if (errno == EBUSY && timeout-- > 0) {
 335          Dmsg2(100, "Device %s busy. ERR=%s\n", dev->print_name(), be.strerror());
 336          bmicrosleep(1, 0);
 337          continue;
 338       }
 339       /* IO error (no volume) try 10 times every 6 seconds */
 340       if (errno == EIO && ioerrcnt-- > 0) {
 341          bmicrosleep(5, 0);
 342          Dmsg0(500, "Continue open\n");
 343          continue;
 344       }
 345       dev->dev_errno = errno;
 346       Mmsg2(dev->errmsg, _("Unable to open device %s: ERR=%s\n"),
 347             dev->print_name(), be.strerror(dev->dev_errno));
 348       /* Stop any open timer we set */
 349       if (dev->tid) {
 350          stop_thread_timer(dev->tid);
 351          dev->tid = 0;
 352       }
 353       Emsg0(M_FATAL, 0, dev->errmsg);
 354       break;
 355    }
 356    if (dev->fd >= 0) {
 357       /* If opened in non-block mode, close it an open it normally */
 358       if (nonblocking) {
 359          nonblocking = 0;
 360          close(dev->fd);
 361          goto open_again;
 362       }
 363       dev->openmode = mode;               /* save open mode */
 364       dev->dev_errno = 0;
 365       dev->state |= ST_OPENED;
 366       dev->use_count = 1;
 367       update_pos_dev(dev);                /* update position */
 368       set_os_device_parameters(dev);      /* do system dependent stuff */
 369       Dmsg0(500, "Open OK\n");
 370    }
 371    /* Stop any open() timer we started */
 372    if (dev->tid) {
 373       stop_thread_timer(dev->tid);
 374       dev->tid = 0;
 375    }
 376    Dmsg1(29, "open dev: tape %d opened\n", dev->fd);
 377 }
 378
 379 /*
 380  * Open a file or DVD device
 381  */
 382 static void open_file_device(DEVICE *dev, int mode)
 383 {
 384    POOL_MEM archive_name(PM_FNAME);
 385    struct stat filestat;
 386
 387    /*
 388     * Handle opening of File Archive (not a tape)
 389     */
 390    Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%d\n", dev->is_dvd()?"DVD":"disk",
 391          archive_name.c_str(), mode);
 392
 393    if (dev->VolCatInfo.VolCatName[0] == 0) {
 394       Mmsg(dev->errmsg, _("Could not open file device %s. No Volume name given.\n"),
 395          dev->print_name());
 396       dev->fd = -1;
 397       return;
 398    }
 399
 400    if (dev->is_dvd()) {
 401       if (dev->part == 0) {
 402          dev->file_size = 0;
 403       }
 404       dev->part_size = 0;
 405
 406       /* if num_parts has not been set, but VolCatInfo is available, copy
 407        * it from the VolCatInfo.VolCatParts */
 408       if (dev->num_parts < dev->VolCatInfo.VolCatParts) {
 409          dev->num_parts = dev->VolCatInfo.VolCatParts;
 410       }
 411
 412       get_filename(dev, dev->VolCatInfo.VolCatName, archive_name);
 413
 414       if (mount_dev(dev, 1) < 0) {
 415          Mmsg(dev->errmsg, _("Could not mount device %s.\n"),
 416               dev->print_name());
 417          Emsg0(M_FATAL, 0, dev->errmsg);
 418          dev->fd = -1;
 419          return;
 420       }
 421    } else {
 422       get_filename(dev, dev->VolCatInfo.VolCatName, archive_name);
 423    }
 424
 425    Dmsg3(29, "open dev: %s dev=%s mode=%d\n", dev->is_dvd()?"DVD":"disk",
 426          archive_name.c_str(), mode);
 427    dev->openmode = mode;
 428
 429    /*
 430     * If we are not trying to access the last part, set mode to
 431     *   OPEN_READ_ONLY as writing would be an error.
 432     */
 433    if (dev->part < dev->num_parts) {
 434       mode = OPEN_READ_ONLY;
 435    }
 436
 437    if (mode == OPEN_READ_WRITE) {
 438       dev->mode = O_CREAT | O_RDWR | O_BINARY;
 439    } else if (mode == OPEN_READ_ONLY) {
 440       dev->mode = O_RDONLY | O_BINARY;
 441    } else if (mode == OPEN_WRITE_ONLY) {
 442       dev->mode = O_WRONLY | O_BINARY;
 443    } else {
 444       Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
 445    }
 446    /* If creating file, give 0640 permissions */
 447    Dmsg3(29, "mode=%d open(%s, 0x%x, 0640)\n", mode, archive_name.c_str(), dev->mode);
 448    if ((dev->fd = open(archive_name.c_str(), dev->mode, 0640)) < 0) {
 449       berrno be;
 450       dev->dev_errno = errno;
 451       Mmsg2(dev->errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
 452             be.strerror());
 453       Dmsg1(29, "open failed: %s", dev->errmsg);
 454       Emsg0(M_FATAL, 0, dev->errmsg);
 455    } else {
 456       dev->dev_errno = 0;
 457       dev->state |= ST_OPENED;
 458       dev->use_count = 1;
 459       update_pos_dev(dev);                /* update position */
 460       if (fstat(dev->fd, &filestat) < 0) {
 461          berrno be;
 462          dev->dev_errno = errno;
 463          Mmsg2(dev->errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
 464                be.strerror());
 465          Emsg0(M_FATAL, 0, dev->errmsg);
 466          Dmsg1(29, "open failed: %s", dev->errmsg);
 467       } else {
 468          dev->part_size = filestat.st_size;
 469       }
 470    }
 471    Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
 472       dev->is_dvd()?"DVD":"disk", dev->fd, dev->part, dev->num_parts,
 473       dev->part_size);
 474    if (dev->is_open() && dev->is_dvd() && (mode != OPEN_READ_ONLY) &&
 475        (dev->free_space_errno == 0 || dev->num_parts == dev->part)) {
 476       update_free_space_dev(dev);
 477    }
 478 }
 479
 480 #ifdef debug_tracing
 481 #undef rewind_dev
 482 bool _rewind_dev(char *file, int line, DEVICE *dev)
 483 {
 484    Dmsg2(100, "rewind_dev called from %s:%d\n", file, line);
 485    return rewind_dev(dev);
 486 }
 487 #endif
 488
 489 /*
 490  * Rewind the device.
 491  *  Returns: true  on success
 492  *           false on failure
 493  */
 494 bool rewind_dev(DEVICE *dev)
 495 {
 496    struct mtop mt_com;
 497    unsigned int i;
 498
 499    Dmsg1(29, "rewind_dev %s\n", dev->print_name());
 500    if (dev->fd < 0) {
 501       dev->dev_errno = EBADF;
 502       Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
 503             dev->print_name());
 504       Emsg0(M_ABORT, 0, dev->errmsg);
 505       return false;
 506    }
 507    dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
 508    dev->block_num = dev->file = 0;
 509    dev->file_size = 0;
 510    dev->file_addr = 0;
 511    if (dev->is_tape()) {
 512       mt_com.mt_op = MTREW;
 513       mt_com.mt_count = 1;
 514       /* If we get an I/O error on rewind, it is probably because
 515        * the drive is actually busy. We loop for (about 5 minutes)
 516        * retrying every 5 seconds.
 517        */
 518       for (i=dev->max_rewind_wait; ; i -= 5) {
 519          if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
 520             berrno be;
 521             clrerror_dev(dev, MTREW);
 522             if (i == dev->max_rewind_wait) {
 523                Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
 524             }
 525             if (dev->dev_errno == EIO && i > 0) {
 526                Dmsg0(200, "Sleeping 5 seconds.\n");
 527                bmicrosleep(5, 0);
 528                continue;
 529             }
 530             Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
 531                dev->print_name(), be.strerror());
 532             return false;
 533          }
 534          break;
 535       }
 536    } else if (dev->is_file()) {
 537       if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
 538          berrno be;
 539          dev->dev_errno = errno;
 540          Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
 541             dev->print_name(), be.strerror());
 542          return false;
 543       }
 544    }
 545    return true;
 546 }
 547
 548 void DEVICE::block(int why)
 549 {
 550    lock_device(this);
 551    block_device(this, why);
 552    V(mutex);
 553 }
 554
 555 void DEVICE::unblock()
 556 {
 557    P(mutex);
 558    unblock_device(this);
 559    V(mutex);
 560 }
 561
 562 /*
 563  * Called to indicate that we have just read an
 564  *  EOF from the device.
 565  */
 566 void DEVICE::set_ateof()
 567 {
 568    set_eof();
 569    file++;
 570    file_addr = 0;
 571    file_size = 0;
 572    block_num = 0;
 573 }
 574
 575 /*
 576  * Called to indicate we are now at the end of the tape, and
 577  *   writing is not possible.
 578  */
 579 void DEVICE::set_ateot()
 580 {
 581    /* Make tape effectively read-only */
 582    state |= (ST_EOF|ST_EOT|ST_WEOT);
 583    clear_append();
 584 }
 585
 586 /*
 587  * Position device to end of medium (end of data)
 588  *  Returns: true  on succes
 589  *           false on error
 590  */
 591 bool
 592 eod_dev(DEVICE *dev)
 593 {
 594    struct mtop mt_com;
 595    struct mtget mt_stat;
 596    bool ok = true;
 597    off_t pos;
 598
 599    if (dev->fd < 0) {
 600       dev->dev_errno = EBADF;
 601       Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
 602             dev->print_name());
 603       return false;
 604    }
 605
 606 #if defined (__digital__) && defined (__unix__)
 607    return fsf_dev(dev, dev->VolCatInfo.VolCatFiles);
 608 #endif
 609
 610    Dmsg0(29, "eod_dev\n");
 611    if (dev->at_eot()) {
 612       return true;
 613    }
 614    dev->state &= ~(ST_EOF);  /* remove EOF flags */
 615    dev->block_num = dev->file = 0;
 616    dev->file_size = 0;
 617    dev->file_addr = 0;
 618    if (dev->state & (ST_FIFO | ST_PROG)) {
 619       return true;
 620    }
 621    if (!dev->is_tape()) {
 622       pos = lseek_dev(dev, (off_t)0, SEEK_END);
 623 //    Dmsg1(100, "====== Seek to %lld\n", pos);
 624       if (pos >= 0) {
 625          update_pos_dev(dev);
 626          dev->state |= ST_EOT;
 627          return true;
 628       }
 629       dev->dev_errno = errno;
 630       berrno be;
 631       Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
 632              dev->print_name(), be.strerror());
 633       return false;
 634    }
 635 #ifdef MTEOM
 636    if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
 637       Dmsg0(100,"Using FAST FSF for EOM\n");
 638       /* If unknown position, rewind */
 639       if (!dev_get_os_pos(dev, &mt_stat)) {
 640         if (!rewind_dev(dev)) {
 641           return false;
 642         }
 643       }
 644       mt_com.mt_op = MTFSF;
 645       /*
 646        * ***FIXME*** fix code to handle case that INT16_MAX is
 647        *   not large enough.
 648        */
 649       mt_com.mt_count = INT16_MAX;    /* use big positive number */
 650       if (mt_com.mt_count < 0) {
 651          mt_com.mt_count = INT16_MAX; /* brain damaged system */
 652       }
 653    }
 654
 655    if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
 656       if (dev_cap(dev, CAP_EOM)) {
 657          Dmsg0(100,"Using EOM for EOM\n");
 658          mt_com.mt_op = MTEOM;
 659          mt_com.mt_count = 1;
 660       }
 661
 662       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
 663          berrno be;
 664          clrerror_dev(dev, mt_com.mt_op);
 665          Dmsg1(50, "ioctl error: %s\n", be.strerror());
 666          update_pos_dev(dev);
 667          Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
 668             dev->print_name(), be.strerror());
 669          return false;
 670       }
 671
 672       if (!dev_get_os_pos(dev, &mt_stat)) {
 673          berrno be;
 674          clrerror_dev(dev, -1);
 675          Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
 676             dev->print_name(), be.strerror());
 677          return false;
 678       }
 679       Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
 680       dev->set_ateof();
 681       dev->file = mt_stat.mt_fileno;
 682    } else {
 683 #else
 684    {
 685 #endif
 686       /*
 687        * Rewind then use FSF until EOT reached
 688        */
 689       if (!rewind_dev(dev)) {
 690          return false;
 691       }
 692       /*
 693        * Move file by file to the end of the tape
 694        */
 695       int file_num;
 696       for (file_num=dev->file; !dev->at_eot(); file_num++) {
 697          Dmsg0(200, "eod_dev: doing fsf 1\n");
 698          if (!fsf_dev(dev, 1)) {
 699             Dmsg0(200, "fsf_dev error.\n");
 700             return false;
 701          }
 702          /*
 703           * Avoid infinite loop. ***FIXME*** possibly add code
 704           *   to set EOD or to turn off CAP_FASTFSF if on.
 705           */
 706          if (file_num == (int)dev->file) {
 707             struct mtget mt_stat;
 708             Dmsg1(100, "fsf_dev did not advance from file %d\n", file_num);
 709             if (dev_get_os_pos(dev, &mt_stat)) {
 710                Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
 711                dev->set_ateof();
 712                dev->file = mt_stat.mt_fileno;
 713             }
 714             return false;
 715          }
 716       }
 717    }
 718    /*
 719     * Some drivers leave us after second EOF when doing
 720     * MTEOM, so we must backup so that appending overwrites
 721     * the second EOF.
 722     */
 723    if (dev_cap(dev, CAP_BSFATEOM)) {
 724       struct mtget mt_stat;
 725       /* Backup over EOF */
 726       ok = bsf_dev(dev, 1);
 727       /* If BSF worked and fileno is known (not -1), set file */
 728       if (dev_get_os_pos(dev, &mt_stat)) {
 729          Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
 730          dev->file = mt_stat.mt_fileno;
 731       } else {
 732          dev->file++;                 /* wing it -- not correct on all OSes */
 733       }
 734    } else {
 735       update_pos_dev(dev);                   /* update position */
 736    }
 737    Dmsg1(200, "EOD dev->file=%d\n", dev->file);
 738    return ok;
 739 }
 740
 741 /*
 742  * Set the position of the device -- only for files
 743  *   For other devices, there is no generic way to do it.
 744  *  Returns: true  on succes
 745  *           false on error
 746  */
 747 bool update_pos_dev(DEVICE *dev)
 748 {
 749    off_t pos;
 750    bool ok = true;
 751
 752    if (dev->fd < 0) {
 753       dev->dev_errno = EBADF;
 754       Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
 755       Emsg0(M_FATAL, 0, dev->errmsg);
 756       return false;
 757    }
 758
 759    /* Find out where we are */
 760    if (dev->is_file()) {
 761       dev->file = 0;
 762       dev->file_addr = 0;
 763       pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
 764       if (pos < 0) {
 765          berrno be;
 766          dev->dev_errno = errno;
 767          Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
 768          Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
 769             dev->print_name(), be.strerror());
 770          ok = false;
 771       } else {
 772          dev->file_addr = pos;
 773       }
 774    }
 775    return ok;
 776 }
 777
 778
 779 /*
 780  * Return the status of the device.  This was meant
 781  * to be a generic routine. Unfortunately, it doesn't
 782  * seem possible (at least I do not know how to do it
 783  * currently), which means that for the moment, this
 784  * routine has very little value.
 785  *
 786  *   Returns: status
 787  */
 788 uint32_t status_dev(DEVICE *dev)
 789 {
 790    struct mtget mt_stat;
 791    uint32_t stat = 0;
 792
 793    if (dev->state & (ST_EOT | ST_WEOT)) {
 794       stat |= BMT_EOD;
 795       Pmsg0(-20, " EOD");
 796    }
 797    if (dev->state & ST_EOF) {
 798       stat |= BMT_EOF;
 799       Pmsg0(-20, " EOF");
 800    }
 801    if (dev->is_tape()) {
 802       stat |= BMT_TAPE;
 803       Pmsg0(-20," Bacula status:");
 804       Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
 805       if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
 806          berrno be;
 807          dev->dev_errno = errno;
 808          Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
 809             dev->print_name(), be.strerror());
 810          return 0;
 811       }
 812       Pmsg0(-20, " Device status:");
 813
 814 #if defined(HAVE_LINUX_OS)
 815       if (GMT_EOF(mt_stat.mt_gstat)) {
 816          stat |= BMT_EOF;
 817          Pmsg0(-20, " EOF");
 818       }
 819       if (GMT_BOT(mt_stat.mt_gstat)) {
 820          stat |= BMT_BOT;
 821          Pmsg0(-20, " BOT");
 822       }
 823       if (GMT_EOT(mt_stat.mt_gstat)) {
 824          stat |= BMT_EOT;
 825          Pmsg0(-20, " EOT");
 826       }
 827       if (GMT_SM(mt_stat.mt_gstat)) {
 828          stat |= BMT_SM;
 829          Pmsg0(-20, " SM");
 830       }
 831       if (GMT_EOD(mt_stat.mt_gstat)) {
 832          stat |= BMT_EOD;
 833          Pmsg0(-20, " EOD");
 834       }
 835       if (GMT_WR_PROT(mt_stat.mt_gstat)) {
 836          stat |= BMT_WR_PROT;
 837          Pmsg0(-20, " WR_PROT");
 838       }
 839       if (GMT_ONLINE(mt_stat.mt_gstat)) {
 840          stat |= BMT_ONLINE;
 841          Pmsg0(-20, " ONLINE");
 842       }
 843       if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
 844          stat |= BMT_DR_OPEN;
 845          Pmsg0(-20, " DR_OPEN");
 846       }
 847       if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
 848          stat |= BMT_IM_REP_EN;
 849          Pmsg0(-20, " IM_REP_EN");
 850       }
 851 #endif /* !SunOS && !OSF */
 852       if (dev_cap(dev, CAP_MTIOCGET)) {
 853          Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
 854       } else {
 855          Pmsg2(-20, " file=%d block=%d\n", -1, -1);
 856       }
 857    } else {
 858       stat |= BMT_ONLINE | BMT_BOT;
 859    }
 860    return stat;
 861 }
 862
 863
 864 /*
 865  * Load medium in device
 866  *  Returns: true  on success
 867  *           false on failure
 868  */
 869 bool load_dev(DEVICE *dev)
 870 {
 871 #ifdef MTLOAD
 872    struct mtop mt_com;
 873 #endif
 874
 875    if (dev->fd < 0) {
 876       dev->dev_errno = EBADF;
 877       Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
 878       Emsg0(M_FATAL, 0, dev->errmsg);
 879       return false;
 880    }
 881    if (!(dev->is_tape())) {
 882       return true;
 883    }
 884 #ifndef MTLOAD
 885    Dmsg0(200, "stored: MTLOAD command not available\n");
 886    berrno be;
 887    dev->dev_errno = ENOTTY;           /* function not available */
 888    Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
 889          dev->print_name(), be.strerror());
 890    return false;
 891 #else
 892
 893    dev->block_num = dev->file = 0;
 894    dev->file_size = 0;
 895    dev->file_addr = 0;
 896    mt_com.mt_op = MTLOAD;
 897    mt_com.mt_count = 1;
 898    if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
 899       berrno be;
 900       dev->dev_errno = errno;
 901       Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
 902          dev->print_name(), be.strerror());
 903       return false;
 904    }
 905    return true;
 906 #endif
 907 }
 908
 909 /*
 910  * Rewind device and put it offline
 911  *  Returns: true  on success
 912  *           false on failure
 913  */
 914 bool offline_dev(DEVICE *dev)
 915 {
 916    struct mtop mt_com;
 917
 918    if (dev->fd < 0) {
 919       dev->dev_errno = EBADF;
 920       Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
 921       Emsg0(M_FATAL, 0, dev->errmsg);
 922       return false;
 923    }
 924    if (!(dev->is_tape())) {
 925       return true;
 926    }
 927
 928    dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
 929    dev->block_num = dev->file = 0;
 930    dev->file_size = 0;
 931    dev->file_addr = 0;
 932    dev->part = 0;
 933 #ifdef MTUNLOCK
 934    mt_com.mt_op = MTUNLOCK;
 935    mt_com.mt_count = 1;
 936    ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
 937 #endif
 938    mt_com.mt_op = MTOFFL;
 939    mt_com.mt_count = 1;
 940    if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
 941       berrno be;
 942       dev->dev_errno = errno;
 943       Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
 944          dev->print_name(), be.strerror());
 945       return false;
 946    }
 947    Dmsg1(100, "Offlined device %s\n", dev->print_name());
 948    return true;
 949 }
 950
 951 bool offline_or_rewind_dev(DEVICE *dev)
 952 {
 953    if (dev->fd < 0) {
 954       return false;
 955    }
 956    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
 957       return offline_dev(dev);
 958    } else {
 959    /*
 960     * Note, this rewind probably should not be here (it wasn't
 961     *  in prior versions of Bacula), but on FreeBSD, this is
 962     *  needed in the case the tape was "frozen" due to an error
 963     *  such as backspacing after writing and EOF. If it is not
 964     *  done, all future references to the drive get and I/O error.
 965     */
 966       clrerror_dev(dev, MTREW);
 967       return rewind_dev(dev);
 968    }
 969 }
 970
 971 /*
 972  * Foward space a file
 973  *   Returns: true  on success
 974  *            false on failure
 975  */
 976 bool
 977 fsf_dev(DEVICE *dev, int num)
 978 {
 979    struct mtget mt_stat;
 980    struct mtop mt_com;
 981    int stat = 0;
 982
 983    if (dev->fd < 0) {
 984       dev->dev_errno = EBADF;
 985       Mmsg0(dev->errmsg, _("Bad call to fsf_dev. Device not open\n"));
 986       Emsg0(M_FATAL, 0, dev->errmsg);
 987       return false;
 988    }
 989
 990    if (!dev->is_tape()) {
 991       return true;
 992    }
 993    if (dev->state & ST_EOT) {
 994       dev->dev_errno = 0;
 995       Mmsg1(dev->errmsg, _("Device %s at End of Tape.\n"), dev->print_name());
 996       return false;
 997    }
 998    if (dev->state & ST_EOF) {
 999       Dmsg0(200, "ST_EOF set on entry to FSF\n");
1000    }
1001
1002    Dmsg0(100, "fsf_dev\n");
1003    dev->block_num = 0;
1004    /*
1005     * If Fast forward space file is set, then we
1006     *  use MTFSF to forward space and MTIOCGET
1007     *  to get the file position. We assume that
1008     *  the SCSI driver will ensure that we do not
1009     *  forward space past the end of the medium.
1010     */
1011    if (dev_cap(dev, CAP_FSF) && dev_cap(dev, CAP_MTIOCGET) && dev_cap(dev, CAP_FASTFSF)) {
1012       mt_com.mt_op = MTFSF;
1013       mt_com.mt_count = num;
1014       stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1015       if (stat < 0 || !dev_get_os_pos(dev, &mt_stat)) {
1016          berrno be;
1017          dev->state |= ST_EOT;
1018          Dmsg0(200, "Set ST_EOT\n");
1019          clrerror_dev(dev, MTFSF);
1020          Mmsg2(dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1021             dev->print_name(), be.strerror());
1022          Dmsg1(200, "%s", dev->errmsg);
1023          return false;
1024       }
1025       Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1026       dev->set_ateof();
1027       dev->file = mt_stat.mt_fileno;
1028       return true;
1029
1030    /*
1031     * Here if CAP_FSF is set, and virtually all drives
1032     *  these days support it, we read a record, then forward
1033     *  space one file. Using this procedure, which is slow,
1034     *  is the only way we can be sure that we don't read
1035     *  two consecutive EOF marks, which means End of Data.
1036     */
1037    } else if (dev_cap(dev, CAP_FSF)) {
1038       POOLMEM *rbuf;
1039       int rbuf_len;
1040       Dmsg0(200, "FSF has cap_fsf\n");
1041       if (dev->max_block_size == 0) {
1042          rbuf_len = DEFAULT_BLOCK_SIZE;
1043       } else {
1044          rbuf_len = dev->max_block_size;
1045       }
1046       rbuf = get_memory(rbuf_len);
1047       mt_com.mt_op = MTFSF;
1048       mt_com.mt_count = 1;
1049       while (num-- && !(dev->state & ST_EOT)) {
1050          Dmsg0(100, "Doing read before fsf\n");
1051          if ((stat = read(dev->fd, (char *)rbuf, rbuf_len)) < 0) {
1052             if (errno == ENOMEM) {     /* tape record exceeds buf len */
1053                stat = rbuf_len;        /* This is OK */
1054             } else {
1055                berrno be;
1056                dev->state |= ST_EOT;
1057                clrerror_dev(dev, -1);
1058                Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev->dev_errno,
1059                   be.strerror());
1060                Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1061                   dev->print_name(), be.strerror());
1062                Dmsg1(100, "%s", dev->errmsg);
1063                break;
1064             }
1065          }
1066          if (stat == 0) {                /* EOF */
1067             update_pos_dev(dev);
1068             Dmsg1(100, "End of File mark from read. File=%d\n", dev->file+1);
1069             /* Two reads of zero means end of tape */
1070             if (dev->state & ST_EOF) {
1071                dev->state |= ST_EOT;
1072                Dmsg0(100, "Set ST_EOT\n");
1073                break;
1074             } else {
1075                dev->set_ateof();
1076                continue;
1077             }
1078          } else {                        /* Got data */
1079             dev->state &= ~(ST_EOF|ST_EOT);
1080          }
1081
1082          Dmsg0(100, "Doing MTFSF\n");
1083          stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1084          if (stat < 0) {                 /* error => EOT */
1085             berrno be;
1086             dev->state |= ST_EOT;
1087             Dmsg0(100, "Set ST_EOT\n");
1088             clrerror_dev(dev, MTFSF);
1089             Mmsg2(dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1090                dev->print_name(), be.strerror());
1091             Dmsg0(100, "Got < 0 for MTFSF\n");
1092             Dmsg1(100, "%s", dev->errmsg);
1093          } else {
1094             dev->set_ateof();
1095          }
1096       }
1097       free_memory(rbuf);
1098
1099    /*
1100     * No FSF, so use FSR to simulate it
1101     */
1102    } else {
1103       Dmsg0(200, "Doing FSR for FSF\n");
1104       while (num-- && !(dev->state & ST_EOT)) {
1105          dev->fsr(INT32_MAX);    /* returns -1 on EOF or EOT */
1106       }
1107       if (dev->state & ST_EOT) {
1108          dev->dev_errno = 0;
1109          Mmsg1(dev->errmsg, _("Device %s at End of Tape.\n"), dev->print_name());
1110          stat = -1;
1111       } else {
1112          stat = 0;
1113       }
1114    }
1115    update_pos_dev(dev);
1116    Dmsg1(200, "Return %d from FSF\n", stat);
1117    if (dev->state & ST_EOF)
1118       Dmsg0(200, "ST_EOF set on exit FSF\n");
1119    if (dev->state & ST_EOT)
1120       Dmsg0(200, "ST_EOT set on exit FSF\n");
1121    Dmsg1(200, "Return from FSF file=%d\n", dev->file);
1122    return stat == 0;
1123 }
1124
1125 /*
1126  * Backward space a file
1127  *  Returns: false on failure
1128  *           true  on success
1129  */
1130 bool
1131 bsf_dev(DEVICE *dev, int num)
1132 {
1133    struct mtop mt_com;
1134    int stat;
1135
1136    if (dev->fd < 0) {
1137       dev->dev_errno = EBADF;
1138       Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1139       Emsg0(M_FATAL, 0, dev->errmsg);
1140       return false;
1141    }
1142
1143    if (!dev->is_tape()) {
1144       Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1145          dev->print_name());
1146       return false;
1147    }
1148    Dmsg0(29, "bsf_dev\n");
1149    dev->state &= ~(ST_EOT|ST_EOF);
1150    dev->file -= num;
1151    dev->file_addr = 0;
1152    dev->file_size = 0;
1153    mt_com.mt_op = MTBSF;
1154    mt_com.mt_count = num;
1155    stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1156    if (stat < 0) {
1157       berrno be;
1158       clrerror_dev(dev, MTBSF);
1159       Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1160          dev->print_name(), be.strerror());
1161    }
1162    update_pos_dev(dev);
1163    return stat == 0;
1164 }
1165
1166
1167 /*
1168  * Foward space num records
1169  *  Returns: false on failure
1170  *           true  on success
1171  */
1172 bool DEVICE::fsr(int num)
1173 {
1174    struct mtop mt_com;
1175    int stat;
1176
1177    if (fd < 0) {
1178       dev_errno = EBADF;
1179       Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1180       Emsg0(M_FATAL, 0, errmsg);
1181       return false;
1182    }
1183
1184    if (!is_tape()) {
1185       return false;
1186    }
1187    if (!dev_cap(this, CAP_FSR)) {
1188       Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1189       return false;
1190    }
1191
1192    Dmsg1(29, "fsr %d\n", num);
1193    mt_com.mt_op = MTFSR;
1194    mt_com.mt_count = num;
1195    stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1196    if (stat == 0) {
1197       clear_eof();
1198       block_num += num;
1199    } else {
1200       berrno be;
1201       struct mtget mt_stat;
1202       clrerror_dev(this, MTFSR);
1203       Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1204       if (dev_get_os_pos(this, &mt_stat)) {
1205          Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1206             block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1207          file = mt_stat.mt_fileno;
1208          block_num = mt_stat.mt_blkno;
1209       } else {
1210          if (at_eof()) {
1211             set_eot();
1212          } else {
1213             set_ateof();
1214          }
1215       }
1216       Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1217          num, print_name(), be.strerror());
1218    }
1219    update_pos_dev(this);
1220    return stat == 0;
1221 }
1222
1223 /*
1224  * Backward space a record
1225  *   Returns:  false on failure
1226  *             true  on success
1227  */
1228 bool
1229 bsr_dev(DEVICE *dev, int num)
1230 {
1231    struct mtop mt_com;
1232    int stat;
1233
1234    if (dev->fd < 0) {
1235       dev->dev_errno = EBADF;
1236       Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1237       Emsg0(M_FATAL, 0, dev->errmsg);
1238       return false;
1239    }
1240
1241    if (!dev->is_tape()) {
1242       return false;
1243    }
1244
1245    if (!dev_cap(dev, CAP_BSR)) {
1246       Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1247       return false;
1248    }
1249
1250    Dmsg0(29, "bsr_dev\n");
1251    dev->block_num -= num;
1252    dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1253    mt_com.mt_op = MTBSR;
1254    mt_com.mt_count = num;
1255    stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1256    if (stat < 0) {
1257       berrno be;
1258       clrerror_dev(dev, MTBSR);
1259       Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1260          dev->print_name(), be.strerror());
1261    }
1262    update_pos_dev(dev);
1263    return stat == 0;
1264 }
1265
1266 /*
1267  * Reposition the device to file, block
1268  * Returns: false on failure
1269  *          true  on success
1270  */
1271 bool
1272 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1273 {
1274    if (dev->fd < 0) {
1275       dev->dev_errno = EBADF;
1276       Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1277       Emsg0(M_FATAL, 0, dev->errmsg);
1278       return false;
1279    }
1280
1281    if (!dev->is_tape()) {
1282       off_t pos = (((off_t)file)<<32) + block;
1283       Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1284       if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1285          berrno be;
1286          dev->dev_errno = errno;
1287          Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1288             dev->print_name(), be.strerror());
1289          return false;
1290       }
1291       dev->file = file;
1292       dev->block_num = block;
1293       dev->file_addr = pos;
1294       return true;
1295    }
1296    Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1297       dev->file, dev->block_num, file, block);
1298    if (file < dev->file) {
1299       Dmsg0(100, "Rewind_dev\n");
1300       if (!rewind_dev(dev)) {
1301          return false;
1302       }
1303    }
1304    if (file > dev->file) {
1305       Dmsg1(100, "fsf %d\n", file-dev->file);
1306       if (!fsf_dev(dev, file-dev->file)) {
1307          Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1308          return false;
1309       }
1310       Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1311    }
1312    if (block < dev->block_num) {
1313       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1314       Dmsg0(100, "bsf_dev 1\n");
1315       bsf_dev(dev, 1);
1316       Dmsg0(100, "fsf_dev 1\n");
1317       fsf_dev(dev, 1);
1318       Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1319    }
1320    if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1321       /* Ignore errors as Bacula can read to the correct block */
1322       Dmsg1(100, "fsr %d\n", block-dev->block_num);
1323       return dev->fsr(block-dev->block_num);
1324    }
1325    return true;
1326 }
1327
1328
1329
1330 /*
1331  * Write an end of file on the device
1332  *   Returns: 0 on success
1333  *            non-zero on failure
1334  */
1335 int
1336 weof_dev(DEVICE *dev, int num)
1337 {
1338    struct mtop mt_com;
1339    int stat;
1340    Dmsg0(29, "weof_dev\n");
1341
1342    if (dev->fd < 0) {
1343       dev->dev_errno = EBADF;
1344       Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1345       Emsg0(M_FATAL, 0, dev->errmsg);
1346       return -1;
1347    }
1348    dev->file_size = 0;
1349
1350    if (!dev->is_tape()) {
1351       return 0;
1352    }
1353    if (!dev->can_append()) {
1354       Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1355       Emsg0(M_FATAL, 0, dev->errmsg);
1356       return -1;
1357    }
1358
1359    dev->state &= ~(ST_EOT | ST_EOF);  /* remove EOF/EOT flags */
1360    mt_com.mt_op = MTWEOF;
1361    mt_com.mt_count = num;
1362    stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1363    if (stat == 0) {
1364       dev->block_num = 0;
1365       dev->file += num;
1366       dev->file_addr = 0;
1367    } else {
1368       berrno be;
1369       clrerror_dev(dev, MTWEOF);
1370       if (stat == -1) {
1371          Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1372             dev->print_name(), be.strerror());
1373        }
1374    }
1375    return stat;
1376 }
1377
1378 /*
1379  * Return string message with last error in English
1380  *  Be careful not to call this routine from within dev.c
1381  *  while editing an Mmsg() or you will end up in a recursive
1382  *  loop creating a Segmentation Violation.
1383  */
1384 char *
1385 strerror_dev(DEVICE *dev)
1386 {
1387    return dev->errmsg;
1388 }
1389
1390
1391 /*
1392  * If implemented in system, clear the tape
1393  * error status.
1394  */
1395 void
1396 clrerror_dev(DEVICE *dev, int func)
1397 {
1398    const char *msg = NULL;
1399    struct mtget mt_stat;
1400    char buf[100];
1401
1402    dev->dev_errno = errno;         /* save errno */
1403    if (errno == EIO) {
1404       dev->VolCatInfo.VolCatErrors++;
1405    }
1406
1407    if (!dev->is_tape()) {
1408       return;
1409    }
1410    if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1411       switch (func) {
1412       case -1:
1413          Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1414          break;
1415       case MTWEOF:
1416          msg = "WTWEOF";
1417          dev->capabilities &= ~CAP_EOF; /* turn off feature */
1418          break;
1419 #ifdef MTEOM
1420       case MTEOM:
1421          msg = "WTEOM";
1422          dev->capabilities &= ~CAP_EOM; /* turn off feature */
1423          break;
1424 #endif
1425       case MTFSF:
1426          msg = "MTFSF";
1427          dev->capabilities &= ~CAP_FSF; /* turn off feature */
1428          break;
1429       case MTBSF:
1430          msg = "MTBSF";
1431          dev->capabilities &= ~CAP_BSF; /* turn off feature */
1432          break;
1433       case MTFSR:
1434          msg = "MTFSR";
1435          dev->capabilities &= ~CAP_FSR; /* turn off feature */
1436          break;
1437       case MTBSR:
1438          msg = "MTBSR";
1439          dev->capabilities &= ~CAP_BSR; /* turn off feature */
1440          break;
1441       case MTREW:
1442          msg = "MTREW";
1443          break;
1444 #ifdef MTSETBLK
1445       case MTSETBLK:
1446          msg = "MTSETBLK";
1447          break;
1448 #endif
1449 #ifdef MTSETBSIZ
1450       case MTSETBSIZ:
1451          msg = "MTSETBSIZ";
1452          break;
1453 #endif
1454 #ifdef MTSRSZ
1455       case MTSRSZ:
1456          msg = "MTSRSZ";
1457          break;
1458 #endif
1459       default:
1460          bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1461          msg = buf;
1462          break;
1463       }
1464       if (msg != NULL) {
1465          dev->dev_errno = ENOSYS;
1466          Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1467          Emsg0(M_ERROR, 0, dev->errmsg);
1468       }
1469    }
1470    /* On some systems such as NetBSD, this clears all errors */
1471    ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1472
1473 /* Found on Linux */
1474 #ifdef MTIOCLRERR
1475 {
1476    struct mtop mt_com;
1477    mt_com.mt_op = MTIOCLRERR;
1478    mt_com.mt_count = 1;
1479    /* Clear any error condition on the tape */
1480    ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1481    Dmsg0(200, "Did MTIOCLRERR\n");
1482 }
1483 #endif
1484
1485 /* Typically on FreeBSD */
1486 #ifdef MTIOCERRSTAT
1487 {
1488    /* Read and clear SCSI error status */
1489    union mterrstat mt_errstat;
1490    Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1491       strerror(dev->dev_errno));
1492    ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1493 }
1494 #endif
1495
1496 /* Clear Subsystem Exception OSF1 */
1497 #ifdef MTCSE
1498 {
1499    struct mtop mt_com;
1500    mt_com.mt_op = MTCSE;
1501    mt_com.mt_count = 1;
1502    /* Clear any error condition on the tape */
1503    ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1504    Dmsg0(200, "Did MTCSE\n");
1505 }
1506 #endif
1507 }
1508
1509 /*
1510  * Flush buffer contents
1511  *  No longer used.
1512  */
1513 int flush_dev(DEVICE *dev)
1514 {
1515    return 1;
1516 }
1517
1518 static void do_close(DEVICE *dev)
1519 {
1520
1521    Dmsg1(29, "really close_dev %s\n", dev->print_name());
1522    if (dev->fd >= 0) {
1523       close(dev->fd);
1524    }
1525
1526    if (unmount_dev(dev, 1) < 0) {
1527       Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1528    }
1529
1530    /* Remove the last part file if it is empty */
1531    if (dev->can_append() && (dev->num_parts > 0)) {
1532       struct stat statp;
1533       POOL_MEM archive_name(PM_FNAME);
1534       dev->part = dev->num_parts;
1535       get_filename(dev, dev->VolCatInfo.VolCatName, archive_name);
1536       /* Check that the part file is empty */
1537       if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1538          unlink(archive_name.c_str());
1539       }
1540    }
1541
1542    /* Clean up device packet so it can be reused */
1543    dev->fd = -1;
1544    dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1545    dev->label_type = B_BACULA_LABEL;
1546    dev->file = dev->block_num = 0;
1547    dev->file_size = 0;
1548    dev->file_addr = 0;
1549    dev->part = 0;
1550    dev->part_size = 0;
1551    dev->part_start = 0;
1552    dev->EndFile = dev->EndBlock = 0;
1553    memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1554    memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1555    if (dev->tid) {
1556       stop_thread_timer(dev->tid);
1557       dev->tid = 0;
1558    }
1559    dev->use_count = 0;
1560    dev->openmode = 0;
1561 }
1562
1563 /*
1564  * Close the device
1565  */
1566 void DEVICE::close()
1567 {
1568    /*if (fd >= 0 && use_count == 1) {*/
1569    /* No need to check if fd >= 0: it is checked again
1570     * in do_close, and do_close MUST be called for volumes
1571     * splitted in parts, even if fd == -1. */
1572    if (use_count == 1) {
1573       do_close(this);
1574    } else if (use_count > 0) {
1575       use_count--;
1576    }
1577
1578 #ifdef FULL_DEBUG
1579    ASSERT(use_count >= 0);
1580 #endif
1581 }
1582
1583
1584 bool truncate_dev(DEVICE *dev)
1585 {
1586    Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1587    if (dev->is_tape()) {
1588       return true;                    /* we don't really truncate tapes */
1589       /* maybe we should rewind and write and eof ???? */
1590    }
1591
1592    /* If there is more than one part, open the first one, and then truncate it. */
1593    if (dev->num_parts > 0) {
1594       dev->num_parts = 0;
1595       dev->VolCatInfo.VolCatParts = 0;
1596       if (open_first_part(dev, OPEN_READ_WRITE) < 0) {
1597          berrno be;
1598          Mmsg1(dev->errmsg, "Unable to truncate device, because I'm unable to open the first part. ERR=%s\n", be.strerror());
1599       }
1600    }
1601
1602    if (ftruncate(dev->fd, 0) != 0) {
1603       berrno be;
1604       Mmsg1(dev->errmsg, _("Unable to truncate device. ERR=%s\n"), be.strerror());
1605       return false;
1606    }
1607    return true;
1608 }
1609
1610 /* Return the resource name for the device */
1611 const char *DEVICE::name() const
1612 {
1613    return device->hdr.name;
1614 }
1615
1616 char *
1617 dev_vol_name(DEVICE *dev)
1618 {
1619    return dev->VolCatInfo.VolCatName;
1620 }
1621
1622 uint32_t dev_block(DEVICE *dev)
1623 {
1624    update_pos_dev(dev);
1625    return dev->block_num;
1626 }
1627
1628 uint32_t dev_file(DEVICE *dev)
1629 {
1630    update_pos_dev(dev);
1631    return dev->file;
1632 }
1633
1634 /*
1635  * Free memory allocated for the device
1636  */
1637 void
1638 term_dev(DEVICE *dev)
1639 {
1640    if (!dev) {
1641       dev->dev_errno = EBADF;
1642       Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1643       Emsg0(M_FATAL, 0, dev->errmsg);
1644       return;
1645    }
1646    do_close(dev);
1647    Dmsg0(29, "term_dev\n");
1648    if (dev->dev_name) {
1649       free_memory(dev->dev_name);
1650       dev->dev_name = NULL;
1651    }
1652    if (dev->prt_name) {
1653       free_memory(dev->prt_name);
1654       dev->prt_name = NULL;
1655    }
1656    if (dev->errmsg) {
1657       free_pool_memory(dev->errmsg);
1658       dev->errmsg = NULL;
1659    }
1660    pthread_mutex_destroy(&dev->mutex);
1661    pthread_cond_destroy(&dev->wait);
1662    pthread_cond_destroy(&dev->wait_next_vol);
1663    pthread_mutex_destroy(&dev->spool_mutex);
1664    rwl_destroy(&dev->lock);
1665    if (dev->attached_dcrs) {
1666       delete dev->attached_dcrs;
1667       dev->attached_dcrs = NULL;
1668    }
1669    if (dev->state & ST_MALLOC) {
1670       free_pool_memory((POOLMEM *)dev);
1671    }
1672 }
1673
1674 /*
1675  * This routine initializes the device wait timers
1676  */
1677 void init_device_wait_timers(DCR *dcr)
1678 {
1679    DEVICE *dev = dcr->dev;
1680    JCR *jcr = dcr->jcr;
1681
1682    /* ******FIXME******* put these on config variables */
1683    dev->min_wait = 60 * 60;
1684    dev->max_wait = 24 * 60 * 60;
1685    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
1686    dev->wait_sec = dev->min_wait;
1687    dev->rem_wait_sec = dev->wait_sec;
1688    dev->num_wait = 0;
1689    dev->poll = false;
1690    dev->BadVolName[0] = 0;
1691
1692    jcr->min_wait = 60 * 60;
1693    jcr->max_wait = 24 * 60 * 60;
1694    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
1695    jcr->wait_sec = jcr->min_wait;
1696    jcr->rem_wait_sec = jcr->wait_sec;
1697    jcr->num_wait = 0;
1698
1699 }
1700
1701 void init_jcr_device_wait_timers(JCR *jcr)
1702 {
1703    /* ******FIXME******* put these on config variables */
1704    jcr->min_wait = 60 * 60;
1705    jcr->max_wait = 24 * 60 * 60;
1706    jcr->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
1707    jcr->wait_sec = jcr->min_wait;
1708    jcr->rem_wait_sec = jcr->wait_sec;
1709    jcr->num_wait = 0;
1710 }
1711
1712
1713 /*
1714  * The dev timers are used for waiting on a particular device
1715  *
1716  * Returns: true if time doubled
1717  *          false if max time expired
1718  */
1719 bool double_dev_wait_time(DEVICE *dev)
1720 {
1721    dev->wait_sec *= 2;               /* double wait time */
1722    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
1723       dev->wait_sec = dev->max_wait;
1724    }
1725    dev->num_wait++;
1726    dev->rem_wait_sec = dev->wait_sec;
1727    if (dev->num_wait >= dev->max_num_wait) {
1728       return false;
1729    }
1730    return true;
1731 }
1732
1733
1734 void set_os_device_parameters(DEVICE *dev)
1735 {
1736 #ifdef HAVE_LINUX_OS
1737    struct mtop mt_com;
1738    if (dev->min_block_size == dev->max_block_size &&
1739        dev->min_block_size == 0) {    /* variable block mode */
1740       mt_com.mt_op = MTSETBLK;
1741       mt_com.mt_count = 0;
1742       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1743          clrerror_dev(dev, MTSETBLK);
1744       }
1745       mt_com.mt_op = MTSETDRVBUFFER;
1746       mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1747       if (!dev_cap(dev, CAP_TWOEOF)) {
1748          mt_com.mt_count |= MT_ST_TWO_FM;
1749       }
1750       if (dev_cap(dev, CAP_EOM)) {
1751          mt_com.mt_count |= MT_ST_FAST_MTEOM;
1752       }
1753       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1754          clrerror_dev(dev, MTSETBLK);
1755       }
1756    }
1757    return;
1758 #endif
1759
1760 #ifdef HAVE_NETBSD_OS
1761    struct mtop mt_com;
1762    if (dev->min_block_size == dev->max_block_size &&
1763        dev->min_block_size == 0) {    /* variable block mode */
1764       mt_com.mt_op = MTSETBSIZ;
1765       mt_com.mt_count = 0;
1766       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1767          clrerror_dev(dev, MTSETBSIZ);
1768       }
1769       /* Get notified at logical end of tape */
1770       mt_com.mt_op = MTEWARN;
1771       mt_com.mt_count = 1;
1772       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1773          clrerror_dev(dev, MTEWARN);
1774       }
1775    }
1776    return;
1777 #endif
1778
1779 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1780    struct mtop mt_com;
1781    if (dev->min_block_size == dev->max_block_size &&
1782        dev->min_block_size == 0) {    /* variable block mode */
1783       mt_com.mt_op = MTSETBSIZ;
1784       mt_com.mt_count = 0;
1785       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1786          clrerror_dev(dev, MTSETBSIZ);
1787       }
1788    }
1789    return;
1790 #endif
1791
1792 #ifdef HAVE_SUN_OS
1793    struct mtop mt_com;
1794    if (dev->min_block_size == dev->max_block_size &&
1795        dev->min_block_size == 0) {    /* variable block mode */
1796       mt_com.mt_op = MTSRSZ;
1797       mt_com.mt_count = 0;
1798       if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1799          clrerror_dev(dev, MTSRSZ);
1800       }
1801    }
1802    return;
1803 #endif
1804 }
1805
1806 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1807 {
1808    return dev_cap(dev, CAP_MTIOCGET) &&
1809           ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1810           mt_stat->mt_fileno >= 0;
1811 }