1 /*
2 Bacula(R) - The Network Backup Solution
3
4 Copyright (C) 2000-2020 Kern Sibbald
5
6 The original author of Bacula is Kern Sibbald, with contributions
7 from many others, a complete list can be found in the file AUTHORS.
8
9 You may use this file and others of this release according to the
10 license defined in the LICENSE file, which includes the Affero General
11 Public License, v3.0 ("AGPLv3") and some additional permissions and
12 terms pursuant to its AGPLv3 Section 7.
13
14 This notice must be preserved when any source code is
15 conveyed and/or propagated.
16
17 Bacula(R) is a registered trademark of Kern Sibbald.
18 */
19 /*
20 *
21 * block.c -- tape block handling functions
22 *
23 * Kern Sibbald, March MMI
24 * added BB02 format October MMII
25 */
26
27
28 #include "bacula.h"
29 #include "stored.h"
30
31 #ifdef DEBUG_BLOCK_CHECKSUM
32 static const bool debug_block_checksum = true;
33 #else
34 static const bool debug_block_checksum = false;
35 #endif
36
37 static int debug_io_error = 0; /* # blocks to write before creating I/O error */
38
39 #ifdef NO_TAPE_WRITE_TEST
40 static const bool no_tape_write_test = true;
41 #else
42 static const bool no_tape_write_test = false;
43 #endif
44
45
46 uint32_t get_len_and_clear_block(DEV_BLOCK *block, DEVICE *dev, uint32_t &pad);
47 uint32_t ser_block_header(DEV_BLOCK *block, bool do_checksum);
48 bool unser_block_header(DCR *dcr, DEVICE *dev, DEV_BLOCK *block);
49
50 /*
51 * Write a block to the device, with locking and unlocking
52 *
53 * Returns: true on success
54 * : false on failure
55 *
56 */
write_block_to_device(bool final)57 bool DCR::write_block_to_device(bool final)
58 {
59 bool ok = true;
60 DCR *dcr = this;
61
62 if (dcr->spooling) {
63 Dmsg0(250, "Write to spool\n");
64 ok = write_block_to_spool_file(dcr);
65 return ok;
66 }
67
68 if (!is_dev_locked()) { /* device already locked? */
69 /* note, do not change this to dcr->rLock */
70 dev->rLock(false); /* no, lock it */
71 }
72
73 if (!check_for_newvol_or_newfile(dcr)) {
74 ok = false;
75 goto bail_out; /* fatal error */
76 }
77
78 Dmsg1(500, "Write block to dev=%p\n", dcr->dev);
79 if (!write_block_to_dev()) {
80 Dmsg2(40, "*** Failed write_block_to_dev adata=%d block=%p\n",
81 block->adata, block);
82 if (job_canceled(jcr) || jcr->getJobType() == JT_SYSTEM) {
83 ok = false;
84 Dmsg2(40, "cancel=%d or SYSTEM=%d\n", job_canceled(jcr),
85 jcr->getJobType() == JT_SYSTEM);
86 } else {
87 bool was_adata = false;
88 if (was_adata) {
89 dcr->set_ameta();
90 was_adata = true;
91 }
92 /* Flush any existing JobMedia info */
93 if (!(ok = dir_create_jobmedia_record(dcr))) {
94 Jmsg(jcr, M_FATAL, 0, _("[SF0201] Error writing JobMedia record to catalog.\n"));
95 } else {
96 Dmsg1(40, "Calling fixup_device was_adata=%d...\n", was_adata);
97 ok = fixup_device_block_write_error(dcr);
98 }
99 if (was_adata) {
100 dcr->set_adata();
101 }
102 }
103 }
104 if (ok && final && !dir_create_jobmedia_record(dcr)) {
105 Jmsg(jcr, M_FATAL, 0, _("[SF0202] Error writing final JobMedia record to catalog.\n"));
106 }
107
108 bail_out:
109 if (!dcr->is_dev_locked()) { /* did we lock dev above? */
110 /* note, do not change this to dcr->dunlock */
111 dev->Unlock(); /* unlock it now */
112 }
113 return ok;
114 }
115
116 /*
117 * Write a block to the device
118 *
119 * Returns: true on success or EOT
120 * false on hard error
121 */
write_block_to_dev()122 bool DCR::write_block_to_dev()
123 {
124 ssize_t stat = 0;
125 uint32_t wlen; /* length to write */
126 bool ok = true;
127 DCR *dcr = this;
128 uint32_t checksum;
129 uint32_t pad; /* padding or zeros written */
130 boffset_t pos;
131 char ed1[50];
132
133 if (no_tape_write_test) {
134 empty_block(block);
135 return true;
136 }
137 if (job_canceled(jcr)) {
138 return false;
139 }
140 if (!dev->enabled) {
141 Jmsg1(jcr, M_FATAL, 0, _("[SF0203] Cannot write block. Device is disabled. dev=%s\n"), dev->print_name());
142 return false;
143 }
144
145 ASSERT2(block->adata == dev->adata, "Block and dev adata not same");
146 Dmsg4(200, "fd=%d adata=%d bufp-buf=%d binbuf=%d\n", dev->fd(), block->adata,
147 block->bufp-block->buf, block->binbuf);
148 ASSERT2(block->binbuf == ((uint32_t)(block->bufp - block->buf)), "binbuf badly set");
149
150 if (is_block_empty(block)) { /* Does block have data in it? */
151 Dmsg1(50, "return write_block_to_dev no adata=%d data to write\n", block->adata);
152 return true;
153 }
154
155 if (dev->at_weot()) {
156 Dmsg1(50, "==== FATAL: At EOM with ST_WEOT. adata=%d.\n", dev->adata);
157 dev->dev_errno = ENOSPC;
158 Jmsg1(jcr, M_FATAL, 0, _("[SF0204] Cannot write block. Device at EOM. dev=%s\n"), dev->print_name());
159 return false;
160 }
161 if (!dev->can_append()) {
162 dev->dev_errno = EIO;
163 Jmsg1(jcr, M_FATAL, 0, _("[SF0205] Attempt to write on read-only Volume. dev=%s\n"), dev->print_name());
164 Dmsg1(50, "Attempt to write on read-only Volume. dev=%s\n", dev->print_name());
165 return false;
166 }
167
168 if (!dev->is_open()) {
169 Jmsg1(jcr, M_FATAL, 0, _("[SF0206] Attempt to write on closed device=%s\n"), dev->print_name());
170 Dmsg1(50, "Attempt to write on closed device=%s\n", dev->print_name());
171 return false;
172 }
173
174 wlen = get_len_and_clear_block(block, dev, pad);
175 block->block_len = wlen;
176 dev->updateVolCatPadding(pad);
177
178 checksum = ser_block_header(block, dev->do_checksum());
179
180 if (!dev->do_size_checks(dcr, block)) {
181 Dmsg0(50, "Size check triggered. Cannot write block.\n");
182 return false;
183 }
184
185 dev->updateVolCatWrites(1);
186
187 dump_block(dev, block, "before write");
188
189 #ifdef DEBUG_BLOCK_ZEROING
190 uint32_t *bp = (uint32_t *)block->buf;
191 if (bp[0] == 0 && bp[1] == 0 && bp[2] == 0 && block->buf[12] == 0) {
192 Jmsg0(jcr, M_ABORT, 0, _("[SA0201] Write block header zeroed.\n"));
193 }
194 #endif
195
196 /*
197 * If Adata block, we must seek to the correct address
198 */
199 if (block->adata) {
200 ASSERT(dcr->dev->adata);
201 uint64_t cur = dev->lseek(dcr, 0, SEEK_CUR);
202 /* If we are going to create a hole, record it */
203 if (block->BlockAddr != cur) {
204 dev->lseek(dcr, block->BlockAddr, SEEK_SET);
205 Dmsg4(100, "Adata seek BlockAddr from %lld to %lld = %lld bytes adata_addr=%lld\n",
206 cur, block->BlockAddr, block->BlockAddr - cur, dev->adata_addr);
207 /* Insanity check */
208 if (block->BlockAddr > cur) {
209 dev->updateVolCatHoleBytes(block->BlockAddr - cur);
210 } else if (block->BlockAddr < cur) {
211 Pmsg5(000, "Vol=%s cur=%lld BlockAddr=%lld adata=%d block=%p\n",
212 dev->getVolCatName(), cur, block->BlockAddr, block->adata, block);
213 Jmsg3(jcr, M_FATAL, 0, "[SF0207] Bad seek on adata Vol=%s BlockAddr=%lld DiskAddr=%lld. Multiple simultaneous Jobs?\n",
214 dev->getVolCatName(), block->BlockAddr, cur);
215 //Pmsg2(000, "HoleBytes would go negative cur=%lld blkaddr=%lld\n", cur, block->BlockAddr);
216 }
217 }
218 }
219
220 /*
221 * Do write here, make a somewhat feeble attempt to recover from
222 * I/O errors, or from the OS telling us it is busy.
223 */
224 int retry = 0;
225 errno = 0;
226 stat = 0;
227 /* ***FIXME**** remove next line debug */
228 pos = dev->lseek(dcr, 0, SEEK_CUR);
229 do {
230 if (retry > 0 && stat == -1 && errno == EBUSY) {
231 berrno be;
232 Dmsg4(100, "===== write retry=%d stat=%d errno=%d: ERR=%s\n",
233 retry, stat, errno, be.bstrerror());
234 bmicrosleep(5, 0); /* pause a bit if busy or lots of errors */
235 dev->clrerror(-1);
236 }
237 stat = dev->write(block->buf, (size_t)wlen);
238 Dmsg4(100, "%s write() BlockAddr=%lld wlen=%d Vol=%s wlen=%d\n",
239 block->adata?"Adata":"Ameta", block->BlockAddr, wlen,
240 dev->VolHdr.VolumeName);
241 } while (stat == -1 && (errno == EBUSY || errno == EIO) && retry++ < 3);
242
243 /* ***FIXME*** remove 2 lines debug */
244 Dmsg2(100, "Wrote %d bytes at %s\n", wlen, dev->print_addr(ed1, sizeof(ed1), pos));
245 dump_block(dev, block, "After write");
246
247 if (debug_block_checksum) {
248 uint32_t achecksum = ser_block_header(block, dev->do_checksum());
249 if (checksum != achecksum) {
250 Jmsg2(jcr, M_ERROR, 0, _("[SA0201] Block checksum changed during write: before=%u after=%u\n"),
251 checksum, achecksum);
252 dump_block(dev, block, "with checksum error");
253 }
254 }
255
256 #ifdef DEBUG_BLOCK_ZEROING
257 if (bp[0] == 0 && bp[1] == 0 && bp[2] == 0 && block->buf[12] == 0) {
258 Jmsg0(jcr, M_ABORT, 0, _("[SA0202] Write block header zeroed.\n"));
259 }
260 #endif
261
262 if (debug_io_error) {
263 debug_io_error--;
264 if (debug_io_error == 1) { /* trigger error */
265 stat = -1;
266 dev->dev_errno = EIO;
267 errno = EIO;
268 debug_io_error = 0; /* turn off trigger */
269 }
270 }
271
272 if (stat != (ssize_t)wlen) {
273 /* Some devices simply report EIO when the volume is full.
274 * With a little more thought we may be able to check
275 * capacity and distinguish real errors and EOT
276 * conditions. In any case, we probably want to
277 * simulate an End of Medium.
278 */
279 if (stat == -1) {
280 berrno be;
281 dev->clrerror(-1); /* saves errno in dev->dev_errno */
282 if (dev->dev_errno == 0) {
283 dev->dev_errno = ENOSPC; /* out of space */
284 }
285 if (dev->dev_errno != ENOSPC) {
286 int etype = M_ERROR;
287 if (block->adata) {
288 etype = M_FATAL;
289 }
290 dev->VolCatInfo.VolCatErrors++;
291 Jmsg5(jcr, etype, 0, _("%s Write error at %s on device %s Vol=%s. ERR=%s.\n"),
292 etype==M_FATAL?"[SF0208]":"[SE0201]",
293 dev->print_addr(ed1, sizeof(ed1)), dev->print_name(),
294 dev->getVolCatName(), be.bstrerror());
295 if (dev->get_tape_alerts(this)) {
296 dev->show_tape_alerts(this, list_long, list_last, alert_callback);
297 }
298 }
299 } else {
300 dev->dev_errno = ENOSPC; /* out of space */
301 }
302 if (dev->dev_errno == ENOSPC) {
303 dev->update_freespace();
304 if (dev->is_freespace_ok() && dev->free_space < dev->min_free_space) {
305 dev->set_nospace();
306 Jmsg(jcr, M_WARNING, 0, _("[SW0201] Out of freespace caused End of Volume \"%s\" at %s on device %s. Write of %u bytes got %d.\n"),
307 dev->getVolCatName(),
308 dev->print_addr(ed1, sizeof(ed1)), dev->print_name(), wlen, stat);
309 } else {
310 dev->clear_nospace();
311 Jmsg(jcr, M_INFO, 0, _("[SI0202] End of Volume \"%s\" at %s on device %s. Write of %u bytes got %d.\n"),
312 dev->getVolCatName(),
313 dev->print_addr(ed1, sizeof(ed1)), dev->print_name(), wlen, stat);
314 }
315 }
316 if (chk_dbglvl(100)) {
317 berrno be;
318 Dmsg7(90, "==== Write error. fd=%d size=%u rtn=%d dev_blk=%d blk_blk=%d errno=%d: ERR=%s\n",
319 dev->fd(), wlen, stat, dev->block_num, block->BlockNumber,
320 dev->dev_errno, be.bstrerror(dev->dev_errno));
321 }
322
323 Dmsg0(40, "Calling terminate_writing_volume\n");
324 ok = terminate_writing_volume(dcr);
325 if (ok) {
326 reread_last_block(dcr);
327 }
328 return false;
329 }
330
331 /* We successfully wrote the block, now do housekeeping */
332 Dmsg2(1300, "VolCatBytes=%lld newVolCatBytes=%lld\n", dev->VolCatInfo.VolCatBytes,
333 (dev->VolCatInfo.VolCatBytes+wlen));
334 if (!dev->setVolCatAdataBytes(block->BlockAddr + wlen)) {
335 dev->updateVolCatBytes(wlen);
336 Dmsg3(200, "AmetaBytes=%lld AdataBytes=%lld Bytes=%lld\n",
337 dev->VolCatInfo.VolCatAmetaBytes, dev->VolCatInfo.VolCatAdataBytes, dev->VolCatInfo.VolCatBytes);
338 }
339 dev->updateVolCatExtraBytes(block->extra_bytes); /* Count bytes stored outside volumes */
340 dev->updateVolCatBlocks(1);
341 dev->LastBlock = block->BlockNumber;
342 block->BlockNumber++;
343
344 /* Update dcr values */
345 if (dev->is_tape()) {
346 dev->EndAddr = dev->get_full_addr();
347 if (dcr->EndAddr < dev->EndAddr) {
348 dcr->EndAddr = dev->EndAddr;
349 }
350 dev->block_num++;
351 } else {
352 /* Save address of byte just written */
353 uint64_t addr = dev->file_addr + wlen - 1;
354 if (dev->is_indexed()) {
355 uint64_t full_addr = dev->get_full_addr(addr);
356 if (full_addr < dcr->EndAddr) {
357 Pmsg2(000, "Possible incorrect EndAddr oldEndAddr=%llu newEndAddr=%llu\n",
358 dcr->EndAddr, full_addr);
359 }
360 dcr->EndAddr = full_addr;
361 }
362
363 if (dev->adata) {
364 /* We really should use file_addr, but I am not sure it is correctly set */
365 Dmsg3(100, "Set BlockAddr from %lld to %lld adata_addr=%lld\n",
366 block->BlockAddr, block->BlockAddr + wlen, dev->adata_addr);
367 block->BlockAddr += wlen;
368 dev->adata_addr = block->BlockAddr;
369 } else {
370 block->BlockAddr = dev->get_full_addr() + wlen;
371 }
372 }
373 if (dev->is_indexed()) {
374 if (dcr->VolMediaId != dev->VolCatInfo.VolMediaId) {
375 Dmsg7(100, "JobMedia Vol=%s wrote=%d MediaId=%lld FI=%lu LI=%lu StartAddr=%lld EndAddr=%lld Wrote\n",
376 dcr->VolumeName, dcr->WroteVol, dcr->VolMediaId,
377 dcr->VolFirstIndex, dcr->VolLastIndex, dcr->StartAddr, dcr->EndAddr);
378 }
379 dcr->VolMediaId = dev->VolCatInfo.VolMediaId;
380 Dmsg3(150, "VolFirstIndex=%d blockFirstIndex=%d Vol=%s\n",
381 dcr->VolFirstIndex, block->FirstIndex, dcr->VolumeName);
382 if (dcr->VolFirstIndex == 0 && block->FirstIndex > 0) {
383 dcr->VolFirstIndex = block->FirstIndex;
384 }
385 if (block->LastIndex > (int32_t)dcr->VolLastIndex) {
386 dcr->VolLastIndex = block->LastIndex;
387 }
388 dcr->WroteVol = true;
389
390 /* Update FileMedia records with the block offset, we do it before the BlockAddr update */
391 dir_create_filemedia_record(dcr);
392 }
393
394 dev->file_addr += wlen; /* update file address */
395 dev->file_size += wlen;
396 dev->usage += wlen; /* update usage counter */
397 if (dev->part > 0) {
398 dev->part_size += wlen;
399 }
400 dev->setVolCatInfo(false); /* Needs update */
401
402 Dmsg2(1300, "write_block: wrote block %d bytes=%d\n", dev->block_num, wlen);
403 empty_block(block);
404 return true;
405 }
406
407
408 /*
409 * Read block with locking
410 *
411 */
read_block_from_device(bool check_block_numbers)412 bool DCR::read_block_from_device(bool check_block_numbers)
413 {
414 bool ok;
415
416 Dmsg0(250, "Enter read_block_from_device\n");
417 dev->rLock(false);
418 ok = read_block_from_dev(check_block_numbers);
419 dev->rUnlock();
420 Dmsg1(250, "Leave read_block_from_device. ok=%d\n", ok);
421 return ok;
422 }
423
set_block_position(DCR * dcr,DEVICE * dev,DEV_BLOCK * block)424 static void set_block_position(DCR *dcr, DEVICE *dev, DEV_BLOCK *block)
425 {
426 /* Used also by the Single Item Restore code to locate a particular block */
427 if (dev->is_tape()) {
428 block->BlockAddr = dev->get_full_addr();
429
430 } else if (!dev->adata) { /* TODO: See if we just use !dev->adata for tapes */
431 /* Note: we only update the DCR values for ameta blocks
432 * because all the indexing (JobMedia) is done with
433 * ameta blocks/records, which may point to adata.
434 */
435 block->BlockAddr = dev->get_full_addr();
436 }
437 block->RecNum = 0;
438 }
439
440 /*
441 * Read the next block into the block structure and unserialize
442 * the block header. For a file, the block may be partially
443 * or completely in the current buffer.
444 * Note: in order for bscan to generate correct JobMedia records
445 * we must be careful to update the EndAddr of the last byte read.
446 */
read_block_from_dev(bool check_block_numbers)447 bool DCR::read_block_from_dev(bool check_block_numbers)
448 {
449 ssize_t stat;
450 int looping;
451 int retry;
452 int status;
453 DCR *dcr = this;
454 boffset_t pos;
455 char ed1[50];
456 uint32_t data_len;
457
458 if (job_canceled(jcr)) {
459 Mmsg(dev->errmsg, _("Job failed or canceled.\n"));
460 Dmsg1(000, "%s", dev->errmsg);
461 block->read_len = 0;
462 return false;
463 }
464 if (!dev->enabled) {
465 Mmsg(dev->errmsg, _("[SF0210] Cannot write block. Device is disabled. dev=%s\n"), dev->print_name());
466 Jmsg1(jcr, M_FATAL, 0, "%s", dev->errmsg);
467 return false;
468 }
469
470 if (dev->at_eot()) {
471 Mmsg(dev->errmsg, _("[SX0201] At EOT: attempt to read past end of Volume.\n"));
472 Dmsg1(000, "%s", dev->errmsg);
473 block->read_len = 0;
474 return false;
475 }
476 looping = 0;
477
478 if (!dev->is_open()) {
479 Mmsg4(dev->errmsg, _("[SF0211] Attempt to read closed device: fd=%d at file:blk %u:%u on device %s\n"),
480 dev->fd(), dev->file, dev->block_num, dev->print_name());
481 Jmsg(dcr->jcr, M_FATAL, 0, "%s", dev->errmsg);
482 Pmsg4(000, "Fatal: dev=%p dcr=%p adata=%d bytes=%lld\n", dev, dcr, dev->adata,
483 VolCatInfo.VolCatAdataRBytes);
484 Pmsg1(000, "%s", dev->errmsg);
485 block->read_len = 0;
486 return false;
487 }
488
489 set_block_position(dcr, dev, block);
490
491 reread:
492 if (looping > 1) {
493 dev->dev_errno = EIO;
494 Mmsg1(dev->errmsg, _("[SE0202] Block buffer size looping problem on device %s\n"),
495 dev->print_name());
496 Dmsg1(000, "%s", dev->errmsg);
497 Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
498 block->read_len = 0;
499 return false;
500 }
501
502 /* See if we must open another part */
503 if (dev->at_eof() && !dev->open_next_part(dcr)) {
504 if (dev->at_eof()) { /* EOF just seen? */
505 dev->set_eot(); /* yes, error => EOT */
506 }
507 return false;
508 }
509
510 retry = 0;
511 errno = 0;
512 stat = 0;
513
514 if (dev->adata) {
515 dev->lseek(dcr, dcr->block->BlockAddr, SEEK_SET);
516 }
517 { /* debug block */
518 pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
519 Dmsg2(200, "Pos for read=%s %lld\n",
520 dev->print_addr(ed1, sizeof(ed1), pos), pos);
521 }
522
523 data_len = 0;
524
525 do {
526 retry = 0;
527
528 do {
529 if ((retry > 0 && stat == -1 && errno == EBUSY)) {
530 berrno be;
531 Dmsg4(100, "===== read retry=%d stat=%d errno=%d: ERR=%s\n",
532 retry, stat, errno, be.bstrerror());
533 bmicrosleep(10, 0); /* pause a bit if busy or lots of errors */
534 dev->clrerror(-1);
535 }
536 stat = dev->read(block->buf + data_len, (size_t)(block->buf_len - data_len));
537 if (stat > 0) {
538 data_len += stat;
539 }
540
541 } while (stat == -1 && (errno == EBUSY || errno == EINTR || errno == EIO) && retry++ < 3);
542
543 } while (data_len < block->buf_len && stat > 0 && dev->dev_type == B_FIFO_DEV);
544
545 Dmsg4(110, "Read() adata=%d vol=%s nbytes=%d pos=%lld\n",
546 block->adata, dev->VolHdr.VolumeName, stat < 0 ? stat : data_len, pos);
547 if (stat < 0) {
548 berrno be;
549 dev->clrerror(-1);
550 Dmsg2(90, "Read device fd=%d got: ERR=%s\n", dev->fd(), be.bstrerror());
551 block->read_len = 0;
552 if (reading_label) { /* Trying to read Volume label */
553 Mmsg(dev->errmsg, _("[SE0203] The %sVolume=%s on device=%s appears to be unlabeled.%s\n"),
554 dev->adata?"adata ":"", VolumeName, dev->print_name(),
555 dev->is_fs_nearly_full(1048576)?" Warning: The filesystem is nearly full.":"");
556 } else {
557 Mmsg4(dev->errmsg, _("[SE0204] Read error on fd=%d at addr=%s on device %s. ERR=%s.\n"),
558 dev->fd(), dev->print_addr(ed1, sizeof(ed1)), dev->print_name(), be.bstrerror());
559 }
560 Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
561 if (dev->get_tape_alerts(this)) {
562 dev->show_tape_alerts(this, list_long, list_last, alert_callback);
563 }
564 if (dev->at_eof()) { /* EOF just seen? */
565 dev->set_eot(); /* yes, error => EOT */
566 }
567 return false;
568 }
569
570 stat = data_len;
571
572 if (stat == 0) { /* Got EOF ! */
573 pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
574 pos = dev->get_full_addr(pos);
575 if (reading_label) { /* Trying to read Volume label */
576 Mmsg4(dev->errmsg, _("The %sVolume=%s on device=%s appears to be unlabeled.%s\n"),
577 dev->adata?"adata ":"", VolumeName, dev->print_name(),
578 dev->is_fs_nearly_full(1048576)?" Warning: The filesystem is nearly full.":"");
579 } else {
580 Mmsg4(dev->errmsg, _("Read zero %sbytes Vol=%s at %s on device %s.\n"),
581 dev->adata?"adata ":"", dev->VolCatInfo.VolCatName,
582 dev->print_addr(ed1, sizeof(ed1), pos), dev->print_name());
583 }
584 block->read_len = 0;
585 Dmsg1(100, "%s", dev->errmsg);
586 if (dev->at_eof()) { /* EOF just seen? */
587 dev->set_eot(); /* yes, error => EOT */
588 }
589 dev->set_ateof();
590 dev->file_addr = 0;
591 dev->EndAddr = pos;
592 if (dcr->EndAddr < dev->EndAddr) {
593 dcr->EndAddr = dev->EndAddr;
594 }
595 Dmsg3(150, "==== Read zero bytes. adata=%d vol=%s at %s\n", dev->adata,
596 dev->VolCatInfo.VolCatName, dev->print_addr(ed1, sizeof(ed1), pos));
597 return false; /* return eof */
598 }
599
600 /* Continue here for successful read */
601
602 block->read_len = stat; /* save length read */
603 if (block->adata) {
604 block->binbuf = block->read_len;
605 block->block_len = block->read_len;
606 } else {
607 if (block->read_len == 80 &&
608 (dcr->VolCatInfo.LabelType != B_BACULA_LABEL ||
609 dcr->device->label_type != B_BACULA_LABEL)) {
610 /* ***FIXME*** should check label */
611 Dmsg2(100, "Ignore 80 byte ANSI label at %u:%u\n", dev->file, dev->block_num);
612 dev->clear_eof();
613 goto reread; /* skip ANSI/IBM label */
614 }
615
616 if (block->read_len < BLKHDR2_LENGTH) {
617 dev->dev_errno = EIO;
618 Mmsg3(dev->errmsg, _("[SE0205] Volume data error at %s! Short block of %d bytes on device %s discarded.\n"),
619 dev->print_addr(ed1, sizeof(ed1)), block->read_len, dev->print_name());
620 Jmsg(jcr, M_WARNING, 0, "%s", dev->errmsg); /* discard block, but continue */
621 dev->set_short_block();
622 block->read_len = block->binbuf = 0;
623 Dmsg2(50, "set block=%p binbuf=%d\n", block, block->binbuf);
624 return false; /* return error */
625 }
626
627 status = jcr->getJobStatus();
628 if (!unser_block_header(this, dev, block)) {
629 if (forge_on) {
630 /* Skip the current byte to find a valid block */
631 dev->file_addr += 1;
632 dev->file_size += 1;
633 /* Can be canceled at this point... */
634 if (jcr->is_canceled()) {
635 jcr->forceJobStatus(status);
636 }
637 set_block_position(dcr, dev, block);
638 dev->lseek(dcr, dcr->block->BlockAddr, SEEK_SET);
639 goto reread;
640 }
641 return false;
642 }
643 }
644
645 /*
646 * If the block is bigger than the buffer, we reposition for
647 * re-reading the block, allocate a buffer of the correct size,
648 * and go re-read.
649 */
650 Dmsg3(150, "adata=%d block_len=%d buf_len=%d\n", block->adata, block->block_len, block->buf_len);
651 if (block->block_len > block->buf_len) {
652 dev->dev_errno = EIO;
653 Mmsg2(dev->errmsg, _("[SE0206] Block length %u is greater than buffer %u. Attempting recovery.\n"),
654 block->block_len, block->buf_len);
655 Jmsg(jcr, M_ERROR, 0, "%s", dev->errmsg);
656 Pmsg1(000, "%s", dev->errmsg);
657 /* Attempt to reposition to re-read the block */
658 if (dev->is_tape()) {
659 Dmsg0(250, "BSR for reread; block too big for buffer.\n");
660 if (!dev->bsr(1)) {
661 Mmsg(dev->errmsg, "%s", dev->bstrerror());
662 if (dev->errmsg[0]) {
663 Jmsg(jcr, M_ERROR, 0, "[SE0207] %s", dev->errmsg);
664 }
665 block->read_len = 0;
666 return false;
667 }
668 } else {
669 Dmsg0(250, "Seek to beginning of block for reread.\n");
670 boffset_t pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
671 pos -= block->read_len;
672 dev->lseek(dcr, pos, SEEK_SET);
673 dev->file_addr = pos;
674 }
675 Mmsg1(dev->errmsg, _("[SI0203] Setting block buffer size to %u bytes.\n"), block->block_len);
676 Jmsg(jcr, M_INFO, 0, "%s", dev->errmsg);
677 Pmsg1(000, "%s", dev->errmsg);
678 /* Set new block length */
679 dev->max_block_size = block->block_len;
680 block->buf_len = block->block_len;
681 free_memory(block->buf);
682 block->buf = get_memory(block->buf_len);
683 empty_block(block);
684 looping++;
685 goto reread; /* re-read block with correct block size */
686 }
687
688 if (block->block_len > block->read_len) {
689 dev->dev_errno = EIO;
690 Mmsg4(dev->errmsg, _("[SE0208] Volume data error at %u:%u! Short block of %d bytes on device %s discarded.\n"),
691 dev->file, dev->block_num, block->read_len, dev->print_name());
692 Jmsg(jcr, M_WARNING, 0, "%s", dev->errmsg); /* discard block, but continue */
693 dev->set_short_block();
694 block->read_len = block->binbuf = 0;
695 return false; /* return error */
696 }
697
698 dev->clear_short_block();
699 dev->clear_eof();
700 dev->updateVolCatReads(1);
701 dev->updateVolCatReadBytes(block->read_len);
702
703 /* Update dcr values */
704 if (dev->is_tape()) {
705 dev->EndAddr = dev->get_full_addr();
706 if (dcr->EndAddr < dev->EndAddr) {
707 dcr->EndAddr = dev->EndAddr;
708 }
709 dev->block_num++;
710 } else {
711 /* We need to take care about a short block in EndBlock/File
712 * computation
713 */
714 uint32_t len = MIN(block->read_len, block->block_len);
715 uint64_t addr = dev->get_full_addr() + len - 1;
716 if (dev->is_indexed()) {
717 if (addr > dcr->EndAddr) {
718 dcr->EndAddr = addr;
719 }
720 }
721 dev->EndAddr = addr;
722 }
723 if (dev->is_indexed()) {
724 dcr->VolMediaId = dev->VolCatInfo.VolMediaId;
725 }
726 dev->file_addr += block->read_len;
727 dev->file_size += block->read_len;
728 dev->usage += block->read_len; /* update usage counter */
729
730 /*
731 * If we read a short block on disk,
732 * seek to beginning of next block. This saves us
733 * from shuffling blocks around in the buffer. Take a
734 * look at this from an efficiency stand point later, but
735 * it should only happen once at the end of each job.
736 *
737 * I've been lseek()ing negative relative to SEEK_CUR for 30
738 * years now. However, it seems that with the new off_t definition,
739 * it is not possible to seek negative amounts, so we use two
740 * lseek(). One to get the position, then the second to do an
741 * absolute positioning -- so much for efficiency. KES Sep 02.
742 */
743 Dmsg0(250, "At end of read block\n");
744 if (block->read_len > block->block_len && !dev->is_tape()) {
745 char ed1[50];
746 boffset_t pos = dev->lseek(dcr, (boffset_t)0, SEEK_CUR); /* get curr pos */
747 Dmsg1(250, "Current lseek pos=%s\n", edit_int64(pos, ed1));
748 pos -= (block->read_len - block->block_len);
749 dev->lseek(dcr, pos, SEEK_SET);
750 Dmsg3(250, "Did lseek pos=%s blk_size=%d rdlen=%d\n",
751 edit_int64(pos, ed1), block->block_len,
752 block->read_len);
753 dev->file_addr = pos;
754 dev->file_size = pos;
755 }
756 Dmsg3(150, "Exit read_block read_len=%d block_len=%d binbuf=%d\n",
757 block->read_len, block->block_len, block->binbuf);
758 block->block_read = true;
759 return true;
760 }
761