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