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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-2007 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *
  30  *   block.c -- tape block handling functions
  31  *
  32  *              Kern Sibbald, March MMI
  33  *                 added BB02 format October MMII
  34  *
  35  *   Version $Id$
  36  *
  37  */
  38
  39
  40 #include "bacula.h"
  41 #include "stored.h"
  42
  43 static bool terminate_writing_volume(DCR *dcr);
  44 static bool do_new_file_bookkeeping(DCR *dcr);
  45 static bool do_dvd_size_checks(DCR *dcr);
  46 static void reread_last_block(DCR *dcr);
  47
  48 /*
  49  * Dump the block header, then walk through
  50  * the block printing out the record headers.
  51  */
  52 void dump_block(DEV_BLOCK *b, const char *msg)
  53 {
  54    ser_declare;
  55    char *p;
  56    char Id[BLKHDR_ID_LENGTH+1];
  57    uint32_t CheckSum, BlockCheckSum;
  58    uint32_t block_len;
  59    uint32_t BlockNumber;
  60    uint32_t VolSessionId, VolSessionTime, data_len;
  61    int32_t  FileIndex;
  62    int32_t  Stream;
  63    int bhl, rhl;
  64    char buf1[100], buf2[100];
  65
  66    unser_begin(b->buf, BLKHDR1_LENGTH);
  67    unser_uint32(CheckSum);
  68    unser_uint32(block_len);
  69    unser_uint32(BlockNumber);
  70    unser_bytes(Id, BLKHDR_ID_LENGTH);
  71    ASSERT(unser_length(b->buf) == BLKHDR1_LENGTH);
  72    Id[BLKHDR_ID_LENGTH] = 0;
  73    if (Id[3] == '2') {
  74       unser_uint32(VolSessionId);
  75       unser_uint32(VolSessionTime);
  76       bhl = BLKHDR2_LENGTH;
  77       rhl = RECHDR2_LENGTH;
  78    } else {
  79       VolSessionId = VolSessionTime = 0;
  80       bhl = BLKHDR1_LENGTH;
  81       rhl = RECHDR1_LENGTH;
  82    }
  83
  84    if (block_len > 100000) {
  85       Dmsg3(20, "Dump block %s 0x%x blocksize too big %u\n", msg, b, block_len);
  86       return;
  87    }
  88
  89    BlockCheckSum = bcrc32((uint8_t *)b->buf+BLKHDR_CS_LENGTH,
  90                          block_len-BLKHDR_CS_LENGTH);
  91    Pmsg6(000, _("Dump block %s %x: size=%d BlkNum=%d\n"
  92 "               Hdrcksum=%x cksum=%x\n"),
  93       msg, b, block_len, BlockNumber, CheckSum, BlockCheckSum);
  94    p = b->buf + bhl;
  95    while (p < (b->buf + block_len+WRITE_RECHDR_LENGTH)) {
  96       unser_begin(p, WRITE_RECHDR_LENGTH);
  97       if (rhl == RECHDR1_LENGTH) {
  98          unser_uint32(VolSessionId);
  99          unser_uint32(VolSessionTime);
 100       }
 101       unser_int32(FileIndex);
 102       unser_int32(Stream);
 103       unser_uint32(data_len);
 104       Pmsg6(000, _("   Rec: VId=%u VT=%u FI=%s Strm=%s len=%d p=%x\n"),
 105            VolSessionId, VolSessionTime, FI_to_ascii(buf1, FileIndex),
 106            stream_to_ascii(buf2, Stream, FileIndex), data_len, p);
 107       p += data_len + rhl;
 108   }
 109 }
 110
 111 /*
 112  * Create a new block structure.
 113  * We pass device so that the block can inherit the
 114  * min and max block sizes.
 115  */
 116 DEV_BLOCK *new_block(DEVICE *dev)
 117 {
 118    DEV_BLOCK *block = (DEV_BLOCK *)get_memory(sizeof(DEV_BLOCK));
 119
 120    memset(block, 0, sizeof(DEV_BLOCK));
 121
 122    /* If the user has specified a max_block_size, use it as the default */
 123    if (dev->max_block_size == 0) {
 124       block->buf_len = DEFAULT_BLOCK_SIZE;
 125    } else {
 126       block->buf_len = dev->max_block_size;
 127    }
 128    block->dev = dev;
 129    block->block_len = block->buf_len;  /* default block size */
 130    block->buf = get_memory(block->buf_len);
 131    empty_block(block);
 132    block->BlockVer = BLOCK_VER;       /* default write version */
 133    Dmsg1(650, "Returning new block=%x\n", block);
 134    return block;
 135 }
 136
 137
 138 /*
 139  * Duplicate an existing block (eblock)
 140  */
 141 DEV_BLOCK *dup_block(DEV_BLOCK *eblock)
 142 {
 143    DEV_BLOCK *block = (DEV_BLOCK *)get_memory(sizeof(DEV_BLOCK));
 144    int buf_len = sizeof_pool_memory(eblock->buf);
 145
 146    memcpy(block, eblock, sizeof(DEV_BLOCK));
 147    block->buf = get_memory(buf_len);
 148    memcpy(block->buf, eblock->buf, buf_len);
 149    return block;
 150 }
 151
 152
 153 /*
 154  * Only the first block checksum error was reported.
 155  *   If there are more, report it now.
 156  */
 157 void print_block_read_errors(JCR *jcr, DEV_BLOCK *block)
 158 {
 159    if (block->read_errors > 1) {
 160       Jmsg(jcr, M_ERROR, 0, _("%d block read errors not printed.\n"),
 161          block->read_errors);
 162    }
 163 }
 164
 165 /*
 166  * Free block
 167  */
 168 void free_block(DEV_BLOCK *block)
 169 {
 170    Dmsg1(999, "free_block buffer %x\n", block->buf);
 171    free_memory(block->buf);
 172    Dmsg1(999, "free_block block %x\n", block);
 173    free_memory((POOLMEM *)block);
 174 }
 175
 176 /* Empty the block -- for writing */
 177 void empty_block(DEV_BLOCK *block)
 178 {
 179    block->binbuf = WRITE_BLKHDR_LENGTH;
 180    block->bufp = block->buf + block->binbuf;
 181    block->read_len = 0;
 182    block->write_failed = false;
 183    block->block_read = false;
 184    block->FirstIndex = block->LastIndex = 0;
 185 }
 186
 187 /*
 188  * Create block header just before write. The space
 189  * in the buffer should have already been reserved by
 190  * init_block.
 191  */
 192 void ser_block_header(DEV_BLOCK *block)
 193 {
 194    ser_declare;
 195    uint32_t CheckSum = 0;
 196    uint32_t block_len = block->binbuf;
 197
 198    Dmsg1(1390, "ser_block_header: block_len=%d\n", block_len);
 199    ser_begin(block->buf, BLKHDR2_LENGTH);
 200    ser_uint32(CheckSum);
 201    ser_uint32(block_len);
 202    ser_uint32(block->BlockNumber);
 203    ser_bytes(WRITE_BLKHDR_ID, BLKHDR_ID_LENGTH);
 204    if (BLOCK_VER >= 2) {
 205       ser_uint32(block->VolSessionId);
 206       ser_uint32(block->VolSessionTime);
 207    }
 208
 209    /* Checksum whole block except for the checksum */
 210    CheckSum = bcrc32((uint8_t *)block->buf+BLKHDR_CS_LENGTH,
 211                  block_len-BLKHDR_CS_LENGTH);
 212    Dmsg1(1390, "ser_bloc_header: checksum=%x\n", CheckSum);
 213    ser_begin(block->buf, BLKHDR2_LENGTH);
 214    ser_uint32(CheckSum);              /* now add checksum to block header */
 215 }
 216
 217 /*
 218  * Unserialize the block header for reading block.
 219  *  This includes setting all the buffer pointers correctly.
 220  *
 221  *  Returns: false on failure (not a block)
 222  *           true  on success
 223  */
 224 static bool unser_block_header(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)
 225 {
 226    ser_declare;
 227    char Id[BLKHDR_ID_LENGTH+1];
 228    uint32_t CheckSum, BlockCheckSum;
 229    uint32_t block_len;
 230    uint32_t block_end;
 231    uint32_t BlockNumber;
 232    int bhl;
 233
 234    unser_begin(block->buf, BLKHDR_LENGTH);
 235    unser_uint32(CheckSum);
 236    unser_uint32(block_len);
 237    unser_uint32(BlockNumber);
 238    unser_bytes(Id, BLKHDR_ID_LENGTH);
 239    ASSERT(unser_length(block->buf) == BLKHDR1_LENGTH);
 240
 241    Id[BLKHDR_ID_LENGTH] = 0;
 242    if (Id[3] == '1') {
 243       bhl = BLKHDR1_LENGTH;
 244       block->BlockVer = 1;
 245       block->bufp = block->buf + bhl;
 246       if (strncmp(Id, BLKHDR1_ID, BLKHDR_ID_LENGTH) != 0) {
 247          dev->dev_errno = EIO;
 248          Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Wanted ID: \"%s\", got \"%s\". Buffer discarded.\n"),
 249             dev->file, dev->block_num, BLKHDR1_ID, Id);
 250          if (block->read_errors == 0 || verbose >= 2) {
 251             Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 252          }
 253          block->read_errors++;
 254          return false;
 255       }
 256    } else if (Id[3] == '2') {
 257       unser_uint32(block->VolSessionId);
 258       unser_uint32(block->VolSessionTime);
 259       bhl = BLKHDR2_LENGTH;
 260       block->BlockVer = 2;
 261       block->bufp = block->buf + bhl;
 262       if (strncmp(Id, BLKHDR2_ID, BLKHDR_ID_LENGTH) != 0) {
 263          dev->dev_errno = EIO;
 264          Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Wanted ID: \"%s\", got \"%s\". Buffer discarded.\n"),
 265             dev->file, dev->block_num, BLKHDR2_ID, Id);
 266          if (block->read_errors == 0 || verbose >= 2) {
 267             Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 268          }
 269          block->read_errors++;
 270          return false;
 271       }
 272    } else {
 273       dev->dev_errno = EIO;
 274       Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Wanted ID: \"%s\", got \"%s\". Buffer discarded.\n"),
 275           dev->file, dev->block_num, BLKHDR2_ID, Id);
 276       Dmsg1(50, "%s", dev->errmsg);
 277       if (block->read_errors == 0 || verbose >= 2) {
 278          Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 279       }
 280       block->read_errors++;
 281       unser_uint32(block->VolSessionId);
 282       unser_uint32(block->VolSessionTime);
 283       return false;
 284    }
 285
 286    /* Sanity check */
 287    if (block_len > MAX_BLOCK_LENGTH) {
 288       dev->dev_errno = EIO;
 289       Mmsg3(dev->errmsg,  _("Volume data error at %u:%u! Block length %u is insane (too large), probably due to a bad archive.\n"),
 290          dev->file, dev->block_num, block_len);
 291       if (block->read_errors == 0 || verbose >= 2) {
 292          Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 293       }
 294       block->read_errors++;
 295       return false;
 296    }
 297
 298    Dmsg1(390, "unser_block_header block_len=%d\n", block_len);
 299    /* Find end of block or end of buffer whichever is smaller */
 300    if (block_len > block->read_len) {
 301       block_end = block->read_len;
 302    } else {
 303       block_end = block_len;
 304    }
 305    block->binbuf = block_end - bhl;
 306    block->block_len = block_len;
 307    block->BlockNumber = BlockNumber;
 308    Dmsg3(390, "Read binbuf = %d %d block_len=%d\n", block->binbuf,
 309       bhl, block_len);
 310    if (block_len <= block->read_len) {
 311       BlockCheckSum = bcrc32((uint8_t *)block->buf+BLKHDR_CS_LENGTH,
 312                          block_len-BLKHDR_CS_LENGTH);
 313       if (BlockCheckSum != CheckSum) {
 314          dev->dev_errno = EIO;
 315          Mmsg6(dev->errmsg, _("Volume data error at %u:%u!\n"
 316             "Block checksum mismatch in block=%u len=%d: calc=%x blk=%x\n"),
 317             dev->file, dev->block_num, (unsigned)BlockNumber,
 318             block_len, BlockCheckSum, CheckSum);
 319          if (block->read_errors == 0 || verbose >= 2) {
 320             Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 321          }
 322          block->read_errors++;
 323          if (!forge_on) {
 324             return false;
 325          }
 326       }
 327    }
 328    return true;
 329 }
 330
 331 /*
 332  * Write a block to the device, with locking and unlocking
 333  *
 334  * Returns: true  on success
 335  *        : false on failure
 336  *
 337  */
 338 bool write_block_to_device(DCR *dcr)
 339 {
 340    bool stat = true;
 341    DEVICE *dev = dcr->dev;
 342    JCR *jcr = dcr->jcr;
 343
 344    if (dcr->spooling) {
 345       stat = write_block_to_spool_file(dcr);
 346       return stat;
 347    }
 348
 349    if (!dcr->is_dev_locked()) {        /* device already locked? */
 350       /* note, do not change this to dcr->r_dlock */
 351       dev->r_dlock();                  /* no, lock it */
 352    }
 353
 354    /*
 355     * If a new volume has been mounted since our last write
 356     *   Create a JobMedia record for the previous volume written,
 357     *   and set new parameters to write this volume
 358     * The same applies for if we are in a new file.
 359     */
 360    if (dcr->NewVol || dcr->NewFile) {
 361       if (job_canceled(jcr)) {
 362          stat = false;
 363          goto bail_out;
 364       }
 365       /* Create a jobmedia record for this job */
 366       if (!dir_create_jobmedia_record(dcr)) {
 367          dev->dev_errno = EIO;
 368          Jmsg(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
 369             dcr->VolCatInfo.VolCatName, jcr->Job);
 370          set_new_volume_parameters(dcr);
 371          stat = false;
 372          goto bail_out;
 373       }
 374       if (dcr->NewVol) {
 375          /* Note, setting a new volume also handles any pending new file */
 376          set_new_volume_parameters(dcr);
 377          dcr->NewFile = false;        /* this handled for new file too */
 378       } else {
 379          set_new_file_parameters(dcr);
 380       }
 381    }
 382
 383    if (!write_block_to_dev(dcr)) {
 384        if (job_canceled(jcr) || jcr->JobType == JT_SYSTEM) {
 385           stat = false;
 386        } else {
 387           stat = fixup_device_block_write_error(dcr);
 388        }
 389    }
 390
 391 bail_out:
 392    if (!dcr->is_dev_locked()) {        /* did we lock dev above? */
 393       /* note, do not change this to dcr->dunlock */
 394       dev->dunlock();                  /* unlock it now */
 395    }
 396    return stat;
 397 }
 398
 399 /*
 400  * Write a block to the device
 401  *
 402  *  Returns: true  on success or EOT
 403  *           false on hard error
 404  */
 405 bool write_block_to_dev(DCR *dcr)
 406 {
 407    ssize_t stat = 0;
 408    uint32_t wlen;                     /* length to write */
 409    int hit_max1, hit_max2;
 410    bool ok = true;
 411    DEVICE *dev = dcr->dev;
 412    JCR *jcr = dcr->jcr;
 413    DEV_BLOCK *block = dcr->block;
 414
 415 #ifdef NO_TAPE_WRITE_TEST
 416    empty_block(block);
 417    return true;
 418 #endif
 419    ASSERT(block->binbuf == ((uint32_t) (block->bufp - block->buf)));
 420    ASSERT(dev->is_open());
 421
 422    /* dump_block(block, "before write"); */
 423    if (dev->at_weot()) {
 424       Dmsg0(100, "return write_block_to_dev with ST_WEOT\n");
 425       dev->dev_errno = ENOSPC;
 426       Jmsg(jcr, M_FATAL, 0,  _("Cannot write block. Device at EOM.\n"));
 427       return false;
 428    }
 429    if (!dev->can_append()) {
 430       dev->dev_errno = EIO;
 431       Jmsg(jcr, M_FATAL, 0, _("Attempt to write on read-only Volume.\n"));
 432       return false;
 433    }
 434    wlen = block->binbuf;
 435    if (wlen <= WRITE_BLKHDR_LENGTH) {  /* Does block have data in it? */
 436       Dmsg0(100, "return write_block_to_dev no data to write\n");
 437       return true;
 438    }
 439    /*
 440     * Clear to the end of the buffer if it is not full,
 441     *  and on tape devices, apply min and fixed blocking.
 442     */
 443    if (wlen != block->buf_len) {
 444       uint32_t blen;                  /* current buffer length */
 445
 446       Dmsg2(250, "binbuf=%d buf_len=%d\n", block->binbuf, block->buf_len);
 447       blen = wlen;
 448
 449       /* Adjust write size to min/max for tapes only */
 450       if (dev->is_tape()) {
 451          /* check for fixed block size */
 452          if (dev->min_block_size == dev->max_block_size) {
 453             wlen = block->buf_len;    /* fixed block size already rounded */
 454          /* Check for min block size */
 455          } else if (wlen < dev->min_block_size) {
 456             wlen =  ((dev->min_block_size + TAPE_BSIZE - 1) / TAPE_BSIZE) * TAPE_BSIZE;
 457          /* Ensure size is rounded */
 458          } else {
 459             wlen = ((wlen + TAPE_BSIZE - 1) / TAPE_BSIZE) * TAPE_BSIZE;
 460          }
 461       }
 462       if (wlen-blen > 0) {
 463          memset(block->bufp, 0, wlen-blen); /* clear garbage */
 464       }
 465    }
 466
 467    ser_block_header(block);
 468
 469    /* Limit maximum Volume size to value specified by user */
 470    hit_max1 = (dev->max_volume_size > 0) &&
 471        ((dev->VolCatInfo.VolCatBytes + block->binbuf)) >= dev->max_volume_size;
 472    hit_max2 = (dev->VolCatInfo.VolCatMaxBytes > 0) &&
 473        ((dev->VolCatInfo.VolCatBytes + block->binbuf)) >= dev->VolCatInfo.VolCatMaxBytes;
 474    if (hit_max1 || hit_max2) {
 475       char ed1[50];
 476       uint64_t max_cap;
 477       Dmsg0(100, "==== Output bytes Triggered medium max capacity.\n");
 478       if (hit_max1) {
 479          max_cap = dev->max_volume_size;
 480       } else {
 481          max_cap = dev->VolCatInfo.VolCatMaxBytes;
 482       }
 483       Jmsg(jcr, M_INFO, 0, _("User defined maximum volume capacity %s exceeded on device %s.\n"),
 484             edit_uint64_with_commas(max_cap, ed1),  dev->print_name());
 485       terminate_writing_volume(dcr);
 486       reread_last_block(dcr);   /* DEBUG */
 487       dev->dev_errno = ENOSPC;
 488       return false;
 489    }
 490
 491    /* Limit maximum File size on volume to user specified value */
 492    if ((dev->max_file_size > 0) &&
 493        (dev->file_size+block->binbuf) >= dev->max_file_size) {
 494       dev->file_size = 0;             /* reset file size */
 495
 496       if (!dev->weof(1)) {            /* write eof */
 497          Dmsg0(190, "WEOF error in max file size.\n");
 498          Jmsg(jcr, M_FATAL, 0, _("Unable to write EOF. ERR=%s\n"),
 499             dev->bstrerror());
 500          terminate_writing_volume(dcr);
 501          dev->dev_errno = ENOSPC;
 502          return false;
 503       }
 504       if (!write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName)) {
 505          return false;
 506       }
 507
 508       if (!do_new_file_bookkeeping(dcr)) {
 509          /* Error message already sent */
 510          return false;
 511       }
 512    }
 513
 514    if (!do_dvd_size_checks(dcr)) {
 515       /* Error message already sent */
 516       return false;
 517    }
 518
 519    dev->VolCatInfo.VolCatWrites++;
 520    Dmsg1(1300, "Write block of %u bytes\n", wlen);
 521 #ifdef DEBUG_BLOCK_ZEROING
 522    uint32_t *bp = (uint32_t *)block->buf;
 523    if (bp[0] == 0 && bp[1] == 0 && bp[2] == 0 && block->buf[12] == 0) {
 524       Jmsg0(jcr, M_ABORT, 0, _("Write block header zeroed.\n"));
 525    }
 526 #endif
 527
 528    /*
 529     * Do write here, make a somewhat feeble attempt to recover from
 530     *  I/O errors, or from the OS telling us it is busy.
 531     */
 532    int retry = 0;
 533    errno = 0;
 534    stat = 0;
 535    do {
 536       if (retry > 0 && stat == -1 && errno == EBUSY) {
 537          berrno be;
 538          Dmsg4(100, "===== write retry=%d stat=%d errno=%d: ERR=%s\n",
 539                retry, stat, errno, be.bstrerror());
 540          bmicrosleep(5, 0);    /* pause a bit if busy or lots of errors */
 541          dev->clrerror(-1);
 542       }
 543       stat = dev->write(block->buf, (size_t)wlen);
 544
 545    } while (stat == -1 && (errno == EBUSY || errno == EIO) && retry++ < 3);
 546
 547 #ifdef DEBUG_BLOCK_ZEROING
 548    if (bp[0] == 0 && bp[1] == 0 && bp[2] == 0 && block->buf[12] == 0) {
 549       Jmsg0(jcr, M_ABORT, 0, _("Write block header zeroed.\n"));
 550    }
 551 #endif
 552
 553    if (stat != (ssize_t)wlen) {
 554       /* Some devices simply report EIO when the volume is full.
 555        * With a little more thought we may be able to check
 556        * capacity and distinguish real errors and EOT
 557        * conditions.  In any case, we probably want to
 558        * simulate an End of Medium.
 559        */
 560       if (stat == -1) {
 561          berrno be;
 562          dev->clrerror(-1);
 563          if (dev->dev_errno == 0) {
 564             dev->dev_errno = ENOSPC;        /* out of space */
 565          }
 566          if (dev->dev_errno != ENOSPC) {
 567             dev->VolCatInfo.VolCatErrors++;
 568             Jmsg4(jcr, M_ERROR, 0, _("Write error at %u:%u on device %s. ERR=%s.\n"),
 569                dev->file, dev->block_num, dev->print_name(), be.bstrerror());
 570          }
 571       } else {
 572         dev->dev_errno = ENOSPC;            /* out of space */
 573       }
 574       if (dev->dev_errno == ENOSPC) {
 575          Jmsg(jcr, M_INFO, 0, _("End of Volume \"%s\" at %u:%u on device %s. Write of %u bytes got %d.\n"),
 576             dev->VolCatInfo.VolCatName,
 577             dev->file, dev->block_num, dev->print_name(), wlen, stat);
 578       }
 579       if (debug_level >= 100) {
 580          berrno be;
 581          Dmsg7(100, "=== Write error. fd=%d size=%u rtn=%d dev_blk=%d blk_blk=%d errno=%d: ERR=%s\n",
 582             dev->fd(), wlen, stat, dev->block_num, block->BlockNumber,
 583             dev->dev_errno, be.bstrerror(dev->dev_errno));
 584       }
 585
 586       ok = terminate_writing_volume(dcr);
 587       if (!ok && !forge_on) {
 588          return false;
 589       }
 590       if (ok) {
 591          reread_last_block(dcr);
 592       }
 593       return false;
 594    }
 595
 596    /* We successfully wrote the block, now do housekeeping */
 597    Dmsg2(1300, "VolCatBytes=%d newVolCatBytes=%d\n", (int)dev->VolCatInfo.VolCatBytes,
 598       (int)(dev->VolCatInfo.VolCatBytes+wlen));
 599    dev->VolCatInfo.VolCatBytes += wlen;
 600    dev->VolCatInfo.VolCatBlocks++;
 601    dev->EndBlock = dev->block_num;
 602    dev->EndFile  = dev->file;
 603    block->BlockNumber++;
 604
 605    /* Update dcr values */
 606    if (dev->is_tape()) {
 607       dcr->EndBlock = dev->EndBlock;
 608       dcr->EndFile  = dev->EndFile;
 609       dev->block_num++;
 610    } else {
 611       /* Save address of block just written */
 612       uint64_t addr = dev->file_addr + wlen - 1;
 613       dcr->EndBlock = (uint32_t)addr;
 614       dcr->EndFile = (uint32_t)(addr >> 32);
 615       dev->block_num = dcr->EndBlock;
 616       dev->file = dcr->EndFile;
 617    }
 618    dcr->VolMediaId = dev->VolCatInfo.VolMediaId;
 619    if (dcr->VolFirstIndex == 0 && block->FirstIndex > 0) {
 620       dcr->VolFirstIndex = block->FirstIndex;
 621    }
 622    if (block->LastIndex > 0) {
 623       dcr->VolLastIndex = block->LastIndex;
 624    }
 625    dcr->WroteVol = true;
 626    dev->file_addr += wlen;            /* update file address */
 627    dev->file_size += wlen;
 628    dev->part_size += wlen;
 629
 630    Dmsg2(1300, "write_block: wrote block %d bytes=%d\n", dev->block_num, wlen);
 631    empty_block(block);
 632    return true;
 633 }
 634
 635 static void reread_last_block(DCR *dcr)
 636 {
 637 #define CHECK_LAST_BLOCK
 638 #ifdef  CHECK_LAST_BLOCK
 639    bool ok = true;
 640    DEVICE *dev = dcr->dev;
 641    JCR *jcr = dcr->jcr;
 642    DEV_BLOCK *block = dcr->block;
 643    /*
 644     * If the device is a tape and it supports backspace record,
 645     *   we backspace over one or two eof marks depending on
 646     *   how many we just wrote, then over the last record,
 647     *   then re-read it and verify that the block number is
 648     *   correct.
 649     */
 650    if (dev->is_tape() && dev->has_cap(CAP_BSR)) {
 651       /* Now back up over what we wrote and read the last block */
 652       if (!dev->bsf(1)) {
 653          berrno be;
 654          ok = false;
 655          Jmsg(jcr, M_ERROR, 0, _("Backspace file at EOT failed. ERR=%s\n"),
 656               be.bstrerror(dev->dev_errno));
 657       }
 658       if (ok && dev->has_cap(CAP_TWOEOF) && !dev->bsf(1)) {
 659          berrno be;
 660          ok = false;
 661          Jmsg(jcr, M_ERROR, 0, _("Backspace file at EOT failed. ERR=%s\n"),
 662               be.bstrerror(dev->dev_errno));
 663       }
 664       /* Backspace over record */
 665       if (ok && !dev->bsr(1)) {
 666          berrno be;
 667          ok = false;
 668          Jmsg(jcr, M_ERROR, 0, _("Backspace record at EOT failed. ERR=%s\n"),
 669               be.bstrerror(dev->dev_errno));
 670          /*
 671           *  On FreeBSD systems, if the user got here, it is likely that his/her
 672           *    tape drive is "frozen".  The correct thing to do is a
 673           *    rewind(), but if we do that, higher levels in cleaning up, will
 674           *    most likely write the EOS record over the beginning of the
 675           *    tape.  The rewind *is* done later in mount.c when another
 676           *    tape is requested. Note, the clrerror() call in bsr()
 677           *    calls ioctl(MTCERRSTAT), which *should* fix the problem.
 678           */
 679       }
 680       if (ok) {
 681          DEV_BLOCK *lblock = new_block(dev);
 682          /* Note, this can destroy dev->errmsg */
 683          dcr->block = lblock;
 684          if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 685             Jmsg(jcr, M_ERROR, 0, _("Re-read last block at EOT failed. ERR=%s"),
 686                  dev->errmsg);
 687          } else {
 688             /*
 689              * If we wrote block and the block numbers don't agree
 690              *  we have a possible problem.
 691              */
 692             if (lblock->VolSessionId == block->VolSessionId &&
 693                 lblock->BlockNumber+1 != block->BlockNumber) {
 694                Jmsg(jcr, M_ERROR, 0, _(
 695 "Re-read of last block OK, but block numbers differ. Last block=%u Current block=%u.\n"),
 696                     lblock->BlockNumber, block->BlockNumber);
 697             } else {
 698                Jmsg(jcr, M_INFO, 0, _("Re-read of last block succeeded.\n"));
 699             }
 700          }
 701          free_block(lblock);
 702          dcr->block = block;
 703       }
 704    }
 705 #endif
 706 }
 707
 708 static bool terminate_writing_volume(DCR *dcr)
 709 {
 710    DEVICE *dev = dcr->dev;
 711    bool ok = true;
 712
 713    /* Create a JobMedia record to indicated end of tape */
 714    dev->VolCatInfo.VolCatFiles = dev->file;
 715    if (!dir_create_jobmedia_record(dcr)) {
 716       Dmsg0(190, "Error from create JobMedia\n");
 717       dev->dev_errno = EIO;
 718        Jmsg(dcr->jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
 719             dcr->VolCatInfo.VolCatName, dcr->jcr->Job);
 720        ok = false;
 721        goto bail_out;
 722    }
 723    dcr->block->write_failed = true;
 724    if (!dev->weof(1)) {         /* end the tape */
 725       dev->VolCatInfo.VolCatErrors++;
 726       Jmsg(dcr->jcr, M_ERROR, 0, _("Error writing final EOF to tape. This Volume may not be readable.\n"
 727            "%s"), dev->errmsg);
 728       ok = false;
 729       Dmsg0(100, "WEOF error.\n");
 730    }
 731    if (ok) {
 732       ok = write_ansi_ibm_labels(dcr, ANSI_EOV_LABEL, dev->VolHdr.VolumeName);
 733    }
 734    bstrncpy(dev->VolCatInfo.VolCatStatus, "Full", sizeof(dev->VolCatInfo.VolCatStatus));
 735    dev->VolCatInfo.VolCatFiles = dev->file;   /* set number of files */
 736
 737    if (dev->is_dvd()) {
 738       if (!dvd_write_part(dcr)) {             /* write last part */
 739          dev->VolCatInfo.VolCatErrors++;
 740          Jmsg(dcr->jcr, M_FATAL, 0, _("Error writing final part to DVD. "
 741                                  "This Volume may not be readable.\n%s"),
 742                          dev->errmsg);
 743          ok = false;
 744          Dmsg0(100, "dvd_write_part error.\n");
 745       }
 746       dev->VolCatInfo.VolCatParts = dev->num_dvd_parts;
 747    }
 748
 749    if (!dir_update_volume_info(dcr, false)) {
 750       ok = false;
 751    }
 752    Dmsg1(100, "dir_update_volume_info terminate writing -- %s\n", ok?"OK":"ERROR");
 753
 754    /*
 755     * Walk through all attached dcrs setting flag to call
 756     * set_new_file_parameters() when that dcr is next used.
 757     */
 758    DCR *mdcr;
 759    foreach_dlist(mdcr, dev->attached_dcrs) {
 760       if (mdcr->jcr->JobId == 0) {
 761          continue;
 762       }
 763       mdcr->NewFile = true;        /* set reminder to do set_new_file_params */
 764    }
 765    /* Set new file/block parameters for current dcr */
 766    set_new_file_parameters(dcr);
 767
 768    if (ok && dev->has_cap(CAP_TWOEOF) && !dev->weof(1)) {  /* end the tape */
 769       dev->VolCatInfo.VolCatErrors++;
 770       /* This may not be fatal since we already wrote an EOF */
 771       Jmsg(dcr->jcr, M_ERROR, 0, "%s", dev->errmsg);
 772    }
 773
 774 bail_out:
 775    dev->set_ateot();                  /* no more writing this tape */
 776    Dmsg1(50, "*** Leave terminate_writing_volume -- %s\n", ok?"OK":"ERROR");
 777    return ok;
 778 }
 779
 780 /*
 781  * Do bookkeeping when a new file is created on a Volume. This is
 782  *  also done for disk files to generate the jobmedia records for
 783  *  quick seeking.
 784  */
 785 static bool do_new_file_bookkeeping(DCR *dcr)
 786 {
 787    DEVICE *dev = dcr->dev;
 788    JCR *jcr = dcr->jcr;
 789
 790    /* Create a JobMedia record so restore can seek */
 791    if (!dir_create_jobmedia_record(dcr)) {
 792       Dmsg0(190, "Error from create_job_media.\n");
 793       dev->dev_errno = EIO;
 794       Jmsg(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
 795            dcr->VolCatInfo.VolCatName, jcr->Job);
 796       terminate_writing_volume(dcr);
 797       dev->dev_errno = EIO;
 798       return false;
 799    }
 800    dev->VolCatInfo.VolCatFiles = dev->file;
 801    if (!dir_update_volume_info(dcr, false)) {
 802       Dmsg0(190, "Error from update_vol_info.\n");
 803       terminate_writing_volume(dcr);
 804       dev->dev_errno = EIO;
 805       return false;
 806    }
 807    Dmsg0(100, "dir_update_volume_info max file size -- OK\n");
 808
 809    /*
 810     * Walk through all attached dcrs setting flag to call
 811     * set_new_file_parameters() when that dcr is next used.
 812     */
 813    DCR *mdcr;
 814    foreach_dlist(mdcr, dev->attached_dcrs) {
 815       if (mdcr->jcr->JobId == 0) {
 816          continue;
 817       }
 818       mdcr->NewFile = true;        /* set reminder to do set_new_file_params */
 819    }
 820    /* Set new file/block parameters for current dcr */
 821    set_new_file_parameters(dcr);
 822    return true;
 823 }
 824
 825 /*
 826  * Do all checks for DVD sizes during writing.
 827  */
 828 static bool do_dvd_size_checks(DCR *dcr)
 829 {
 830    DEVICE *dev = dcr->dev;
 831    JCR *jcr = dcr->jcr;
 832    DEV_BLOCK *block = dcr->block;
 833
 834    /* Don't go further if the device is not a dvd */
 835    if (!dev->is_dvd()) {
 836       return true;
 837    }
 838
 839    /* Limit maximum part size to value specified by user
 840     */
 841    if (dev->max_part_size > 0 && ((dev->part_size + block->binbuf) >= dev->max_part_size)) {
 842       if (dev->part < dev->num_dvd_parts) {
 843          Jmsg3(dcr->jcr, M_FATAL, 0, _("Error while writing, current part number"
 844                " is less than the total number of parts (%d/%d, device=%s)\n"),
 845                dev->part, dev->num_dvd_parts, dev->print_name());
 846          dev->dev_errno = EIO;
 847          return false;
 848       }
 849
 850       if (dvd_open_next_part(dcr) < 0) {
 851          Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device next part %s: ERR=%s\n"),
 852                 dev->print_name(), dev->bstrerror());
 853          dev->dev_errno = EIO;
 854          return false;
 855       }
 856
 857       dev->VolCatInfo.VolCatParts = dev->num_dvd_parts;
 858
 859       if (!dir_update_volume_info(dcr, false)) {
 860          Dmsg0(190, "Error from update_vol_info.\n");
 861          dev->dev_errno = EIO;
 862          return false;
 863       }
 864    }
 865
 866    dev->update_freespace();
 867
 868    if (!dev->is_freespace_ok()) { /* Error while getting free space */
 869       char ed1[50], ed2[50];
 870       Dmsg1(100, "Cannot get free space on the device ERR=%s.\n", dev->errmsg);
 871       Jmsg(jcr, M_FATAL, 0, _("End of Volume \"%s\" at %u:%u on device %s "
 872          "(part_size=%s, free_space=%s, free_space_errno=%d, errmsg=%s).\n"),
 873            dev->VolCatInfo.VolCatName,
 874            dev->file, dev->block_num, dev->print_name(),
 875            edit_uint64_with_commas(dev->part_size, ed1), edit_uint64_with_commas(dev->free_space, ed2),
 876            dev->free_space_errno, dev->errmsg);
 877       dev->dev_errno = dev->free_space_errno;
 878       return false;
 879    }
 880
 881    if ((dev->is_freespace_ok() && (dev->part_size + block->binbuf) >= dev->free_space)) {
 882       char ed1[50], ed2[50];
 883       Dmsg0(100, "==== Just enough free space on the device to write the current part...\n");
 884       Jmsg(jcr, M_INFO, 0, _("End of Volume \"%s\" at %u:%u on device %s "
 885          "(part_size=%s, free_space=%s, free_space_errno=%d).\n"),
 886             dev->VolCatInfo.VolCatName,
 887             dev->file, dev->block_num, dev->print_name(),
 888             edit_uint64_with_commas(dev->part_size, ed1), edit_uint64_with_commas(dev->free_space, ed2),
 889             dev->free_space_errno);
 890       terminate_writing_volume(dcr);
 891       dev->dev_errno = ENOSPC;
 892       return false;
 893    }
 894    return true;
 895 }
 896
 897
 898 /*
 899  * Read block with locking
 900  *
 901  */
 902 bool read_block_from_device(DCR *dcr, bool check_block_numbers)
 903 {
 904    bool ok;
 905    DEVICE *dev = dcr->dev;
 906    Dmsg0(250, "Enter read_block_from_device\n");
 907    dev->r_dlock();
 908    ok = read_block_from_dev(dcr, check_block_numbers);
 909    dev->dunlock();
 910    Dmsg0(250, "Leave read_block_from_device\n");
 911    return ok;
 912 }
 913
 914 /*
 915  * Read the next block into the block structure and unserialize
 916  *  the block header.  For a file, the block may be partially
 917  *  or completely in the current buffer.
 918  */
 919 bool read_block_from_dev(DCR *dcr, bool check_block_numbers)
 920 {
 921    ssize_t stat;
 922    int looping;
 923    uint32_t BlockNumber;
 924    int retry;
 925    JCR *jcr = dcr->jcr;
 926    DEVICE *dev = dcr->dev;
 927    DEV_BLOCK *block = dcr->block;
 928
 929    ASSERT(dev->is_open());
 930
 931    if (dev->at_eot()) {
 932       return false;
 933    }
 934    looping = 0;
 935    Dmsg1(250, "Full read in read_block_from_device() len=%d\n",
 936          block->buf_len);
 937 reread:
 938    if (looping > 1) {
 939       dev->dev_errno = EIO;
 940       Mmsg1(dev->errmsg, _("Block buffer size looping problem on device %s\n"),
 941          dev->print_name());
 942       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 943       block->read_len = 0;
 944       return false;
 945    }
 946
 947 // #define lots_of_debug
 948 #ifdef lots_of_debug
 949    if (dev->at_eof() && dev->is_dvd()) {
 950       Dmsg1(100, "file_size=%u\n",(unsigned int)dev->file_size);
 951       Dmsg1(100, "file_addr=%u\n",(unsigned int)dev->file_addr);
 952       Dmsg1(100, "lseek=%u\n",(unsigned int)lseek(dev->fd(), 0, SEEK_CUR));
 953       Dmsg1(100, "part_start=%u\n",(unsigned int)dev->part_start);
 954       Dmsg1(100, "part_size=%u\n", (unsigned int)dev->part_size);
 955       Dmsg2(100, "part=%u num_dvd_parts=%u\n", dev->part, dev->num_dvd_parts);
 956       Dmsg1(100, "VolCatInfo.VolCatParts=%u\n", (unsigned int)dev->VolCatInfo.VolCatParts);
 957       Dmsg3(100, "Tests : %d %d %d\n", (dev->VolCatInfo.VolCatParts > 0),
 958          ((dev->file_addr-dev->part_start) == dev->part_size),
 959          (dev->part <= dev->VolCatInfo.VolCatParts));
 960   }
 961 #endif
 962
 963    /* Check for DVD part file end */
 964    if (dev->at_eof() && dev->is_dvd() && dev->num_dvd_parts > 0 &&
 965         dev->part <= dev->num_dvd_parts) {
 966       Dmsg0(400, "Call dvd_open_next_part\n");
 967       if (dvd_open_next_part(dcr) < 0) {
 968          Jmsg3(dcr->jcr, M_FATAL, 0, _("Unable to open device part=%d %s: ERR=%s\n"),
 969                dev->part, dev->print_name(), dev->bstrerror());
 970          dev->dev_errno = EIO;
 971          return false;
 972       }
 973    }
 974
 975    retry = 0;
 976    errno = 0;
 977    stat = 0;
 978    do {
 979       if ((retry > 0 && stat == -1 && errno == EBUSY)) {
 980          berrno be;
 981          Dmsg4(100, "===== read retry=%d stat=%d errno=%d: ERR=%s\n",
 982                retry, stat, errno, be.bstrerror());
 983          bmicrosleep(10, 0);    /* pause a bit if busy or lots of errors */
 984          dev->clrerror(-1);
 985       }
 986       stat = dev->read(block->buf, (size_t)block->buf_len);
 987
 988    } while (stat == -1 && (errno == EBUSY || errno == EINTR || errno == EIO) && retry++ < 3);
 989    if (stat < 0) {
 990       berrno be;
 991       dev->clrerror(-1);
 992       Dmsg1(250, "Read device got: ERR=%s\n", be.bstrerror());
 993       block->read_len = 0;
 994       Mmsg5(dev->errmsg, _("Read error on fd=%d at file:blk %u:%u on device %s. ERR=%s.\n"),
 995          dev->fd(), dev->file, dev->block_num, dev->print_name(), be.bstrerror());
 996       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 997       if (dev->at_eof()) {        /* EOF just seen? */
 998          dev->set_eot();          /* yes, error => EOT */
 999       }
1000       return false;
1001    }
1002    Dmsg3(250, "Read device got %d bytes at %u:%u\n", stat,
1003       dev->file, dev->block_num);
1004    if (stat == 0) {             /* Got EOF ! */
1005       dev->block_num = 0;
1006       block->read_len = 0;
1007       Mmsg3(dev->errmsg, _("Read zero bytes at %u:%u on device %s.\n"),
1008          dev->file, dev->block_num, dev->print_name());
1009       if (dev->at_eof()) {       /* EOF already read? */
1010          dev->set_eot();         /* yes, 2 EOFs => EOT */
1011          return 0;
1012       }
1013       dev->set_ateof();
1014       return false;             /* return eof */
1015    }
1016
1017    /* Continue here for successful read */
1018
1019    block->read_len = stat;      /* save length read */
1020    if (block->read_len == 80 &&
1021         (dcr->VolCatInfo.LabelType != B_BACULA_LABEL ||
1022          dcr->device->label_type != B_BACULA_LABEL)) {
1023       /* ***FIXME*** should check label */
1024       Dmsg2(100, "Ignore 80 byte ANSI label at %u:%u\n", dev->file, dev->block_num);
1025       dev->clear_eof();
1026       goto reread;             /* skip ANSI/IBM label */
1027    }
1028
1029    if (block->read_len < BLKHDR2_LENGTH) {
1030       dev->dev_errno = EIO;
1031       Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Very short block of %d bytes on device %s discarded.\n"),
1032          dev->file, dev->block_num, block->read_len, dev->print_name());
1033       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1034       dev->set_short_block();
1035       block->read_len = block->binbuf = 0;
1036       return false;             /* return error */
1037    }
1038
1039    BlockNumber = block->BlockNumber + 1;
1040    if (!unser_block_header(jcr, dev, block)) {
1041       if (forge_on) {
1042          dev->file_addr += block->read_len;
1043          dev->file_size += block->read_len;
1044          goto reread;
1045       }
1046       return false;
1047    }
1048
1049    /*
1050     * If the block is bigger than the buffer, we reposition for
1051     *  re-reading the block, allocate a buffer of the correct size,
1052     *  and go re-read.
1053     */
1054    if (block->block_len > block->buf_len) {
1055       dev->dev_errno = EIO;
1056       Mmsg2(dev->errmsg,  _("Block length %u is greater than buffer %u. Attempting recovery.\n"),
1057          block->block_len, block->buf_len);
1058       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1059       Pmsg1(000, "%s", dev->errmsg);
1060       /* Attempt to reposition to re-read the block */
1061       if (dev->is_tape()) {
1062          Dmsg0(250, "BSR for reread; block too big for buffer.\n");
1063          if (!dev->bsr(1)) {
1064             Jmsg(jcr, M_ERROR, 0, "%s", dev->bstrerror());
1065             block->read_len = 0;
1066             return false;
1067          }
1068       } else {
1069          Dmsg0(250, "Seek to beginning of block for reread.\n");
1070          boffset_t pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
1071          pos -= block->read_len;
1072          dev->lseek(dcr, pos, SEEK_SET);
1073          dev->file_addr = pos;
1074       }
1075       Mmsg1(dev->errmsg, _("Setting block buffer size to %u bytes.\n"), block->block_len);
1076       Jmsg(jcr, M_INFO, 0, "%s", dev->errmsg);
1077       Pmsg1(000, "%s", dev->errmsg);
1078       /* Set new block length */
1079       dev->max_block_size = block->block_len;
1080       block->buf_len = block->block_len;
1081       free_memory(block->buf);
1082       block->buf = get_memory(block->buf_len);
1083       empty_block(block);
1084       looping++;
1085       goto reread;                    /* re-read block with correct block size */
1086    }
1087
1088    if (block->block_len > block->read_len) {
1089       dev->dev_errno = EIO;
1090       Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Short block of %d bytes on device %s discarded.\n"),
1091          dev->file, dev->block_num, block->read_len, dev->print_name());
1092       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1093       dev->set_short_block();
1094       block->read_len = block->binbuf = 0;
1095       return false;             /* return error */
1096    }
1097
1098    dev->clear_short_block();
1099    dev->clear_eof();
1100    dev->VolCatInfo.VolCatReads++;
1101    dev->VolCatInfo.VolCatRBytes += block->read_len;
1102
1103    dev->EndBlock = dev->block_num;
1104    dev->EndFile  = dev->file;
1105    dev->block_num++;
1106
1107    /* Update dcr values */
1108    if (dev->is_tape()) {
1109       dcr->EndBlock = dev->EndBlock;
1110       dcr->EndFile  = dev->EndFile;
1111    } else {
1112       uint64_t addr = dev->file_addr + block->read_len - 1;
1113       dcr->EndBlock = (uint32_t)addr;
1114       dcr->EndFile = (uint32_t)(addr >> 32);
1115       dev->block_num = dcr->EndBlock;
1116       dev->file = dcr->EndFile;
1117    }
1118    dcr->VolMediaId = dev->VolCatInfo.VolMediaId;
1119    dev->file_addr += block->read_len;
1120    dev->file_size += block->read_len;
1121
1122    /*
1123     * If we read a short block on disk,
1124     * seek to beginning of next block. This saves us
1125     * from shuffling blocks around in the buffer. Take a
1126     * look at this from an efficiency stand point later, but
1127     * it should only happen once at the end of each job.
1128     *
1129     * I've been lseek()ing negative relative to SEEK_CUR for 30
1130     *   years now. However, it seems that with the new off_t definition,
1131     *   it is not possible to seek negative amounts, so we use two
1132     *   lseek(). One to get the position, then the second to do an
1133     *   absolute positioning -- so much for efficiency.  KES Sep 02.
1134     */
1135    Dmsg0(250, "At end of read block\n");
1136    if (block->read_len > block->block_len && !dev->is_tape()) {
1137       char ed1[50];
1138       boffset_t pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
1139       Dmsg1(250, "Current lseek pos=%s\n", edit_int64(pos, ed1));
1140       pos -= (block->read_len - block->block_len);
1141       dev->lseek(dcr, pos, SEEK_SET);
1142       Dmsg3(250, "Did lseek pos=%s blk_size=%d rdlen=%d\n",
1143          edit_int64(pos, ed1), block->block_len,
1144             block->read_len);
1145       dev->file_addr = pos;
1146       dev->file_size = pos;
1147    }
1148    Dmsg2(250, "Exit read_block read_len=%d block_len=%d\n",
1149       block->read_len, block->block_len);
1150    block->block_read = true;
1151    return true;
1152 }