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       } else {
 378          set_new_file_parameters(dcr);
 379       }
 380    }
 381
 382    if (!write_block_to_dev(dcr)) {
 383        if (job_canceled(jcr) || jcr->JobType == JT_SYSTEM) {
 384           stat = false;
 385        } else {
 386           stat = fixup_device_block_write_error(dcr);
 387        }
 388    }
 389
 390 bail_out:
 391    if (!dcr->is_dev_locked()) {        /* did we lock dev above? */
 392       /* note, do not change this to dcr->dunlock */
 393       dev->dunlock();                  /* unlock it now */
 394    }
 395    return stat;
 396 }
 397
 398 /*
 399  * Write a block to the device
 400  *
 401  *  Returns: true  on success or EOT
 402  *           false on hard error
 403  */
 404 bool write_block_to_dev(DCR *dcr)
 405 {
 406    ssize_t stat = 0;
 407    uint32_t wlen;                     /* length to write */
 408    int hit_max1, hit_max2;
 409    bool ok = true;
 410    DEVICE *dev = dcr->dev;
 411    JCR *jcr = dcr->jcr;
 412    DEV_BLOCK *block = dcr->block;
 413
 414 #ifdef NO_TAPE_WRITE_TEST
 415    empty_block(block);
 416    return true;
 417 #endif
 418    ASSERT(block->binbuf == ((uint32_t) (block->bufp - block->buf)));
 419    ASSERT(dev->is_open());
 420
 421    /* dump_block(block, "before write"); */
 422    if (dev->at_weot()) {
 423       Dmsg0(100, "return write_block_to_dev with ST_WEOT\n");
 424       dev->dev_errno = ENOSPC;
 425       Jmsg(jcr, M_FATAL, 0,  _("Cannot write block. Device at EOM.\n"));
 426       return false;
 427    }
 428    if (!dev->can_append()) {
 429       dev->dev_errno = EIO;
 430       Jmsg(jcr, M_FATAL, 0, _("Attempt to write on read-only Volume.\n"));
 431       return false;
 432    }
 433    wlen = block->binbuf;
 434    if (wlen <= WRITE_BLKHDR_LENGTH) {  /* Does block have data in it? */
 435       Dmsg0(100, "return write_block_to_dev no data to write\n");
 436       return true;
 437    }
 438    /*
 439     * Clear to the end of the buffer if it is not full,
 440     *  and on tape devices, apply min and fixed blocking.
 441     */
 442    if (wlen != block->buf_len) {
 443       uint32_t blen;                  /* current buffer length */
 444
 445       Dmsg2(250, "binbuf=%d buf_len=%d\n", block->binbuf, block->buf_len);
 446       blen = wlen;
 447
 448       /* Adjust write size to min/max for tapes only */
 449       if (dev->is_tape()) {
 450          /* check for fixed block size */
 451          if (dev->min_block_size == dev->max_block_size) {
 452             wlen = block->buf_len;    /* fixed block size already rounded */
 453          /* Check for min block size */
 454          } else if (wlen < dev->min_block_size) {
 455             wlen =  ((dev->min_block_size + TAPE_BSIZE - 1) / TAPE_BSIZE) * TAPE_BSIZE;
 456          /* Ensure size is rounded */
 457          } else {
 458             wlen = ((wlen + TAPE_BSIZE - 1) / TAPE_BSIZE) * TAPE_BSIZE;
 459          }
 460       }
 461       if (wlen-blen > 0) {
 462          memset(block->bufp, 0, wlen-blen); /* clear garbage */
 463       }
 464    }
 465
 466    ser_block_header(block);
 467
 468    /* Limit maximum Volume size to value specified by user */
 469    hit_max1 = (dev->max_volume_size > 0) &&
 470        ((dev->VolCatInfo.VolCatBytes + block->binbuf)) >= dev->max_volume_size;
 471    hit_max2 = (dev->VolCatInfo.VolCatMaxBytes > 0) &&
 472        ((dev->VolCatInfo.VolCatBytes + block->binbuf)) >= dev->VolCatInfo.VolCatMaxBytes;
 473    if (hit_max1 || hit_max2) {
 474       char ed1[50];
 475       uint64_t max_cap;
 476       Dmsg0(100, "==== Output bytes Triggered medium max capacity.\n");
 477       if (hit_max1) {
 478          max_cap = dev->max_volume_size;
 479       } else {
 480          max_cap = dev->VolCatInfo.VolCatMaxBytes;
 481       }
 482       Jmsg(jcr, M_INFO, 0, _("User defined maximum volume capacity %s exceeded on device %s.\n"),
 483             edit_uint64_with_commas(max_cap, ed1),  dev->print_name());
 484       terminate_writing_volume(dcr);
 485       reread_last_block(dcr);   /* DEBUG */
 486       dev->dev_errno = ENOSPC;
 487       return false;
 488    }
 489
 490    /* Limit maximum File size on volume to user specified value */
 491    if ((dev->max_file_size > 0) &&
 492        (dev->file_size+block->binbuf) >= dev->max_file_size) {
 493       dev->file_size = 0;             /* reset file size */
 494
 495       if (!dev->weof(1)) {            /* write eof */
 496          Dmsg0(190, "WEOF error in max file size.\n");
 497          Jmsg(jcr, M_FATAL, 0, _("Unable to write EOF. ERR=%s\n"),
 498             dev->bstrerror());
 499          terminate_writing_volume(dcr);
 500          dev->dev_errno = ENOSPC;
 501          return false;
 502       }
 503       if (!write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName)) {
 504          return false;
 505       }
 506
 507       if (!do_new_file_bookkeeping(dcr)) {
 508          /* Error message already sent */
 509          return false;
 510       }
 511    }
 512
 513    if (!do_dvd_size_checks(dcr)) {
 514       /* Error message already sent */
 515       return false;
 516    }
 517
 518    dev->VolCatInfo.VolCatWrites++;
 519    Dmsg1(1300, "Write block of %u bytes\n", wlen);
 520 #ifdef DEBUG_BLOCK_ZEROING
 521    uint32_t *bp = (uint32_t *)block->buf;
 522    if (bp[0] == 0 && bp[1] == 0 && bp[2] == 0 && block->buf[12] == 0) {
 523       Jmsg0(jcr, M_ABORT, 0, _("Write block header zeroed.\n"));
 524    }
 525 #endif
 526
 527    /*
 528     * Do write here, make a somewhat feeble attempt to recover from
 529     *  I/O errors, or from the OS telling us it is busy.
 530     */
 531    int retry = 0;
 532    errno = 0;
 533    stat = 0;
 534    do {
 535       if (retry > 0 && stat == -1 && errno == EBUSY) {
 536          berrno be;
 537          Dmsg4(100, "===== write retry=%d stat=%d errno=%d: ERR=%s\n",
 538                retry, stat, errno, be.bstrerror());
 539          bmicrosleep(5, 0);    /* pause a bit if busy or lots of errors */
 540          dev->clrerror(-1);
 541       }
 542       stat = dev->write(block->buf, (size_t)wlen);
 543
 544    } while (stat == -1 && (errno == EBUSY || errno == EIO) && retry++ < 3);
 545
 546 #ifdef DEBUG_BLOCK_ZEROING
 547    if (bp[0] == 0 && bp[1] == 0 && bp[2] == 0 && block->buf[12] == 0) {
 548       Jmsg0(jcr, M_ABORT, 0, _("Write block header zeroed.\n"));
 549    }
 550 #endif
 551
 552    if (stat != (ssize_t)wlen) {
 553       /* Some devices simply report EIO when the volume is full.
 554        * With a little more thought we may be able to check
 555        * capacity and distinguish real errors and EOT
 556        * conditions.  In any case, we probably want to
 557        * simulate an End of Medium.
 558        */
 559       if (stat == -1) {
 560          berrno be;
 561          dev->clrerror(-1);
 562          if (dev->dev_errno == 0) {
 563             dev->dev_errno = ENOSPC;        /* out of space */
 564          }
 565          if (dev->dev_errno != ENOSPC) {
 566             dev->VolCatInfo.VolCatErrors++;
 567             Jmsg4(jcr, M_ERROR, 0, _("Write error at %u:%u on device %s. ERR=%s.\n"),
 568                dev->file, dev->block_num, dev->print_name(), be.bstrerror());
 569          }
 570       } else {
 571         dev->dev_errno = ENOSPC;            /* out of space */
 572       }
 573       if (dev->dev_errno == ENOSPC) {
 574          Jmsg(jcr, M_INFO, 0, _("End of Volume \"%s\" at %u:%u on device %s. Write of %u bytes got %d.\n"),
 575             dev->VolCatInfo.VolCatName,
 576             dev->file, dev->block_num, dev->print_name(), wlen, stat);
 577       }
 578       if (debug_level >= 100) {
 579          berrno be;
 580          Dmsg7(100, "=== Write error. fd=%d size=%u rtn=%d dev_blk=%d blk_blk=%d errno=%d: ERR=%s\n",
 581             dev->fd(), wlen, stat, dev->block_num, block->BlockNumber,
 582             dev->dev_errno, be.bstrerror(dev->dev_errno));
 583       }
 584
 585       ok = terminate_writing_volume(dcr);
 586       if (!ok && !forge_on) {
 587          return false;
 588       }
 589       if (ok) {
 590          reread_last_block(dcr);
 591       }
 592       return false;
 593    }
 594
 595    /* We successfully wrote the block, now do housekeeping */
 596    Dmsg2(1300, "VolCatBytes=%d newVolCatBytes=%d\n", (int)dev->VolCatInfo.VolCatBytes,
 597       (int)(dev->VolCatInfo.VolCatBytes+wlen));
 598    dev->VolCatInfo.VolCatBytes += wlen;
 599    dev->VolCatInfo.VolCatBlocks++;
 600    dev->EndBlock = dev->block_num;
 601    dev->EndFile  = dev->file;
 602    dev->LastBlock = block->BlockNumber;
 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 #ifdef xxx
 693             if (lblock->VolSessionId == block->VolSessionId &&
 694                 lblock->VolSessionTime == block->VolSessionTime &&
 695                 lblock->BlockNumber+1 != block->BlockNumber) {
 696 #endif
 697             if (lblock->BlockNumber != dev->LastBlock) {
 698                Jmsg(jcr, M_ERROR, 0, _(
 699 "Re-read of last block OK, but block numbers differ. Read block=%u Want block=%u.\n"),
 700                     lblock->BlockNumber, dev->LastBlock);
 701             } else {
 702                Jmsg(jcr, M_INFO, 0, _("Re-read of last block succeeded.\n"));
 703             }
 704          }
 705          free_block(lblock);
 706          dcr->block = block;
 707       }
 708    }
 709 #endif
 710 }
 711
 712 /*
 713  * If this routine is called, we do our bookkeeping and
 714  *   then assure that the volume will not be written any
 715  *   more.
 716  */
 717 static bool terminate_writing_volume(DCR *dcr)
 718 {
 719    DEVICE *dev = dcr->dev;
 720    bool ok = true;
 721
 722    /* Create a JobMedia record to indicated end of tape */
 723    dev->VolCatInfo.VolCatFiles = dev->file;
 724    if (!dir_create_jobmedia_record(dcr)) {
 725       Dmsg0(190, "Error from create JobMedia\n");
 726       dev->dev_errno = EIO;
 727        Jmsg(dcr->jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
 728             dcr->VolCatInfo.VolCatName, dcr->jcr->Job);
 729        ok = false;
 730        goto bail_out;
 731    }
 732    dcr->block->write_failed = true;
 733    if (!dev->weof(1)) {         /* end the tape */
 734       dev->VolCatInfo.VolCatErrors++;
 735       Jmsg(dcr->jcr, M_ERROR, 0, _("Error writing final EOF to tape. This Volume may not be readable.\n"
 736            "%s"), dev->errmsg);
 737       ok = false;
 738       Dmsg0(100, "WEOF error.\n");
 739    }
 740    if (ok) {
 741       ok = write_ansi_ibm_labels(dcr, ANSI_EOV_LABEL, dev->VolHdr.VolumeName);
 742    }
 743    bstrncpy(dev->VolCatInfo.VolCatStatus, "Full", sizeof(dev->VolCatInfo.VolCatStatus));
 744    dev->VolCatInfo.VolCatFiles = dev->file;   /* set number of files */
 745
 746    if (dev->is_dvd()) {
 747       if (!dvd_write_part(dcr)) {             /* write last part */
 748          dev->VolCatInfo.VolCatErrors++;
 749          Jmsg(dcr->jcr, M_FATAL, 0, _("Error writing final part to DVD. "
 750                                  "This Volume may not be readable.\n%s"),
 751                          dev->errmsg);
 752          ok = false;
 753          Dmsg0(100, "dvd_write_part error.\n");
 754       }
 755       dev->VolCatInfo.VolCatParts = dev->num_dvd_parts;
 756    }
 757
 758    if (!dir_update_volume_info(dcr, false, true)) {
 759       ok = false;
 760    }
 761    Dmsg1(100, "dir_update_volume_info terminate writing -- %s\n", ok?"OK":"ERROR");
 762
 763    /*
 764     * Walk through all attached dcrs setting flag to call
 765     * set_new_file_parameters() when that dcr is next used.
 766     */
 767    DCR *mdcr;
 768    foreach_dlist(mdcr, dev->attached_dcrs) {
 769       if (mdcr->jcr->JobId == 0) {
 770          continue;
 771       }
 772       mdcr->NewFile = true;        /* set reminder to do set_new_file_params */
 773    }
 774    /* Set new file/block parameters for current dcr */
 775    set_new_file_parameters(dcr);
 776
 777    if (ok && dev->has_cap(CAP_TWOEOF) && !dev->weof(1)) {  /* end the tape */
 778       dev->VolCatInfo.VolCatErrors++;
 779       /* This may not be fatal since we already wrote an EOF */
 780       Jmsg(dcr->jcr, M_ERROR, 0, "%s", dev->errmsg);
 781    }
 782
 783 bail_out:
 784    dev->set_ateot();                  /* no more writing this tape */
 785    Dmsg1(50, "*** Leave terminate_writing_volume -- %s\n", ok?"OK":"ERROR");
 786    return ok;
 787 }
 788
 789 /*
 790  * Do bookkeeping when a new file is created on a Volume. This is
 791  *  also done for disk files to generate the jobmedia records for
 792  *  quick seeking.
 793  */
 794 static bool do_new_file_bookkeeping(DCR *dcr)
 795 {
 796    DEVICE *dev = dcr->dev;
 797    JCR *jcr = dcr->jcr;
 798
 799    /* Create a JobMedia record so restore can seek */
 800    if (!dir_create_jobmedia_record(dcr)) {
 801       Dmsg0(190, "Error from create_job_media.\n");
 802       dev->dev_errno = EIO;
 803       Jmsg(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"),
 804            dcr->VolCatInfo.VolCatName, jcr->Job);
 805       terminate_writing_volume(dcr);
 806       dev->dev_errno = EIO;
 807       return false;
 808    }
 809    dev->VolCatInfo.VolCatFiles = dev->file;
 810    if (!dir_update_volume_info(dcr, false, false)) {
 811       Dmsg0(190, "Error from update_vol_info.\n");
 812       terminate_writing_volume(dcr);
 813       dev->dev_errno = EIO;
 814       return false;
 815    }
 816    Dmsg0(100, "dir_update_volume_info max file size -- OK\n");
 817
 818    /*
 819     * Walk through all attached dcrs setting flag to call
 820     * set_new_file_parameters() when that dcr is next used.
 821     */
 822    DCR *mdcr;
 823    foreach_dlist(mdcr, dev->attached_dcrs) {
 824       if (mdcr->jcr->JobId == 0) {
 825          continue;
 826       }
 827       mdcr->NewFile = true;        /* set reminder to do set_new_file_params */
 828    }
 829    /* Set new file/block parameters for current dcr */
 830    set_new_file_parameters(dcr);
 831    return true;
 832 }
 833
 834 /*
 835  * Do all checks for DVD sizes during writing.
 836  */
 837 static bool do_dvd_size_checks(DCR *dcr)
 838 {
 839    DEVICE *dev = dcr->dev;
 840    JCR *jcr = dcr->jcr;
 841    DEV_BLOCK *block = dcr->block;
 842
 843    /* Don't go further if the device is not a dvd */
 844    if (!dev->is_dvd()) {
 845       return true;
 846    }
 847
 848    /* Limit maximum part size to value specified by user
 849     */
 850    if (dev->max_part_size > 0 && ((dev->part_size + block->binbuf) >= dev->max_part_size)) {
 851       if (dev->part < dev->num_dvd_parts) {
 852          Jmsg3(dcr->jcr, M_FATAL, 0, _("Error while writing, current part number"
 853                " is less than the total number of parts (%d/%d, device=%s)\n"),
 854                dev->part, dev->num_dvd_parts, dev->print_name());
 855          dev->dev_errno = EIO;
 856          return false;
 857       }
 858
 859       if (dvd_open_next_part(dcr) < 0) {
 860          Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device next part %s: ERR=%s\n"),
 861                 dev->print_name(), dev->bstrerror());
 862          dev->dev_errno = EIO;
 863          return false;
 864       }
 865
 866       dev->VolCatInfo.VolCatParts = dev->num_dvd_parts;
 867
 868       if (!dir_update_volume_info(dcr, false, false)) {
 869          Dmsg0(190, "Error from update_vol_info.\n");
 870          dev->dev_errno = EIO;
 871          return false;
 872       }
 873    }
 874
 875    dev->update_freespace();
 876
 877    if (!dev->is_freespace_ok()) { /* Error while getting free space */
 878       char ed1[50], ed2[50];
 879       Dmsg1(100, "Cannot get free space on the device ERR=%s.\n", dev->errmsg);
 880       Jmsg(jcr, M_FATAL, 0, _("End of Volume \"%s\" at %u:%u on device %s "
 881          "(part_size=%s, free_space=%s, free_space_errno=%d, errmsg=%s).\n"),
 882            dev->VolCatInfo.VolCatName,
 883            dev->file, dev->block_num, dev->print_name(),
 884            edit_uint64_with_commas(dev->part_size, ed1), edit_uint64_with_commas(dev->free_space, ed2),
 885            dev->free_space_errno, dev->errmsg);
 886       dev->dev_errno = dev->free_space_errno;
 887       return false;
 888    }
 889
 890    if ((dev->is_freespace_ok() && (dev->part_size + block->binbuf) >= dev->free_space)) {
 891       char ed1[50], ed2[50];
 892       Dmsg0(100, "==== Just enough free space on the device to write the current part...\n");
 893       Jmsg(jcr, M_INFO, 0, _("End of Volume \"%s\" at %u:%u on device %s "
 894          "(part_size=%s, free_space=%s, free_space_errno=%d).\n"),
 895             dev->VolCatInfo.VolCatName,
 896             dev->file, dev->block_num, dev->print_name(),
 897             edit_uint64_with_commas(dev->part_size, ed1), edit_uint64_with_commas(dev->free_space, ed2),
 898             dev->free_space_errno);
 899       terminate_writing_volume(dcr);
 900       dev->dev_errno = ENOSPC;
 901       return false;
 902    }
 903    return true;
 904 }
 905
 906
 907 /*
 908  * Read block with locking
 909  *
 910  */
 911 bool read_block_from_device(DCR *dcr, bool check_block_numbers)
 912 {
 913    bool ok;
 914    DEVICE *dev = dcr->dev;
 915    Dmsg0(250, "Enter read_block_from_device\n");
 916    dev->r_dlock();
 917    ok = read_block_from_dev(dcr, check_block_numbers);
 918    dev->dunlock();
 919    Dmsg0(250, "Leave read_block_from_device\n");
 920    return ok;
 921 }
 922
 923 /*
 924  * Read the next block into the block structure and unserialize
 925  *  the block header.  For a file, the block may be partially
 926  *  or completely in the current buffer.
 927  */
 928 bool read_block_from_dev(DCR *dcr, bool check_block_numbers)
 929 {
 930    ssize_t stat;
 931    int looping;
 932    uint32_t BlockNumber;
 933    int retry;
 934    JCR *jcr = dcr->jcr;
 935    DEVICE *dev = dcr->dev;
 936    DEV_BLOCK *block = dcr->block;
 937
 938    ASSERT(dev->is_open());
 939
 940    if (dev->at_eot()) {
 941       return false;
 942    }
 943    looping = 0;
 944    Dmsg1(250, "Full read in read_block_from_device() len=%d\n",
 945          block->buf_len);
 946 reread:
 947    if (looping > 1) {
 948       dev->dev_errno = EIO;
 949       Mmsg1(dev->errmsg, _("Block buffer size looping problem on device %s\n"),
 950          dev->print_name());
 951       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
 952       block->read_len = 0;
 953       return false;
 954    }
 955
 956 // #define lots_of_debug
 957 #ifdef lots_of_debug
 958    if (dev->at_eof() && dev->is_dvd()) {
 959       Dmsg1(100, "file_size=%u\n",(unsigned int)dev->file_size);
 960       Dmsg1(100, "file_addr=%u\n",(unsigned int)dev->file_addr);
 961       Dmsg1(100, "lseek=%u\n",(unsigned int)lseek(dev->fd(), 0, SEEK_CUR));
 962       Dmsg1(100, "part_start=%u\n",(unsigned int)dev->part_start);
 963       Dmsg1(100, "part_size=%u\n", (unsigned int)dev->part_size);
 964       Dmsg2(100, "part=%u num_dvd_parts=%u\n", dev->part, dev->num_dvd_parts);
 965       Dmsg1(100, "VolCatInfo.VolCatParts=%u\n", (unsigned int)dev->VolCatInfo.VolCatParts);
 966       Dmsg3(100, "Tests : %d %d %d\n", (dev->VolCatInfo.VolCatParts > 0),
 967          ((dev->file_addr-dev->part_start) == dev->part_size),
 968          (dev->part <= dev->VolCatInfo.VolCatParts));
 969   }
 970 #endif
 971
 972    /* Check for DVD part file end */
 973    if (dev->at_eof() && dev->is_dvd() && dev->num_dvd_parts > 0 &&
 974         dev->part <= dev->num_dvd_parts) {
 975       Dmsg0(400, "Call dvd_open_next_part\n");
 976       if (dvd_open_next_part(dcr) < 0) {
 977          Jmsg3(dcr->jcr, M_FATAL, 0, _("Unable to open device part=%d %s: ERR=%s\n"),
 978                dev->part, dev->print_name(), dev->bstrerror());
 979          dev->dev_errno = EIO;
 980          return false;
 981       }
 982    }
 983
 984    retry = 0;
 985    errno = 0;
 986    stat = 0;
 987    do {
 988       if ((retry > 0 && stat == -1 && errno == EBUSY)) {
 989          berrno be;
 990          Dmsg4(100, "===== read retry=%d stat=%d errno=%d: ERR=%s\n",
 991                retry, stat, errno, be.bstrerror());
 992          bmicrosleep(10, 0);    /* pause a bit if busy or lots of errors */
 993          dev->clrerror(-1);
 994       }
 995       stat = dev->read(block->buf, (size_t)block->buf_len);
 996
 997    } while (stat == -1 && (errno == EBUSY || errno == EINTR || errno == EIO) && retry++ < 3);
 998    if (stat < 0) {
 999       berrno be;
1000       dev->clrerror(-1);
1001       Dmsg1(250, "Read device got: ERR=%s\n", be.bstrerror());
1002       block->read_len = 0;
1003       Mmsg5(dev->errmsg, _("Read error on fd=%d at file:blk %u:%u on device %s. ERR=%s.\n"),
1004          dev->fd(), dev->file, dev->block_num, dev->print_name(), be.bstrerror());
1005       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1006       if (dev->at_eof()) {        /* EOF just seen? */
1007          dev->set_eot();          /* yes, error => EOT */
1008       }
1009       return false;
1010    }
1011    Dmsg3(250, "Read device got %d bytes at %u:%u\n", stat,
1012       dev->file, dev->block_num);
1013    if (stat == 0) {             /* Got EOF ! */
1014       dev->block_num = 0;
1015       block->read_len = 0;
1016       Mmsg3(dev->errmsg, _("Read zero bytes at %u:%u on device %s.\n"),
1017          dev->file, dev->block_num, dev->print_name());
1018       if (dev->at_eof()) {       /* EOF already read? */
1019          dev->set_eot();         /* yes, 2 EOFs => EOT */
1020          return 0;
1021       }
1022       dev->set_ateof();
1023       return false;             /* return eof */
1024    }
1025
1026    /* Continue here for successful read */
1027
1028    block->read_len = stat;      /* save length read */
1029    if (block->read_len == 80 &&
1030         (dcr->VolCatInfo.LabelType != B_BACULA_LABEL ||
1031          dcr->device->label_type != B_BACULA_LABEL)) {
1032       /* ***FIXME*** should check label */
1033       Dmsg2(100, "Ignore 80 byte ANSI label at %u:%u\n", dev->file, dev->block_num);
1034       dev->clear_eof();
1035       goto reread;             /* skip ANSI/IBM label */
1036    }
1037
1038    if (block->read_len < BLKHDR2_LENGTH) {
1039       dev->dev_errno = EIO;
1040       Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Very short block of %d bytes on device %s discarded.\n"),
1041          dev->file, dev->block_num, block->read_len, dev->print_name());
1042       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1043       dev->set_short_block();
1044       block->read_len = block->binbuf = 0;
1045       return false;             /* return error */
1046    }
1047
1048    BlockNumber = block->BlockNumber + 1;
1049    if (!unser_block_header(jcr, dev, block)) {
1050       if (forge_on) {
1051          dev->file_addr += block->read_len;
1052          dev->file_size += block->read_len;
1053          goto reread;
1054       }
1055       return false;
1056    }
1057
1058    /*
1059     * If the block is bigger than the buffer, we reposition for
1060     *  re-reading the block, allocate a buffer of the correct size,
1061     *  and go re-read.
1062     */
1063    if (block->block_len > block->buf_len) {
1064       dev->dev_errno = EIO;
1065       Mmsg2(dev->errmsg,  _("Block length %u is greater than buffer %u. Attempting recovery.\n"),
1066          block->block_len, block->buf_len);
1067       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1068       Pmsg1(000, "%s", dev->errmsg);
1069       /* Attempt to reposition to re-read the block */
1070       if (dev->is_tape()) {
1071          Dmsg0(250, "BSR for reread; block too big for buffer.\n");
1072          if (!dev->bsr(1)) {
1073             Jmsg(jcr, M_ERROR, 0, "%s", dev->bstrerror());
1074             block->read_len = 0;
1075             return false;
1076          }
1077       } else {
1078          Dmsg0(250, "Seek to beginning of block for reread.\n");
1079          boffset_t pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
1080          pos -= block->read_len;
1081          dev->lseek(dcr, pos, SEEK_SET);
1082          dev->file_addr = pos;
1083       }
1084       Mmsg1(dev->errmsg, _("Setting block buffer size to %u bytes.\n"), block->block_len);
1085       Jmsg(jcr, M_INFO, 0, "%s", dev->errmsg);
1086       Pmsg1(000, "%s", dev->errmsg);
1087       /* Set new block length */
1088       dev->max_block_size = block->block_len;
1089       block->buf_len = block->block_len;
1090       free_memory(block->buf);
1091       block->buf = get_memory(block->buf_len);
1092       empty_block(block);
1093       looping++;
1094       goto reread;                    /* re-read block with correct block size */
1095    }
1096
1097    if (block->block_len > block->read_len) {
1098       dev->dev_errno = EIO;
1099       Mmsg4(dev->errmsg, _("Volume data error at %u:%u! Short block of %d bytes on device %s discarded.\n"),
1100          dev->file, dev->block_num, block->read_len, dev->print_name());
1101       Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
1102       dev->set_short_block();
1103       block->read_len = block->binbuf = 0;
1104       return false;             /* return error */
1105    }
1106
1107    dev->clear_short_block();
1108    dev->clear_eof();
1109    dev->VolCatInfo.VolCatReads++;
1110    dev->VolCatInfo.VolCatRBytes += block->read_len;
1111
1112    dev->EndBlock = dev->block_num;
1113    dev->EndFile  = dev->file;
1114    dev->block_num++;
1115
1116    /* Update dcr values */
1117    if (dev->is_tape()) {
1118       dcr->EndBlock = dev->EndBlock;
1119       dcr->EndFile  = dev->EndFile;
1120    } else {
1121       uint64_t addr = dev->file_addr + block->read_len - 1;
1122       dcr->EndBlock = (uint32_t)addr;
1123       dcr->EndFile = (uint32_t)(addr >> 32);
1124       dev->block_num = dcr->EndBlock;
1125       dev->file = dcr->EndFile;
1126    }
1127    dcr->VolMediaId = dev->VolCatInfo.VolMediaId;
1128    dev->file_addr += block->read_len;
1129    dev->file_size += block->read_len;
1130
1131    /*
1132     * If we read a short block on disk,
1133     * seek to beginning of next block. This saves us
1134     * from shuffling blocks around in the buffer. Take a
1135     * look at this from an efficiency stand point later, but
1136     * it should only happen once at the end of each job.
1137     *
1138     * I've been lseek()ing negative relative to SEEK_CUR for 30
1139     *   years now. However, it seems that with the new off_t definition,
1140     *   it is not possible to seek negative amounts, so we use two
1141     *   lseek(). One to get the position, then the second to do an
1142     *   absolute positioning -- so much for efficiency.  KES Sep 02.
1143     */
1144    Dmsg0(250, "At end of read block\n");
1145    if (block->read_len > block->block_len && !dev->is_tape()) {
1146       char ed1[50];
1147       boffset_t pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
1148       Dmsg1(250, "Current lseek pos=%s\n", edit_int64(pos, ed1));
1149       pos -= (block->read_len - block->block_len);
1150       dev->lseek(dcr, pos, SEEK_SET);
1151       Dmsg3(250, "Did lseek pos=%s blk_size=%d rdlen=%d\n",
1152          edit_int64(pos, ed1), block->block_len,
1153             block->read_len);
1154       dev->file_addr = pos;
1155       dev->file_size = pos;
1156    }
1157    Dmsg2(250, "Exit read_block read_len=%d block_len=%d\n",
1158       block->read_len, block->block_len);
1159    block->block_read = true;
1160    return true;
1161 }