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-2004 Kern Sibbald and John Walker
  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 as
  36    published by the Free Software Foundation; either version 2 of
  37    the License, or (at your option) any later version.
  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 GNU
  42    General Public License for more details.
  43
  44    You should have received a copy of the GNU General Public
  45    License along with this program; if not, write to the Free
  46    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  47    MA 02111-1307, USA.
  48
  49  */
  50
  51 /*
  52  * Handling I/O errors and end of tape conditions are a bit tricky.
  53  * This is how it is currently done when writting.
  54  * On either an I/O error or end of tape,
  55  * we will stop writing on the physical device (no I/O recovery is
  56  * attempted at least in this daemon). The state flag will be sent
  57  * to include ST_EOT, which is ephimeral, and ST_WEOT, which is
  58  * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
  59  * cleared only when the problem goes away.  Now when ST_WEOT
  60  * is set all calls to write_block_to_device() call the fix_up
  61  * routine. In addition, all threads are blocked
  62  * from writing on the tape by calling lock_dev(), and thread other
  63  * than the first thread to hit the EOT will block on a condition
  64  * variable. The first thread to hit the EOT will continue to
  65  * be able to read and write the tape (he sort of tunnels through
  66  * the locking mechanism -- see lock_dev() for details).
  67  *
  68  * Now presumably somewhere higher in the chain of command
  69  * (device.c), someone will notice the EOT condition and
  70  * get a new tape up, get the tape label read, and mark
  71  * the label for rewriting. Then this higher level routine
  72  * will write the unwritten buffer to the new volume.
  73  * Finally, he will release
  74  * any blocked threads by doing a broadcast on the condition
  75  * variable.  At that point, we should be totally back in
  76  * business with no lost data.
  77  */
  78
  79
  80 #include "bacula.h"
  81 #include "stored.h"
  82
  83 /* Forward referenced functions */
  84
  85 /*
  86  * Allocate and initialize the DEVICE structure
  87  * Note, if dev is non-NULL, it is already allocated,
  88  * thus we neither allocate it nor free it. This allows
  89  * the caller to put the packet in shared memory.
  90  *
  91  *  Note, for a tape, the device->device_name is the device name
  92  *     (e.g. /dev/nst0), and for a file, the device name
  93  *     is the directory in which the file will be placed.
  94  *
  95  */
  96 DEVICE *
  97 init_dev(DEVICE *dev, DEVRES *device)
  98 {
  99    struct stat statp;
 100    bool tape, fifo;
 101    int errstat;
 102    DCR *dcr = NULL;
 103
 104    /* Check that device is available */
 105    if (stat(device->device_name, &statp) < 0) {
 106       berrno be;
 107       if (dev) {
 108          dev->dev_errno = errno;
 109       }
 110       Emsg2(M_FATAL, 0, "Unable to stat device %s : %s\n", device->device_name,
 111             be.strerror());
 112       return NULL;
 113    }
 114    tape = false;
 115    fifo = false;
 116    if (S_ISDIR(statp.st_mode)) {
 117       tape = false;
 118    } else if (S_ISCHR(statp.st_mode)) {
 119       tape = true;
 120    } else if (S_ISFIFO(statp.st_mode)) {
 121       fifo = true;
 122    } else {
 123       if (dev) {
 124          dev->dev_errno = ENODEV;
 125       }
 126       Emsg2(M_FATAL, 0, _("%s is an unknown device type. Must be tape or directory. st_mode=%x\n"),
 127          device->device_name, statp.st_mode);
 128       return NULL;
 129    }
 130    if (!dev) {
 131       dev = (DEVICE *)get_memory(sizeof(DEVICE));
 132       memset(dev, 0, sizeof(DEVICE));
 133       dev->state = ST_MALLOC;
 134    } else {
 135       memset(dev, 0, sizeof(DEVICE));
 136    }
 137
 138    /* Copy user supplied device parameters from Resource */
 139    dev->dev_name = get_memory(strlen(device->device_name)+1);
 140    strcpy(dev->dev_name, device->device_name);
 141    dev->capabilities = device->cap_bits;
 142    dev->min_block_size = device->min_block_size;
 143    dev->max_block_size = device->max_block_size;
 144    dev->max_volume_size = device->max_volume_size;
 145    dev->max_file_size = device->max_file_size;
 146    dev->volume_capacity = device->volume_capacity;
 147    dev->max_rewind_wait = device->max_rewind_wait;
 148    dev->max_open_wait = device->max_open_wait;
 149    dev->max_open_vols = device->max_open_vols;
 150    dev->vol_poll_interval = device->vol_poll_interval;
 151    dev->max_spool_size = device->max_spool_size;
 152    dev->drive_index = device->drive_index;
 153    /* Sanity check */
 154    if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
 155       dev->vol_poll_interval = 60;
 156    }
 157    dev->device = device;
 158
 159    if (tape) {
 160       dev->state |= ST_TAPE;
 161    } else if (fifo) {
 162       dev->state |= ST_FIFO;
 163       dev->capabilities |= CAP_STREAM; /* set stream device */
 164    } else {
 165       dev->state |= ST_FILE;
 166    }
 167
 168    if (dev->max_block_size > 1000000) {
 169       Emsg3(M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
 170          dev->max_block_size, dev->dev_name, DEFAULT_BLOCK_SIZE);
 171       dev->max_block_size = 0;
 172    }
 173    if (dev->max_block_size % TAPE_BSIZE != 0) {
 174       Emsg2(M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
 175          dev->max_block_size, dev->dev_name);
 176    }
 177
 178    dev->errmsg = get_pool_memory(PM_EMSG);
 179    *dev->errmsg = 0;
 180
 181    if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
 182       berrno be;
 183       dev->dev_errno = errstat;
 184       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 185       Emsg0(M_FATAL, 0, dev->errmsg);
 186    }
 187    if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
 188       berrno be;
 189       dev->dev_errno = errstat;
 190       Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
 191       Emsg0(M_FATAL, 0, dev->errmsg);
 192    }
 193    if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
 194       berrno be;
 195       dev->dev_errno = errstat;
 196       Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
 197       Emsg0(M_FATAL, 0, dev->errmsg);
 198    }
 199    if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
 200       berrno be;
 201       dev->dev_errno = errstat;
 202       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 203       Emsg0(M_FATAL, 0, dev->errmsg);
 204    }
 205    if ((errstat = rwl_init(&dev->lock)) != 0) {
 206       berrno be;
 207       dev->dev_errno = errstat;
 208       Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
 209       Emsg0(M_FATAL, 0, dev->errmsg);
 210    }
 211
 212    dev->fd = -1;
 213    dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
 214    Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev_is_tape(dev), dev->dev_name);
 215
 216    return dev;
 217 }
 218
 219 /* Open the device with the operating system and
 220  * initialize buffer pointers.
 221  *
 222  * Note, for a tape, the VolName is the name we give to the
 223  *    volume (not really used here), but for a file, the
 224  *    VolName represents the name of the file to be created/opened.
 225  *    In the case of a file, the full name is the device name
 226  *    (archive_name) with the VolName concatenated.
 227  */
 228 int
 229 open_dev(DEVICE *dev, char *VolName, int mode)
 230 {
 231    POOLMEM *archive_name;
 232
 233    if (dev->state & ST_OPENED) {
 234       /*
 235        *  *****FIXME***** how to handle two threads wanting
 236        *  different volumes mounted???? E.g. one is waiting
 237        *  for the next volume to be mounted, and a new job
 238        *  starts and snatches up the device.
 239        */
 240       if (VolName && strcmp(dev->VolCatInfo.VolCatName, VolName) != 0) {
 241          return -1;
 242       }
 243       dev->use_count++;
 244       Mmsg2(&dev->errmsg, _("WARNING!!!! device %s opened %d times!!!\n"),
 245             dev->dev_name, dev->use_count);
 246       Emsg1(M_WARNING, 0, "%s", dev->errmsg);
 247       return dev->fd;
 248    }
 249    if (VolName) {
 250       bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
 251    }
 252
 253    Dmsg3(29, "open_dev: tape=%d dev_name=%s vol=%s\n", dev_is_tape(dev),
 254          dev->dev_name, dev->VolCatInfo.VolCatName);
 255    dev->state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
 256    if (dev->state & (ST_TAPE|ST_FIFO)) {
 257       int timeout;
 258       Dmsg0(29, "open_dev: device is tape\n");
 259       if (mode == OPEN_READ_WRITE) {
 260          dev->mode = O_RDWR | O_BINARY;
 261       } else if (mode == OPEN_READ_ONLY) {
 262          dev->mode = O_RDONLY | O_BINARY;
 263       } else if (mode == OPEN_WRITE_ONLY) {
 264          dev->mode = O_WRONLY | O_BINARY;
 265       } else {
 266          Emsg0(M_ABORT, 0, _("Illegal mode given to open_dev.\n"));
 267       }
 268       timeout = dev->max_open_wait;
 269       errno = 0;
 270       if (dev->state & ST_FIFO && timeout) {
 271          /* Set open timer */
 272          dev->tid = start_thread_timer(pthread_self(), timeout);
 273       }
 274       /* If busy retry each second for max_open_wait seconds */
 275       while ((dev->fd = open(dev->dev_name, dev->mode, MODE_RW)) < 0) {
 276          if (errno == EINTR || errno == EAGAIN) {
 277             continue;
 278          }
 279          if (errno == EBUSY && timeout-- > 0) {
 280             Dmsg2(100, "Device %s busy. ERR=%s\n", dev->dev_name, strerror(errno));
 281             bmicrosleep(1, 0);
 282             continue;
 283          }
 284          dev->dev_errno = errno;
 285          Mmsg2(&dev->errmsg, _("stored: unable to open device %s: ERR=%s\n"),
 286                dev->dev_name, strerror(dev->dev_errno));
 287          /* Stop any open timer we set */
 288          if (dev->tid) {
 289             stop_thread_timer(dev->tid);
 290             dev->tid = 0;
 291          }
 292          Emsg0(M_FATAL, 0, dev->errmsg);
 293          break;
 294       }
 295       if (dev->fd >= 0) {
 296          dev->dev_errno = 0;
 297          dev->state |= ST_OPENED;
 298          dev->use_count = 1;
 299          update_pos_dev(dev);             /* update position */
 300       }
 301       /* Stop any open() timer we started */
 302       if (dev->tid) {
 303          stop_thread_timer(dev->tid);
 304          dev->tid = 0;
 305       }
 306       Dmsg1(29, "open_dev: tape %d opened\n", dev->fd);
 307    } else {
 308       /*
 309        * Handle opening of File Archive (not a tape)
 310        */
 311       if (VolName == NULL || *VolName == 0) {
 312          Mmsg(dev->errmsg, _("Could not open file device %s. No Volume name given.\n"),
 313             dev->dev_name);
 314          return -1;
 315       }
 316       archive_name = get_pool_memory(PM_FNAME);
 317       pm_strcpy(&archive_name, dev->dev_name);
 318       if (archive_name[strlen(archive_name)] != '/') {
 319          pm_strcat(&archive_name, "/");
 320       }
 321       pm_strcat(&archive_name, VolName);
 322       Dmsg1(29, "open_dev: device is disk %s\n", archive_name);
 323       if (mode == OPEN_READ_WRITE) {
 324          dev->mode = O_CREAT | O_RDWR | O_BINARY;
 325       } else if (mode == OPEN_READ_ONLY) {
 326          dev->mode = O_RDONLY | O_BINARY;
 327       } else if (mode == OPEN_WRITE_ONLY) {
 328          dev->mode = O_WRONLY | O_BINARY;
 329       } else {
 330          Emsg0(M_ABORT, 0, _("Illegal mode given to open_dev.\n"));
 331       }
 332       /* If creating file, give 0640 permissions */
 333       if ((dev->fd = open(archive_name, dev->mode, 0640)) < 0) {
 334          dev->dev_errno = errno;
 335          Mmsg2(&dev->errmsg, _("Could not open: %s, ERR=%s\n"), archive_name, strerror(dev->dev_errno));
 336          Emsg0(M_FATAL, 0, dev->errmsg);
 337       } else {
 338          dev->dev_errno = 0;
 339          dev->state |= ST_OPENED;
 340          dev->use_count = 1;
 341          update_pos_dev(dev);                /* update position */
 342       }
 343       Dmsg1(29, "open_dev: disk fd=%d opened\n", dev->fd);
 344       free_pool_memory(archive_name);
 345    }
 346    return dev->fd;
 347 }
 348
 349 #ifdef debug_tracing
 350 #undef rewind_dev
 351 int _rewind_dev(char *file, int line, DEVICE *dev)
 352 {
 353    Dmsg2(100, "rewind_dev called from %s:%d\n", file, line);
 354    return rewind_dev(dev);
 355 }
 356 #endif
 357
 358
 359 /*
 360  * Rewind the device.
 361  *  Returns: 1 on success
 362  *           0 on failure
 363  */
 364 int rewind_dev(DEVICE *dev)
 365 {
 366    struct mtop mt_com;
 367    unsigned int i;
 368
 369    Dmsg1(29, "rewind_dev %s\n", dev->dev_name);
 370    if (dev->fd < 0) {
 371       dev->dev_errno = EBADF;
 372       Mmsg1(&dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
 373             dev->dev_name);
 374       Emsg0(M_FATAL, 0, dev->errmsg);
 375       return 0;
 376    }
 377    dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
 378    dev->block_num = dev->file = 0;
 379    dev->file_addr = 0;
 380    if (dev->state & ST_TAPE) {
 381       mt_com.mt_op = MTREW;
 382       mt_com.mt_count = 1;
 383       /* If we get an I/O error on rewind, it is probably because
 384        * the drive is actually busy. We loop for (about 5 minutes)
 385        * retrying every 5 seconds.
 386        */
 387       for (i=dev->max_rewind_wait; ; i -= 5) {
 388          if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
 389             if (i == dev->max_rewind_wait) {
 390                Dmsg1(200, "Rewind error, %s. retrying ...\n", strerror(errno));
 391             }
 392             clrerror_dev(dev, MTREW);
 393             if (dev->dev_errno == EIO && i > 0) {
 394                Dmsg0(200, "Sleeping 5 seconds.\n");
 395                bmicrosleep(5, 0);
 396                continue;
 397             }
 398             Mmsg2(&dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
 399                dev->dev_name, strerror(dev->dev_errno));
 400             return 0;
 401          }
 402          break;
 403       }
 404    } else if (dev->state & ST_FILE) {
 405       if (lseek(dev->fd, (off_t)0, SEEK_SET) < 0) {
 406          dev->dev_errno = errno;
 407          Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
 408             dev->dev_name, strerror(dev->dev_errno));
 409          return 0;
 410       }
 411    }
 412    return 1;
 413 }
 414
 415 /*
 416  * Position device to end of medium (end of data)
 417  *  Returns: 1 on succes
 418  *           0 on error
 419  */
 420 int
 421 eod_dev(DEVICE *dev)
 422 {
 423    struct mtop mt_com;
 424    struct mtget mt_stat;
 425    int stat = 0;
 426    off_t pos;
 427
 428    Dmsg0(29, "eod_dev\n");
 429    if (dev->state & ST_EOT) {
 430       return 1;
 431    }
 432    dev->state &= ~(ST_EOF);  /* remove EOF flags */
 433    dev->block_num = dev->file = 0;
 434    dev->file_addr = 0;
 435    if (dev->state & (ST_FIFO | ST_PROG)) {
 436       return 1;
 437    }
 438    if (!(dev->state & ST_TAPE)) {
 439       pos = lseek(dev->fd, (off_t)0, SEEK_END);
 440 //    Dmsg1(100, "====== Seek to %lld\n", pos);
 441       if (pos >= 0) {
 442          update_pos_dev(dev);
 443          dev->state |= ST_EOT;
 444          return 1;
 445       }
 446       dev->dev_errno = errno;
 447       Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
 448              dev->dev_name, strerror(dev->dev_errno));
 449       return 0;
 450    }
 451 #ifdef MTEOM
 452
 453    if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
 454       struct mtget mt_stat;
 455       Dmsg0(100,"Using FAST FSF for EOM\n");
 456       if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) == 0 && mt_stat.mt_fileno <= 0) {
 457         if (!rewind_dev(dev)) {
 458           return 0;
 459         }
 460       }
 461       mt_com.mt_op = MTFSF;
 462       /*
 463        * ***FIXEM*** fix code to handle case that INT16_MAX is
 464        *   not large enough.
 465        */
 466       mt_com.mt_count = INT16_MAX;    /* use big positive number */
 467       if (mt_com.mt_count < 0) {
 468          mt_com.mt_count = INT16_MAX; /* brain damaged system */
 469       }
 470    }
 471
 472    if (dev_cap(dev, CAP_EOM)) {
 473       Dmsg0(100,"Using EOM for EOM\n");
 474       mt_com.mt_op = MTEOM;
 475       mt_com.mt_count = 1;
 476    }
 477    if (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM)) {
 478       if ((stat=ioctl(dev->fd, MTIOCTOP, (char *)&mt_com)) < 0) {
 479          Dmsg1(50, "ioctl error: %s\n", strerror(dev->dev_errno));
 480          clrerror_dev(dev, mt_com.mt_op);
 481          update_pos_dev(dev);
 482          Mmsg2(&dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
 483             dev->dev_name, strerror(dev->dev_errno));
 484          return 0;
 485       }
 486
 487       if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
 488          dev->dev_errno = errno;
 489          Mmsg2(&dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
 490             dev->dev_name, strerror(dev->dev_errno));
 491          return 0;
 492       }
 493       Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
 494       dev->file = mt_stat.mt_fileno;
 495
 496    /*
 497     * Rewind then use FSF until EOT reached
 498     */
 499    } else {
 500 #else
 501    {
 502 #endif
 503       if (!rewind_dev(dev)) {
 504          return 0;
 505       }
 506       /*
 507        * Move file by file to the end of the tape
 508        */
 509       int file_num;
 510       for (file_num=dev->file; !(dev->state & ST_EOT); file_num++) {
 511          Dmsg0(200, "eod_dev: doing fsf 1\n");
 512          if (!fsf_dev(dev, 1)) {
 513             Dmsg0(200, "fsf_dev error.\n");
 514             return 0;
 515          }
 516          /*
 517           * Avoid infinite loop. ***FIXME*** possibly add code
 518           *   to set EOD or to turn off CAP_FASTFSF if on.
 519           */
 520          if (file_num == (int)dev->file) {
 521             struct mtget mt_stat;
 522             Dmsg1(100, "fsf_dev did not advance from file %d\n", file_num);
 523             if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) == 0 &&
 524                       mt_stat.mt_fileno >= 0) {
 525                Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
 526                dev->file = mt_stat.mt_fileno;
 527             }
 528             stat = 0;
 529             break;                    /* we are not progressing, bail out */
 530          }
 531       }
 532    }
 533    /*
 534     * Some drivers leave us after second EOF when doing
 535     * MTEOM, so we must backup so that appending overwrites
 536     * the second EOF.
 537     */
 538    if (dev_cap(dev, CAP_BSFATEOM)) {
 539       struct mtget mt_stat;
 540       /* Backup over EOF */
 541       stat = bsf_dev(dev, 1);
 542       /* If BSF worked and fileno is known (not -1), set file */
 543       if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) == 0 && mt_stat.mt_fileno >= 0) {
 544          Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
 545          dev->file = mt_stat.mt_fileno;
 546       } else {
 547          dev->file++;                 /* wing it -- not correct on all OSes */
 548       }
 549    } else {
 550       update_pos_dev(dev);                   /* update position */
 551       stat = 1;
 552    }
 553    Dmsg1(200, "EOD dev->file=%d\n", dev->file);
 554    return stat;
 555 }
 556
 557 /*
 558  * Set the position of the device -- only for files
 559  *   For other devices, there is no generic way to do it.
 560  *  Returns: true  on succes
 561  *           false on error
 562  */
 563 bool update_pos_dev(DEVICE *dev)
 564 {
 565    off_t pos;
 566    bool ok = true;
 567
 568    if (dev->fd < 0) {
 569       dev->dev_errno = EBADF;
 570       Mmsg0(&dev->errmsg, _("Bad device call. Archive not open\n"));
 571       Emsg0(M_FATAL, 0, dev->errmsg);
 572       return false;
 573    }
 574
 575    /* Find out where we are */
 576    if (dev->state & ST_FILE) {
 577       dev->file = 0;
 578       dev->file_addr = 0;
 579       pos = lseek(dev->fd, (off_t)0, SEEK_CUR);
 580       if (pos < 0) {
 581          Pmsg1(000, "Seek error: ERR=%s\n", strerror(dev->dev_errno));
 582          dev->dev_errno = errno;
 583          Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
 584             dev->dev_name, strerror(dev->dev_errno));
 585          ok = false;
 586       } else {
 587          dev->file_addr = pos;
 588       }
 589    }
 590    return ok;
 591 }
 592
 593
 594 /*
 595  * Return the status of the device.  This was meant
 596  * to be a generic routine. Unfortunately, it doesn't
 597  * seem possible (at least I do not know how to do it
 598  * currently), which means that for the moment, this
 599  * routine has very little value.
 600  *
 601  *   Returns: status
 602  */
 603 uint32_t status_dev(DEVICE *dev)
 604 {
 605    struct mtget mt_stat;
 606    uint32_t stat = 0;
 607
 608    if (dev->state & (ST_EOT | ST_WEOT)) {
 609       stat |= BMT_EOD;
 610       Dmsg0(-20, " EOD");
 611    }
 612    if (dev->state & ST_EOF) {
 613       stat |= BMT_EOF;
 614       Dmsg0(-20, " EOF");
 615    }
 616    if (dev->state & ST_TAPE) {
 617       stat |= BMT_TAPE;
 618       Dmsg0(-20," Bacula status:");
 619       Dmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
 620       if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
 621          dev->dev_errno = errno;
 622          Mmsg2(&dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
 623             dev->dev_name, strerror(dev->dev_errno));
 624          return 0;
 625       }
 626       Dmsg0(-20, " Device status:");
 627
 628 #if defined(HAVE_LINUX_OS)
 629       if (GMT_EOF(mt_stat.mt_gstat)) {
 630          stat |= BMT_EOF;
 631          Dmsg0(-20, " EOF");
 632       }
 633       if (GMT_BOT(mt_stat.mt_gstat)) {
 634          stat |= BMT_BOT;
 635          Dmsg0(-20, " BOT");
 636       }
 637       if (GMT_EOT(mt_stat.mt_gstat)) {
 638          stat |= BMT_EOT;
 639          Dmsg0(-20, " EOT");
 640       }
 641       if (GMT_SM(mt_stat.mt_gstat)) {
 642          stat |= BMT_SM;
 643          Dmsg0(-20, " SM");
 644       }
 645       if (GMT_EOD(mt_stat.mt_gstat)) {
 646          stat |= BMT_EOD;
 647          Dmsg0(-20, " EOD");
 648       }
 649       if (GMT_WR_PROT(mt_stat.mt_gstat)) {
 650          stat |= BMT_WR_PROT;
 651          Dmsg0(-20, " WR_PROT");
 652       }
 653       if (GMT_ONLINE(mt_stat.mt_gstat)) {
 654          stat |= BMT_ONLINE;
 655          Dmsg0(-20, " ONLINE");
 656       }
 657       if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
 658          stat |= BMT_DR_OPEN;
 659          Dmsg0(-20, " DR_OPEN");
 660       }
 661       if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
 662          stat |= BMT_IM_REP_EN;
 663          Dmsg0(-20, " IM_REP_EN");
 664       }
 665 #endif /* !SunOS && !OSF */
 666       Dmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
 667    } else {
 668       stat |= BMT_ONLINE | BMT_BOT;
 669    }
 670    return stat;
 671 }
 672
 673
 674 /*
 675  * Load medium in device
 676  *  Returns: true  on success
 677  *           false on failure
 678  */
 679 bool load_dev(DEVICE *dev)
 680 {
 681 #ifdef MTLOAD
 682    struct mtop mt_com;
 683 #endif
 684
 685    if (dev->fd < 0) {
 686       dev->dev_errno = EBADF;
 687       Mmsg0(&dev->errmsg, _("Bad call to load_dev. Archive not open\n"));
 688       Emsg0(M_FATAL, 0, dev->errmsg);
 689       return false;
 690    }
 691    if (!(dev->state & ST_TAPE)) {
 692       return true;
 693    }
 694 #ifndef MTLOAD
 695    Dmsg0(200, "stored: MTLOAD command not available\n");
 696    dev->dev_errno = ENOTTY;           /* function not available */
 697    Mmsg2(&dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
 698          dev->dev_name, strerror(dev->dev_errno));      return 0;
 699    return false;
 700 #else
 701
 702    dev->block_num = dev->file = 0;
 703    dev->file_addr = 0;
 704    mt_com.mt_op = MTLOAD;
 705    mt_com.mt_count = 1;
 706    if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
 707       dev->dev_errno = errno;
 708       Mmsg2(&dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
 709          dev->dev_name, strerror(dev->dev_errno));      return 0;
 710       return false;
 711    }
 712    return true;
 713 #endif
 714 }
 715
 716 /*
 717  * Rewind device and put it offline
 718  *  Returns: true  on success
 719  *           false on failure
 720  */
 721 bool offline_dev(DEVICE *dev)
 722 {
 723    struct mtop mt_com;
 724
 725    if (dev->fd < 0) {
 726       dev->dev_errno = EBADF;
 727       Mmsg0(&dev->errmsg, _("Bad call to offline_dev. Archive not open\n"));
 728       Emsg0(M_FATAL, 0, dev->errmsg);
 729       return false;
 730    }
 731    if (!(dev->state & ST_TAPE)) {
 732       return true;
 733    }
 734
 735    dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT);  /* remove EOF/EOT flags */
 736    dev->block_num = dev->file = 0;
 737    dev->file_addr = 0;
 738 #ifdef MTUNLOCK
 739    mt_com.mt_op = MTUNLOCK;
 740    mt_com.mt_count = 1;
 741    ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
 742 #endif
 743    mt_com.mt_op = MTOFFL;
 744    mt_com.mt_count = 1;
 745    if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
 746       dev->dev_errno = errno;
 747       Mmsg2(&dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
 748          dev->dev_name, strerror(dev->dev_errno));
 749       return false;
 750    }
 751    Dmsg1(100, "Offlined device %s\n", dev->dev_name);
 752    return true;
 753 }
 754
 755 int offline_or_rewind_dev(DEVICE *dev)
 756 {
 757    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
 758       return offline_dev(dev);
 759    } else {
 760    /*
 761     * Note, this rewind probably should not be here (it wasn't
 762     *  in prior versions of Bacula), but on FreeBSD, this is
 763     *  needed in the case the tape was "frozen" due to an error
 764     *  such as backspacing after writing and EOF. If it is not
 765     *  done, all future references to the drive get and I/O error.
 766     */
 767       return rewind_dev(dev);
 768    }
 769 }
 770
 771 /*
 772  * Foward space a file
 773  *   Returns: true  on success
 774  *            false on failure
 775  */
 776 bool
 777 fsf_dev(DEVICE *dev, int num)
 778 {
 779    struct mtget mt_stat;
 780    struct mtop mt_com;
 781    int stat = 0;
 782
 783    if (dev->fd < 0) {
 784       dev->dev_errno = EBADF;
 785       Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
 786       Emsg0(M_FATAL, 0, dev->errmsg);
 787       return false;
 788    }
 789
 790    if (!(dev->state & ST_TAPE)) {
 791       return true;
 792    }
 793    if (dev->state & ST_EOT) {
 794       dev->dev_errno = 0;
 795       Mmsg1(dev->errmsg, _("Device %s at End of Tape.\n"), dev->dev_name);
 796       return false;
 797    }
 798    if (dev->state & ST_EOF) {
 799       Dmsg0(200, "ST_EOF set on entry to FSF\n");
 800    }
 801
 802    Dmsg0(29, "fsf_dev\n");
 803    dev->block_num = 0;
 804    /*
 805     * If Fast forward space file is set, then we
 806     *  use MTFSF to forward space and MTIOCGET
 807     *  to get the file position. We assume that
 808     *  the SCSI driver will ensure that we do not
 809     *  forward space over the end of data mark.
 810     */
 811    if (dev_cap(dev, CAP_FSF) && dev_cap(dev, CAP_FASTFSF)) {
 812       mt_com.mt_op = MTFSF;
 813       mt_com.mt_count = num;
 814       stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
 815       if (stat < 0 || ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
 816          berrno be;
 817          dev->state |= ST_EOT;
 818          Dmsg0(200, "Set ST_EOT\n");
 819          clrerror_dev(dev, MTFSF);
 820          Mmsg2(dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
 821             dev->dev_name, be.strerror());
 822          Dmsg1(200, "%s", dev->errmsg);
 823          return false;
 824       }
 825       Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
 826       dev->file = mt_stat.mt_fileno;
 827       dev->state |= ST_EOF;     /* just read EOF */
 828       dev->file_addr = 0;
 829       return true;
 830
 831    /*
 832     * Here if CAP_FSF is set, and virtually all drives
 833     *  these days support it, we read a record, then forward
 834     *  space one file. Using this procedure, which is slow,
 835     *  is the only way we can be sure that we don't read
 836     *  two consecutive EOF marks, which means End of Data.
 837     */
 838    } else if (dev_cap(dev, CAP_FSF)) {
 839       POOLMEM *rbuf;
 840       int rbuf_len;
 841       Dmsg0(200, "FSF has cap_fsf\n");
 842       if (dev->max_block_size == 0) {
 843          rbuf_len = DEFAULT_BLOCK_SIZE;
 844       } else {
 845          rbuf_len = dev->max_block_size;
 846       }
 847       rbuf = get_memory(rbuf_len);
 848       mt_com.mt_op = MTFSF;
 849       mt_com.mt_count = 1;
 850       while (num-- && !(dev->state & ST_EOT)) {
 851          Dmsg0(200, "Doing read before fsf\n");
 852          if ((stat = read(dev->fd, (char *)rbuf, rbuf_len)) < 0) {
 853             if (errno == ENOMEM) {     /* tape record exceeds buf len */
 854                stat = rbuf_len;        /* This is OK */
 855             } else {
 856                berrno be;
 857                dev->state |= ST_EOT;
 858                clrerror_dev(dev, -1);
 859                Dmsg2(200, "Set ST_EOT read errno=%d. ERR=%s\n", dev->dev_errno,
 860                   be.strerror());
 861                Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
 862                   dev->dev_name, be.strerror(dev->dev_errno));
 863                Dmsg1(200, "%s", dev->errmsg);
 864                break;
 865             }
 866          }
 867          if (stat == 0) {                /* EOF */
 868             update_pos_dev(dev);
 869             Dmsg1(200, "End of File mark from read. File=%d\n", dev->file+1);
 870             /* Two reads of zero means end of tape */
 871             if (dev->state & ST_EOF) {
 872                dev->state |= ST_EOT;
 873                Dmsg0(200, "Set ST_EOT\n");
 874                break;
 875             } else {
 876                dev->state |= ST_EOF;
 877                dev->file++;
 878                dev->file_addr = 0;
 879                continue;
 880             }
 881          } else {                        /* Got data */
 882             dev->state &= ~(ST_EOF|ST_EOT);
 883          }
 884
 885          Dmsg0(200, "Doing MTFSF\n");
 886          stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
 887          if (stat < 0) {                 /* error => EOT */
 888             dev->state |= ST_EOT;
 889             Dmsg0(200, "Set ST_EOT\n");
 890             clrerror_dev(dev, MTFSF);
 891             Mmsg2(&dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
 892                dev->dev_name, strerror(dev->dev_errno));
 893             Dmsg0(200, "Got < 0 for MTFSF\n");
 894             Dmsg1(200, "%s", dev->errmsg);
 895          } else {
 896             dev->state |= ST_EOF;     /* just read EOF */
 897             dev->file++;
 898             dev->file_addr = 0;
 899          }
 900       }
 901       free_memory(rbuf);
 902
 903    /*
 904     * No FSF, so use FSR to simulate it
 905     */
 906    } else {
 907       Dmsg0(200, "Doing FSR for FSF\n");
 908       while (num-- && !(dev->state & ST_EOT)) {
 909          fsr_dev(dev, INT32_MAX);    /* returns -1 on EOF or EOT */
 910       }
 911       if (dev->state & ST_EOT) {
 912          dev->dev_errno = 0;
 913          Mmsg1(dev->errmsg, _("Device %s at End of Tape.\n"), dev->dev_name);
 914          stat = -1;
 915       } else {
 916          stat = 0;
 917       }
 918    }
 919    update_pos_dev(dev);
 920    Dmsg1(200, "Return %d from FSF\n", stat);
 921    if (dev->state & ST_EOF)
 922       Dmsg0(200, "ST_EOF set on exit FSF\n");
 923    if (dev->state & ST_EOT)
 924       Dmsg0(200, "ST_EOT set on exit FSF\n");
 925    Dmsg1(200, "Return from FSF file=%d\n", dev->file);
 926    return stat == 0;
 927 }
 928
 929 /*
 930  * Backward space a file
 931  *  Returns: false on failure
 932  *           true  on success
 933  */
 934 bool
 935 bsf_dev(DEVICE *dev, int num)
 936 {
 937    struct mtop mt_com;
 938    int stat;
 939
 940    if (dev->fd < 0) {
 941       dev->dev_errno = EBADF;
 942       Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Archive device not open\n"));
 943       Emsg0(M_FATAL, 0, dev->errmsg);
 944       return false;
 945    }
 946
 947    if (!(dev_state(dev, ST_TAPE))) {
 948       Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
 949          dev->dev_name);
 950       return false;
 951    }
 952    Dmsg0(29, "bsf_dev\n");
 953    dev->state &= ~(ST_EOT|ST_EOF);
 954    dev->file -= num;
 955    dev->file_addr = 0;
 956    mt_com.mt_op = MTBSF;
 957    mt_com.mt_count = num;
 958    stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
 959    if (stat < 0) {
 960       clrerror_dev(dev, MTBSF);
 961       Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
 962          dev->dev_name, strerror(dev->dev_errno));
 963    }
 964    update_pos_dev(dev);
 965    return stat == 0;
 966 }
 967
 968
 969 /*
 970  * Foward space a record
 971  *  Returns: false on failure
 972  *           true  on success
 973  */
 974 bool
 975 fsr_dev(DEVICE *dev, int num)
 976 {
 977    struct mtop mt_com;
 978    int stat;
 979
 980    if (dev->fd < 0) {
 981       dev->dev_errno = EBADF;
 982       Mmsg0(dev->errmsg, _("Bad call to fsr_dev. Archive not open\n"));
 983       Emsg0(M_FATAL, 0, dev->errmsg);
 984       return false;
 985    }
 986
 987    if (!(dev_state(dev, ST_TAPE))) {
 988       return false;
 989    }
 990    if (!dev_cap(dev, CAP_FSR)) {
 991       Mmsg1(dev->errmsg, _("ioctl MTFSR not permitted on %s.\n"), dev->dev_name);
 992       return false;
 993    }
 994
 995    Dmsg0(29, "fsr_dev\n");
 996    mt_com.mt_op = MTFSR;
 997    mt_com.mt_count = num;
 998    stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
 999    if (stat == 0) {
1000       dev->state &= ~ST_EOF;
1001       dev->block_num += num;
1002    } else {
1003       struct mtget mt_stat;
1004       if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) == 0 && mt_stat.mt_fileno >= 0) {
1005          Dmsg4(100, "Adjust from %d:%d to %d:%d\n", dev->file,
1006             dev->block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1007          dev->file = mt_stat.mt_fileno;
1008          dev->block_num = mt_stat.mt_blkno;
1009       } else {
1010          if (dev->state & ST_EOF) {
1011             dev->state |= ST_EOT;
1012          } else {
1013             dev->state |= ST_EOF;           /* assume EOF */
1014             dev->file++;
1015             dev->block_num = 0;
1016             dev->file_addr = 0;
1017          }
1018       }
1019       clrerror_dev(dev, MTFSR);
1020       Mmsg2(dev->errmsg, _("ioctl MTFSR error on %s. ERR=%s.\n"),
1021          dev->dev_name, strerror(dev->dev_errno));
1022    }
1023    update_pos_dev(dev);
1024    return stat == 0;
1025 }
1026
1027 /*
1028  * Backward space a record
1029  *   Returns:  false on failure
1030  *             true  on success
1031  */
1032 bool
1033 bsr_dev(DEVICE *dev, int num)
1034 {
1035    struct mtop mt_com;
1036    int stat;
1037
1038    if (dev->fd < 0) {
1039       dev->dev_errno = EBADF;
1040       Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Archive not open\n"));
1041       Emsg0(M_FATAL, 0, dev->errmsg);
1042       return false;
1043    }
1044
1045    if (!(dev->state & ST_TAPE)) {
1046       return false;
1047    }
1048
1049    if (!dev_cap(dev, CAP_BSR)) {
1050       Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->dev_name);
1051       return false;
1052    }
1053
1054    Dmsg0(29, "bsr_dev\n");
1055    dev->block_num -= num;
1056    dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1057    mt_com.mt_op = MTBSR;
1058    mt_com.mt_count = num;
1059    stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1060    if (stat < 0) {
1061       clrerror_dev(dev, MTBSR);
1062       Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1063          dev->dev_name, strerror(dev->dev_errno));
1064    }
1065    update_pos_dev(dev);
1066    return stat == 0;
1067 }
1068
1069 /*
1070  * Reposition the device to file, block
1071  * Returns: false on failure
1072  *          true  on success
1073  */
1074 bool
1075 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1076 {
1077    if (dev->fd < 0) {
1078       dev->dev_errno = EBADF;
1079       Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Archive not open\n"));
1080       Emsg0(M_FATAL, 0, dev->errmsg);
1081       return false;
1082    }
1083
1084    if (!(dev_state(dev, ST_TAPE))) {
1085       off_t pos = (((off_t)file)<<32) + block;
1086       Dmsg1(100, "===== lseek to %d\n", (int)pos);
1087       if (lseek(dev->fd, pos, SEEK_SET) == (off_t)-1) {
1088          dev->dev_errno = errno;
1089          Mmsg2(dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
1090             dev->dev_name, strerror(dev->dev_errno));
1091          return false;
1092       }
1093       dev->file = file;
1094       dev->block_num = block;
1095       dev->file_addr = pos;
1096       return true;
1097    }
1098    Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1099       dev->file, dev->block_num, file, block);
1100    if (file < dev->file) {
1101       Dmsg0(100, "Rewind_dev\n");
1102       if (!rewind_dev(dev)) {
1103          return false;
1104       }
1105    }
1106    if (file > dev->file) {
1107       Dmsg1(100, "fsf %d\n", file-dev->file);
1108       if (!fsf_dev(dev, file-dev->file)) {
1109          return false;
1110       }
1111    }
1112    if (block < dev->block_num) {
1113       bsf_dev(dev, 1);
1114       fsf_dev(dev, 1);
1115    }
1116    if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1117       /* Ignore errors as Bacula can read to the correct block */
1118       Dmsg1(100, "fsr %d\n", block-dev->block_num);
1119       return fsr_dev(dev, block-dev->block_num);
1120    }
1121    return true;
1122 }
1123
1124
1125
1126 /*
1127  * Write an end of file on the device
1128  *   Returns: 0 on success
1129  *            non-zero on failure
1130  */
1131 int
1132 weof_dev(DEVICE *dev, int num)
1133 {
1134    struct mtop mt_com;
1135    int stat;
1136
1137    if (dev->fd < 0) {
1138       dev->dev_errno = EBADF;
1139       Mmsg0(dev->errmsg, _("Bad call to weof_dev. Archive drive not open\n"));
1140       Emsg0(M_FATAL, 0, dev->errmsg);
1141       return -1;
1142    }
1143
1144    if (!(dev_state(dev, ST_TAPE))) {
1145       return 0;
1146    }
1147    dev->state &= ~(ST_EOT | ST_EOF);  /* remove EOF/EOT flags */
1148    dev->block_num = 0;
1149    Dmsg0(29, "weof_dev\n");
1150    mt_com.mt_op = MTWEOF;
1151    mt_com.mt_count = num;
1152    stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1153    if (stat == 0) {
1154       dev->file += num;
1155       dev->file_addr = 0;
1156    } else {
1157       berrno be;
1158       clrerror_dev(dev, MTWEOF);
1159       if (stat == -1) {
1160          Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1161             dev->dev_name, be.strerror());
1162        }
1163    }
1164    return stat;
1165 }
1166
1167 /*
1168  * Return string message with last error in English
1169  *  Be careful not to call this routine from within dev.c
1170  *  while editing an Mmsg() or you will end up in a recursive
1171  *  loop creating a Segmentation Violation.
1172  */
1173 char *
1174 strerror_dev(DEVICE *dev)
1175 {
1176    return dev->errmsg;
1177 }
1178
1179
1180 /*
1181  * If implemented in system, clear the tape
1182  * error status.
1183  */
1184 void
1185 clrerror_dev(DEVICE *dev, int func)
1186 {
1187    const char *msg = NULL;
1188    struct mtget mt_stat;
1189
1190    dev->dev_errno = errno;         /* save errno */
1191    if (errno == EIO) {
1192       dev->VolCatInfo.VolCatErrors++;
1193    }
1194
1195    if (!(dev->state & ST_TAPE)) {
1196       return;
1197    }
1198    if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1199       switch (func) {
1200       case -1:
1201          Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1202          break;
1203       case MTWEOF:
1204          msg = "WTWEOF";
1205          dev->capabilities &= ~CAP_EOF; /* turn off feature */
1206          break;
1207 #ifdef MTEOM
1208       case MTEOM:
1209          msg = "WTEOM";
1210          dev->capabilities &= ~CAP_EOM; /* turn off feature */
1211          break;
1212 #endif
1213       case MTFSF:
1214          msg = "MTFSF";
1215          dev->capabilities &= ~CAP_FSF; /* turn off feature */
1216          break;
1217       case MTBSF:
1218          msg = "MTBSF";
1219          dev->capabilities &= ~CAP_BSF; /* turn off feature */
1220          break;
1221       case MTFSR:
1222          msg = "MTFSR";
1223          dev->capabilities &= ~CAP_FSR; /* turn off feature */
1224          break;
1225       case MTBSR:
1226          msg = "MTBSR";
1227          dev->capabilities &= ~CAP_BSR; /* turn off feature */
1228          break;
1229       default:
1230          msg = "Unknown";
1231          break;
1232       }
1233       if (msg != NULL) {
1234          dev->dev_errno = ENOSYS;
1235          Mmsg1(&dev->errmsg, _("This device does not support %s.\n"), msg);
1236          Emsg0(M_ERROR, 0, dev->errmsg);
1237       }
1238    }
1239    /* On some systems such as NetBSD, this clears all errors */
1240    ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1241
1242 /* Found on Linux */
1243 #ifdef MTIOCLRERR
1244 {
1245    struct mtop mt_com;
1246    mt_com.mt_op = MTIOCLRERR;
1247    mt_com.mt_count = 1;
1248    /* Clear any error condition on the tape */
1249    ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1250    Dmsg0(200, "Did MTIOCLRERR\n");
1251 }
1252 #endif
1253
1254 /* Typically on FreeBSD */
1255 #ifdef MTIOCERRSTAT
1256 {
1257    /* Read and clear SCSI error status */
1258    union mterrstat mt_errstat;
1259    Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1260       strerror(dev->dev_errno));
1261    ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1262 }
1263 #endif
1264 }
1265
1266 /*
1267  * Flush buffer contents
1268  *  No longer used.
1269  */
1270 int flush_dev(DEVICE *dev)
1271 {
1272    return 1;
1273 }
1274
1275 static void do_close(DEVICE *dev)
1276 {
1277
1278    Dmsg1(29, "really close_dev %s\n", dev->dev_name);
1279    if (dev->fd >= 0) {
1280       close(dev->fd);
1281    }
1282    /* Clean up device packet so it can be reused */
1283    dev->fd = -1;
1284    dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1285    dev->file = dev->block_num = 0;
1286    dev->file_addr = 0;
1287    dev->EndFile = dev->EndBlock = 0;
1288    memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1289    memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1290    if (dev->tid) {
1291       stop_thread_timer(dev->tid);
1292       dev->tid = 0;
1293    }
1294    dev->use_count = 0;
1295 }
1296
1297 /*
1298  * Close the device
1299  */
1300 void
1301 close_dev(DEVICE *dev)
1302 {
1303    if (!dev) {
1304       Mmsg0(&dev->errmsg, _("Bad call to close_dev. Archive not open\n"));
1305       Emsg0(M_FATAL, 0, dev->errmsg);
1306       return;
1307    }
1308    if (dev->fd >= 0 && dev->use_count == 1) {
1309       do_close(dev);
1310    } else if (dev->use_count > 0) {
1311       dev->use_count--;
1312    }
1313
1314 #ifdef FULL_DEBUG
1315    ASSERT(dev->use_count >= 0);
1316 #endif
1317 }
1318
1319 /*
1320  * Used when unmounting the device, ignore use_count
1321  */
1322 void force_close_dev(DEVICE *dev)
1323 {
1324    if (!dev) {
1325       Mmsg0(&dev->errmsg, _("Bad call to force_close_dev. Archive not open\n"));
1326       Emsg0(M_FATAL, 0, dev->errmsg);
1327       return;
1328    }
1329    Dmsg1(29, "Force close_dev %s\n", dev->dev_name);
1330    do_close(dev);
1331
1332 #ifdef FULL_DEBUG
1333    ASSERT(dev->use_count >= 0);
1334 #endif
1335 }
1336
1337 bool truncate_dev(DEVICE *dev)
1338 {
1339    if (dev->state & ST_TAPE) {
1340       return true;                    /* we don't really truncate tapes */
1341       /* maybe we should rewind and write and eof ???? */
1342    }
1343    if (ftruncate(dev->fd, 0) != 0) {
1344       Mmsg1(&dev->errmsg, _("Unable to truncate device. ERR=%s\n"), strerror(errno));
1345       return false;
1346    }
1347    return true;
1348 }
1349
1350 bool
1351 dev_is_tape(DEVICE *dev)
1352 {
1353    return (dev->state & ST_TAPE) ? true : false;
1354 }
1355
1356
1357 /*
1358  * return 1 if the device is read for write, and 0 otherwise
1359  *   This is meant for checking at the end of a job to see
1360  *   if we still have a tape (perhaps not if at end of tape
1361  *   and the job is canceled).
1362  */
1363 bool
1364 dev_can_write(DEVICE *dev)
1365 {
1366    if ((dev->state & ST_OPENED) &&  (dev->state & ST_APPEND) &&
1367        (dev->state & ST_LABEL)  && !(dev->state & ST_WEOT)) {
1368       return true;
1369    } else {
1370       return false;
1371    }
1372 }
1373
1374 char *
1375 dev_name(DEVICE *dev)
1376 {
1377    return dev->dev_name;
1378 }
1379
1380 char *
1381 dev_vol_name(DEVICE *dev)
1382 {
1383    return dev->VolCatInfo.VolCatName;
1384 }
1385
1386 uint32_t dev_block(DEVICE *dev)
1387 {
1388    update_pos_dev(dev);
1389    return dev->block_num;
1390 }
1391
1392 uint32_t dev_file(DEVICE *dev)
1393 {
1394    update_pos_dev(dev);
1395    return dev->file;
1396 }
1397
1398 /*
1399  * Free memory allocated for the device
1400  */
1401 void
1402 term_dev(DEVICE *dev)
1403 {
1404    if (!dev) {
1405       dev->dev_errno = EBADF;
1406       Mmsg0(&dev->errmsg, _("Bad call to term_dev. Archive not open\n"));
1407       Emsg0(M_FATAL, 0, dev->errmsg);
1408       return;
1409    }
1410    do_close(dev);
1411    Dmsg0(29, "term_dev\n");
1412    if (dev->dev_name) {
1413       free_memory(dev->dev_name);
1414       dev->dev_name = NULL;
1415    }
1416    if (dev->errmsg) {
1417       free_pool_memory(dev->errmsg);
1418       dev->errmsg = NULL;
1419    }
1420    pthread_mutex_destroy(&dev->mutex);
1421    pthread_cond_destroy(&dev->wait);
1422    pthread_cond_destroy(&dev->wait_next_vol);
1423    pthread_mutex_destroy(&dev->spool_mutex);
1424    rwl_destroy(&dev->lock);
1425    if (dev->attached_dcrs) {
1426       delete dev->attached_dcrs;
1427       dev->attached_dcrs = NULL;
1428    }
1429    if (dev->state & ST_MALLOC) {
1430       free_pool_memory((POOLMEM *)dev);
1431    }
1432 }
1433
1434 /*
1435  * This routine initializes the device wait timers
1436  */
1437 void init_dev_wait_timers(DEVICE *dev)
1438 {
1439    /* ******FIXME******* put these on config variables */
1440    dev->min_wait = 60 * 60;
1441    dev->max_wait = 24 * 60 * 60;
1442    dev->max_num_wait = 9;              /* 5 waits =~ 1 day, then 1 day at a time */
1443    dev->wait_sec = dev->min_wait;
1444    dev->rem_wait_sec = dev->wait_sec;
1445    dev->num_wait = 0;
1446    dev->poll = false;
1447    dev->BadVolName[0] = 0;
1448 }
1449
1450 /*
1451  * Returns: true if time doubled
1452  *          false if max time expired
1453  */
1454 bool double_dev_wait_time(DEVICE *dev)
1455 {
1456    dev->wait_sec *= 2;               /* double wait time */
1457    if (dev->wait_sec > dev->max_wait) {   /* but not longer than maxtime */
1458       dev->wait_sec = dev->max_wait;
1459    }
1460    dev->num_wait++;
1461    dev->rem_wait_sec = dev->wait_sec;
1462    if (dev->num_wait >= dev->max_num_wait) {
1463       return false;
1464    }
1465    return true;
1466 }