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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-2008 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 /*
 709  * If this routine is called, we do our bookkeeping and
 710  *   then assure that the volume will not be written any
 711  *   more.
 712  */
 713 static bool terminate_writing_volume(DCR *dcr)
 714 {
 715    DEVICE *dev = dcr->dev;
 716    bool ok = true;
 717
 718    /* Create a JobMedia record to indicated end of tape */
 719    dev->VolCatInfo.VolCatFiles = dev->file;
 720    if (!dir_create_jobmedia_record(dcr)) {
 721       Dmsg0(190, "Error from create JobMedia\n");
 722       dev->dev_errno = EIO;
 723        Jmsg(dcr->jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
 724             dcr->VolCatInfo.VolCatName, dcr->jcr->Job);
 725        ok = false;
 726        goto bail_out;
 727    }
 728    dcr->block->write_failed = true;
 729    if (!dev->weof(1)) {         /* end the tape */
 730       dev->VolCatInfo.VolCatErrors++;
 731       Jmsg(dcr->jcr, M_ERROR, 0, _("Error writing final EOF to tape. This Volume may not be readable.\n"
 732            "%s"), dev->errmsg);
 733       ok = false;
 734       Dmsg0(100, "WEOF error.\n");
 735    }
 736    if (ok) {
 737       ok = write_ansi_ibm_labels(dcr, ANSI_EOV_LABEL, dev->VolHdr.VolumeName);
 738    }
 739    bstrncpy(dev->VolCatInfo.VolCatStatus, "Full", sizeof(dev->VolCatInfo.VolCatStatus));
 740    dev->VolCatInfo.VolCatFiles = dev->file;   /* set number of files */
 741
 742    if (dev->is_dvd()) {
 743       if (!dvd_write_part(dcr)) {             /* write last part */
 744          dev->VolCatInfo.VolCatErrors++;
 745          Jmsg(dcr->jcr, M_FATAL, 0, _("Error writing final part to DVD. "
 746                                  "This Volume may not be readable.\n%s"),
 747                          dev->errmsg);
 748          ok = false;
 749          Dmsg0(100, "dvd_write_part error.\n");
 750       }
 751       dev->VolCatInfo.VolCatParts = dev->num_dvd_parts;
 752    }
 753
 754    if (!dir_update_volume_info(dcr, false, true)) {
 755       ok = false;
 756    }
 757    Dmsg1(100, "dir_update_volume_info terminate writing -- %s\n", ok?"OK":"ERROR");
 758
 759    /*
 760     * Walk through all attached dcrs setting flag to call
 761     * set_new_file_parameters() when that dcr is next used.
 762     */
 763    DCR *mdcr;
 764    foreach_dlist(mdcr, dev->attached_dcrs) {
 765       if (mdcr->jcr->JobId == 0) {
 766          continue;
 767       }
 768       mdcr->NewFile = true;        /* set reminder to do set_new_file_params */
 769    }
 770    /* Set new file/block parameters for current dcr */
 771    set_new_file_parameters(dcr);
 772
 773    if (ok && dev->has_cap(CAP_TWOEOF) && !dev->weof(1)) {  /* end the tape */
 774       dev->VolCatInfo.VolCatErrors++;
 775       /* This may not be fatal since we already wrote an EOF */
 776       Jmsg(dcr->jcr, M_ERROR, 0, "%s", dev->errmsg);
 777    }
 778
 779 bail_out:
 780    dev->set_ateot();                  /* no more writing this tape */
 781    Dmsg1(50, "*** Leave terminate_writing_volume -- %s\n", ok?"OK":"ERROR");
 782    return ok;
 783 }
 784
 785 /*
 786  * Do bookkeeping when a new file is created on a Volume. This is
 787  *  also done for disk files to generate the jobmedia records for
 788  *  quick seeking.
 789  */
 790 static bool do_new_file_bookkeeping(DCR *dcr)
 791 {
 792    DEVICE *dev = dcr->dev;
 793    JCR *jcr = dcr->jcr;
 794
 795    /* Create a JobMedia record so restore can seek */
 796    if (!dir_create_jobmedia_record(dcr)) {
 797       Dmsg0(190, "Error from create_job_media.\n");
 798       dev->dev_errno = EIO;
 799       Jmsg(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
 800            dcr->VolCatInfo.VolCatName, jcr->Job);
 801       terminate_writing_volume(dcr);
 802       dev->dev_errno = EIO;
 803       return false;
 804    }
 805    dev->VolCatInfo.VolCatFiles = dev->file;
 806    if (!dir_update_volume_info(dcr, false, false)) {
 807       Dmsg0(190, "Error from update_vol_info.\n");
 808       terminate_writing_volume(dcr);
 809       dev->dev_errno = EIO;
 810       return false;
 811    }
 812    Dmsg0(100, "dir_update_volume_info max file size -- OK\n");
 813
 814    /*
 815     * Walk through all attached dcrs setting flag to call
 816     * set_new_file_parameters() when that dcr is next used.
 817     */
 818    DCR *mdcr;
 819    foreach_dlist(mdcr, dev->attached_dcrs) {
 820       if (mdcr->jcr->JobId == 0) {
 821          continue;
 822       }
 823       mdcr->NewFile = true;        /* set reminder to do set_new_file_params */
 824    }
 825    /* Set new file/block parameters for current dcr */
 826    set_new_file_parameters(dcr);
 827    return true;
 828 }
 829
 830 /*
 831  * Do all checks for DVD sizes during writing.
 832  */
 833 static bool do_dvd_size_checks(DCR *dcr)
 834 {
 835    DEVICE *dev = dcr->dev;
 836    JCR *jcr = dcr->jcr;
 837    DEV_BLOCK *block = dcr->block;
 838
 839    /* Don't go further if the device is not a dvd */
 840    if (!dev->is_dvd()) {
 841       return true;
 842    }
 843
 844    /* Limit maximum part size to value specified by user
 845     */
 846    if (dev->max_part_size > 0 && ((dev->part_size + block->binbuf) >= dev->max_part_size)) {
 847       if (dev->part < dev->num_dvd_parts) {
 848          Jmsg3(dcr->jcr, M_FATAL, 0, _("Error while writing, current part number"
 849                " is less than the total number of parts (%d/%d, device=%s)\n"),
 850                dev->part, dev->num_dvd_parts, dev->print_name());
 851          dev->dev_errno = EIO;
 852          return false;
 853       }
 854
 855       if (dvd_open_next_part(dcr) < 0) {
 856          Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device next part %s: ERR=%s\n"),
 857                 dev->print_name(), dev->bstrerror());
 858          dev->dev_errno = EIO;
 859          return false;
 860       }
 861
 862       dev->VolCatInfo.VolCatParts = dev->num_dvd_parts;
 863
 864       if (!dir_update_volume_info(dcr, false, false)) {
 865          Dmsg0(190, "Error from update_vol_info.\n");
 866          dev->dev_errno = EIO;
 867          return false;
 868       }
 869    }
 870
 871    dev->update_freespace();
 872
 873    if (!dev->is_freespace_ok()) { /* Error while getting free space */
 874       char ed1[50], ed2[50];
 875       Dmsg1(100, "Cannot get free space on the device ERR=%s.\n", dev->errmsg);
 876       Jmsg(jcr, M_FATAL, 0, _("End of Volume \"%s\" at %u:%u on device %s "
 877          "(part_size=%s, free_space=%s, free_space_errno=%d, errmsg=%s).\n"),
 878            dev->VolCatInfo.VolCatName,
 879            dev->file, dev->block_num, dev->print_name(),
 880            edit_uint64_with_commas(dev->part_size, ed1), edit_uint64_with_commas(dev->free_space, ed2),
 881            dev->free_space_errno, dev->errmsg);
 882       dev->dev_errno = dev->free_space_errno;
 883       return false;
 884    }
 885
 886    if ((dev->is_freespace_ok() && (dev->part_size + block->binbuf) >= dev->free_space)) {
 887       char ed1[50], ed2[50];
 888       Dmsg0(100, "==== Just enough free space on the device to write the current part...\n");
 889       Jmsg(jcr, M_INFO, 0, _("End of Volume \"%s\" at %u:%u on device %s "
 890          "(part_size=%s, free_space=%s, free_space_errno=%d).\n"),
 891             dev->VolCatInfo.VolCatName,
 892             dev->file, dev->block_num, dev->print_name(),
 893             edit_uint64_with_commas(dev->part_size, ed1), edit_uint64_with_commas(dev->free_space, ed2),
 894             dev->free_space_errno);
 895       terminate_writing_volume(dcr);
 896       dev->dev_errno = ENOSPC;
 897       return false;
 898    }
 899    return true;
 900 }
 901
 902
 903 /*
 904  * Read block with locking
 905  *
 906  */
 907 bool read_block_from_device(DCR *dcr, bool check_block_numbers)
 908 {
 909    bool ok;
 910    DEVICE *dev = dcr->dev;
 911    Dmsg0(250, "Enter read_block_from_device\n");
 912    dev->r_dlock();
 913    ok = read_block_from_dev(dcr, check_block_numbers);
 914    dev->dunlock();
 915    Dmsg0(250, "Leave read_block_from_device\n");
 916    return ok;
 917 }
 918
 919 /*
 920  * Read the next block into the block structure and unserialize
 921  *  the block header.  For a file, the block may be partially
 922  *  or completely in the current buffer.
 923  */
 924 bool read_block_from_dev(DCR *dcr, bool check_block_numbers)
 925 {
 926    ssize_t stat;
 927    int looping;
 928    uint32_t BlockNumber;
 929    int retry;
 930    JCR *jcr = dcr->jcr;
 931    DEVICE *dev = dcr->dev;
 932    DEV_BLOCK *block = dcr->block;
 933
 934    ASSERT(dev->is_open());
 935
 936    if (dev->at_eot()) {
 937       return false;
 938    }
 939    looping = 0;
 940    Dmsg1(250, "Full read in read_block_from_device() len=%d\n",
 941          block->buf_len);
 942 reread:
 943    if (looping > 1) {
 944       dev->dev_errno = EIO;
 945       Mmsg1(dev->errmsg, _("Block buffer size looping problem on device %s\n"),
 946          dev->print_name());
 947       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 948       block->read_len = 0;
 949       return false;
 950    }
 951
 952 // #define lots_of_debug
 953 #ifdef lots_of_debug
 954    if (dev->at_eof() && dev->is_dvd()) {
 955       Dmsg1(100, "file_size=%u\n",(unsigned int)dev->file_size);
 956       Dmsg1(100, "file_addr=%u\n",(unsigned int)dev->file_addr);
 957       Dmsg1(100, "lseek=%u\n",(unsigned int)lseek(dev->fd(), 0, SEEK_CUR));
 958       Dmsg1(100, "part_start=%u\n",(unsigned int)dev->part_start);
 959       Dmsg1(100, "part_size=%u\n", (unsigned int)dev->part_size);
 960       Dmsg2(100, "part=%u num_dvd_parts=%u\n", dev->part, dev->num_dvd_parts);
 961       Dmsg1(100, "VolCatInfo.VolCatParts=%u\n", (unsigned int)dev->VolCatInfo.VolCatParts);
 962       Dmsg3(100, "Tests : %d %d %d\n", (dev->VolCatInfo.VolCatParts > 0),
 963          ((dev->file_addr-dev->part_start) == dev->part_size),
 964          (dev->part <= dev->VolCatInfo.VolCatParts));
 965   }
 966 #endif
 967
 968    /* Check for DVD part file end */
 969    if (dev->at_eof() && dev->is_dvd() && dev->num_dvd_parts > 0 &&
 970         dev->part <= dev->num_dvd_parts) {
 971       Dmsg0(400, "Call dvd_open_next_part\n");
 972       if (dvd_open_next_part(dcr) < 0) {
 973          Jmsg3(dcr->jcr, M_FATAL, 0, _("Unable to open device part=%d %s: ERR=%s\n"),
 974                dev->part, dev->print_name(), dev->bstrerror());
 975          dev->dev_errno = EIO;
 976          return false;
 977       }
 978    }
 979
 980    retry = 0;
 981    errno = 0;
 982    stat = 0;
 983    do {
 984       if ((retry > 0 && stat == -1 && errno == EBUSY)) {
 985          berrno be;
 986          Dmsg4(100, "===== read retry=%d stat=%d errno=%d: ERR=%s\n",
 987                retry, stat, errno, be.bstrerror());
 988          bmicrosleep(10, 0);    /* pause a bit if busy or lots of errors */
 989          dev->clrerror(-1);
 990       }
 991       stat = dev->read(block->buf, (size_t)block->buf_len);
 992
 993    } while (stat == -1 && (errno == EBUSY || errno == EINTR || errno == EIO) && retry++ < 3);
 994    if (stat < 0) {
 995       berrno be;
 996       dev->clrerror(-1);
 997       Dmsg1(250, "Read device got: ERR=%s\n", be.bstrerror());
 998       block->read_len = 0;
 999       Mmsg5(dev->errmsg, _("Read error on fd=%d at file:blk %u:%u on device %s. ERR=%s.\n"),
1000          dev->fd(), dev->file, dev->block_num, dev->print_name(), be.bstrerror());
1001       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1002       if (dev->at_eof()) {        /* EOF just seen? */
1003          dev->set_eot();          /* yes, error => EOT */
1004       }
1005       return false;
1006    }
1007    Dmsg3(250, "Read device got %d bytes at %u:%u\n", stat,
1008       dev->file, dev->block_num);
1009    if (stat == 0) {             /* Got EOF ! */
1010       dev->block_num = 0;
1011       block->read_len = 0;
1012       Mmsg3(dev->errmsg, _("Read zero bytes at %u:%u on device %s.\n"),
1013          dev->file, dev->block_num, dev->print_name());
1014       if (dev->at_eof()) {       /* EOF already read? */
1015          dev->set_eot();         /* yes, 2 EOFs => EOT */
1016          return 0;
1017       }
1018       dev->set_ateof();
1019       return false;             /* return eof */
1020    }
1021
1022    /* Continue here for successful read */
1023
1024    block->read_len = stat;      /* save length read */
1025    if (block->read_len == 80 &&
1026         (dcr->VolCatInfo.LabelType != B_BACULA_LABEL ||
1027          dcr->device->label_type != B_BACULA_LABEL)) {
1028       /* ***FIXME*** should check label */
1029       Dmsg2(100, "Ignore 80 byte ANSI label at %u:%u\n", dev->file, dev->block_num);
1030       dev->clear_eof();
1031       goto reread;             /* skip ANSI/IBM label */
1032    }
1033
1034    if (block->read_len < BLKHDR2_LENGTH) {
1035       dev->dev_errno = EIO;
1036       Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Very short block of %d bytes on device %s discarded.\n"),
1037          dev->file, dev->block_num, block->read_len, dev->print_name());
1038       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1039       dev->set_short_block();
1040       block->read_len = block->binbuf = 0;
1041       return false;             /* return error */
1042    }
1043
1044    BlockNumber = block->BlockNumber + 1;
1045    if (!unser_block_header(jcr, dev, block)) {
1046       if (forge_on) {
1047          dev->file_addr += block->read_len;
1048          dev->file_size += block->read_len;
1049          goto reread;
1050       }
1051       return false;
1052    }
1053
1054    /*
1055     * If the block is bigger than the buffer, we reposition for
1056     *  re-reading the block, allocate a buffer of the correct size,
1057     *  and go re-read.
1058     */
1059    if (block->block_len > block->buf_len) {
1060       dev->dev_errno = EIO;
1061       Mmsg2(dev->errmsg,  _("Block length %u is greater than buffer %u. Attempting recovery.\n"),
1062          block->block_len, block->buf_len);
1063       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1064       Pmsg1(000, "%s", dev->errmsg);
1065       /* Attempt to reposition to re-read the block */
1066       if (dev->is_tape()) {
1067          Dmsg0(250, "BSR for reread; block too big for buffer.\n");
1068          if (!dev->bsr(1)) {
1069             Jmsg(jcr, M_ERROR, 0, "%s", dev->bstrerror());
1070             block->read_len = 0;
1071             return false;
1072          }
1073       } else {
1074          Dmsg0(250, "Seek to beginning of block for reread.\n");
1075          boffset_t pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
1076          pos -= block->read_len;
1077          dev->lseek(dcr, pos, SEEK_SET);
1078          dev->file_addr = pos;
1079       }
1080       Mmsg1(dev->errmsg, _("Setting block buffer size to %u bytes.\n"), block->block_len);
1081       Jmsg(jcr, M_INFO, 0, "%s", dev->errmsg);
1082       Pmsg1(000, "%s", dev->errmsg);
1083       /* Set new block length */
1084       dev->max_block_size = block->block_len;
1085       block->buf_len = block->block_len;
1086       free_memory(block->buf);
1087       block->buf = get_memory(block->buf_len);
1088       empty_block(block);
1089       looping++;
1090       goto reread;                    /* re-read block with correct block size */
1091    }
1092
1093    if (block->block_len > block->read_len) {
1094       dev->dev_errno = EIO;
1095       Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Short block of %d bytes on device %s discarded.\n"),
1096          dev->file, dev->block_num, block->read_len, dev->print_name());
1097       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1098       dev->set_short_block();
1099       block->read_len = block->binbuf = 0;
1100       return false;             /* return error */
1101    }
1102
1103    dev->clear_short_block();
1104    dev->clear_eof();
1105    dev->VolCatInfo.VolCatReads++;
1106    dev->VolCatInfo.VolCatRBytes += block->read_len;
1107
1108    dev->EndBlock = dev->block_num;
1109    dev->EndFile  = dev->file;
1110    dev->block_num++;
1111
1112    /* Update dcr values */
1113    if (dev->is_tape()) {
1114       dcr->EndBlock = dev->EndBlock;
1115       dcr->EndFile  = dev->EndFile;
1116    } else {
1117       uint64_t addr = dev->file_addr + block->read_len - 1;
1118       dcr->EndBlock = (uint32_t)addr;
1119       dcr->EndFile = (uint32_t)(addr >> 32);
1120       dev->block_num = dcr->EndBlock;
1121       dev->file = dcr->EndFile;
1122    }
1123    dcr->VolMediaId = dev->VolCatInfo.VolMediaId;
1124    dev->file_addr += block->read_len;
1125    dev->file_size += block->read_len;
1126
1127    /*
1128     * If we read a short block on disk,
1129     * seek to beginning of next block. This saves us
1130     * from shuffling blocks around in the buffer. Take a
1131     * look at this from an efficiency stand point later, but
1132     * it should only happen once at the end of each job.
1133     *
1134     * I've been lseek()ing negative relative to SEEK_CUR for 30
1135     *   years now. However, it seems that with the new off_t definition,
1136     *   it is not possible to seek negative amounts, so we use two
1137     *   lseek(). One to get the position, then the second to do an
1138     *   absolute positioning -- so much for efficiency.  KES Sep 02.
1139     */
1140    Dmsg0(250, "At end of read block\n");
1141    if (block->read_len > block->block_len && !dev->is_tape()) {
1142       char ed1[50];
1143       boffset_t pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
1144       Dmsg1(250, "Current lseek pos=%s\n", edit_int64(pos, ed1));
1145       pos -= (block->read_len - block->block_len);
1146       dev->lseek(dcr, pos, SEEK_SET);
1147       Dmsg3(250, "Did lseek pos=%s blk_size=%d rdlen=%d\n",
1148          edit_int64(pos, ed1), block->block_len,
1149             block->read_len);
1150       dev->file_addr = pos;
1151       dev->file_size = pos;
1152    }
1153    Dmsg2(250, "Exit read_block read_len=%d block_len=%d\n",
1154       block->read_len, block->block_len);
1155    block->block_read = true;
1156    return true;
1157 }