3 * Bacula Tape manipulation program
5 * Has various tape manipulation commands -- mostly for
6 * use in determining how tapes really work.
8 * Kern Sibbald, April MM
10 * Note, this program reads stored.conf, and will only
11 * talk to devices that are configured.
17 Copyright (C) 2000-2004 Kern Sibbald and John Walker
19 This program is free software; you can redistribute it and/or
20 modify it under the terms of the GNU General Public License as
21 published by the Free Software Foundation; either version 2 of
22 the License, or (at your option) any later version.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 General Public License for more details.
29 You should have received a copy of the GNU General Public
30 License along with this program; if not, write to the Free
31 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
40 /* External subroutines */
41 extern void free_config_resources();
42 extern char *edit_device_codes(JCR *jcr, char *omsg, const char *imsg, const char *cmd);
44 /* Exported variables */
47 int bsize = TAPE_BSIZE;
48 char VolName[MAX_NAME_LENGTH];
49 bool forge_on = false;
52 * If you change the format of the state file,
53 * increment this value
55 static uint32_t btape_state_level = 2;
58 DEVRES *device = NULL;
61 /* Forward referenced subroutines */
62 static void do_tape_cmds();
63 static void helpcmd();
64 static void scancmd();
65 static void rewindcmd();
66 static void clearcmd();
70 static void fillcmd();
71 static void qfillcmd();
72 static void statcmd();
73 static void unfillcmd();
74 static int flush_block(DEV_BLOCK *block, int dump);
75 static int quickie_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec);
76 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
77 static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
78 static void scan_blocks();
79 static void set_volume_name(const char *VolName, int volnum);
80 static void rawfill_cmd();
81 static void bfill_cmd();
82 static bool open_the_device();
83 static void autochangercmd();
84 static void do_unfill();
87 /* Static variables */
88 #define CONFIG_FILE "bacula-sd.conf"
91 #define MAX_CMD_ARGS 30
94 static char *argk[MAX_CMD_ARGS];
95 static char *argv[MAX_CMD_ARGS];
98 static int quickie_count = 0;
99 static BSR *bsr = NULL;
100 static int signals = TRUE;
103 static uint64_t vol_size;
104 static uint64_t VolBytes;
107 static int32_t file_index;
108 static int end_of_tape = 0;
109 static uint32_t LastBlock = 0;
110 static uint32_t eot_block;
111 static uint32_t eot_block_len;
112 static uint32_t eot_FileIndex;
113 static int dumped = 0;
114 static DEV_BLOCK *last_block1 = NULL;
115 static DEV_BLOCK *last_block2 = NULL;
116 static DEV_BLOCK *last_block = NULL;
117 static DEV_BLOCK *this_block = NULL;
118 static DEV_BLOCK *first_block = NULL;
119 static uint32_t last_file1 = 0;
120 static uint32_t last_file2 = 0;
121 static uint32_t last_file = 0;
122 static uint32_t last_block_num1 = 0;
123 static uint32_t last_block_num2 = 0;
124 static uint32_t last_block_num = 0;
125 static uint32_t BlockNumber = 0;
126 static bool simple = true;
128 static const char *VolumeName = NULL;
129 static int vol_num = 0;
131 static JCR *jcr = NULL;
135 static void terminate_btape(int sig);
136 int get_cmd(const char *prompt);
139 /*********************************************************************
141 * Main Bacula Pool Creation Program
144 int main(int margc, char *margv[])
149 if (TAPE_BSIZE % DEV_BSIZE != 0 || TAPE_BSIZE / DEV_BSIZE == 0) {
150 Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
151 TAPE_BSIZE, DEV_BSIZE);
153 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
154 Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE);
157 printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
159 working_directory = "/tmp";
160 my_name_is(margc, margv, "btape");
161 init_msg(NULL, NULL);
163 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
165 case 'b': /* bootstrap file */
166 bsr = parse_bsr(NULL, optarg);
167 // dump_bsr(bsr, true);
170 case 'c': /* specify config file */
171 if (configfile != NULL) {
174 configfile = bstrdup(optarg);
177 case 'd': /* set debug level */
178 debug_level = atoi(optarg);
179 if (debug_level <= 0) {
206 cmd = get_pool_memory(PM_FNAME);
207 args = get_pool_memory(PM_FNAME);
210 init_signals(terminate_btape);
213 if (configfile == NULL) {
214 configfile = bstrdup(CONFIG_FILE);
217 daemon_start_time = time(NULL);
219 parse_config(configfile);
222 /* See if we can open a device */
224 Pmsg0(000, "No archive name specified.\n");
227 } else if (margc != 1) {
228 Pmsg0(000, "Improper number of arguments specified.\n");
233 jcr = setup_jcr("btape", margv[0], bsr, NULL);
234 dev = setup_to_access_device(jcr, 0); /* acquire for write */
238 if (!open_the_device()) {
242 Dmsg0(200, "Do tape commands\n");
250 static void terminate_btape(int stat)
253 sm_check(__FILE__, __LINE__, false);
257 free_config_resources();
259 free_pool_memory(args);
263 free_pool_memory(cmd);
271 if (debug_level > 10)
272 print_memory_pool_stats();
282 free_block(this_block);
286 close_memory_pool(); /* free memory in pool */
292 static bool open_the_device()
296 block = new_block(dev);
298 if (!(dev->state & ST_OPENED)) {
299 Dmsg1(200, "Opening device %s\n", jcr->VolumeName);
300 if (open_dev(dev, jcr->VolumeName, OPEN_READ_WRITE) < 0) {
301 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
307 Pmsg1(000, "open_dev %s OK\n", dev_name(dev));
320 * Write a label to the tape
322 static void labelcmd()
325 pm_strcpy(&cmd, VolumeName);
327 if (!get_cmd("Enter Volume Name: ")) {
332 if (!(dev->state & ST_OPENED)) {
333 if (!first_open_device(dev)) {
334 Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
338 write_new_volume_label_to_dev(jcr, jcr->device, cmd, "Default");
339 Pmsg1(-1, "Wrote Volume label for volume \"%s\".\n", cmd);
343 * Read the tape label
345 static void readlabelcmd()
347 int save_debug_level = debug_level;
351 block = new_block(dev);
352 stat = read_dev_volume_label(jcr, dev, block);
355 Pmsg0(0, "Volume has no label.\n");
358 Pmsg0(0, "Volume label read correctly.\n");
361 Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev));
364 Pmsg0(0, "Volume name error\n");
366 case VOL_CREATE_ERROR:
367 Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
369 case VOL_VERSION_ERROR:
370 Pmsg0(0, "Volume version error.\n");
372 case VOL_LABEL_ERROR:
373 Pmsg0(0, "Bad Volume label type.\n");
376 Pmsg0(0, "Unknown error.\n");
381 dump_volume_label(dev);
382 debug_level = save_debug_level;
388 * Load the tape should have prevously been taken
389 * off line, otherwise this command is not necessary.
391 static void loadcmd()
394 if (!load_dev(dev)) {
395 Pmsg1(0, "Bad status from load. ERR=%s\n", strerror_dev(dev));
397 Pmsg1(0, "Loaded %s\n", dev_name(dev));
403 static void rewindcmd()
405 if (!rewind_dev(dev)) {
406 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
407 clrerror_dev(dev, -1);
409 Pmsg1(0, "Rewound %s\n", dev_name(dev));
414 * Clear any tape error
416 static void clearcmd()
418 clrerror_dev(dev, -1);
422 * Write and end of file on the tape
424 static void weofcmd()
435 if ((stat = weof_dev(dev, num)) < 0) {
436 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
439 Pmsg3(0, "Wrote %d EOF%s to %s\n", num, num==1?"":"s", dev_name(dev));
444 /* Go to the end of the medium -- raw command
445 * The idea was orginally that the end of the Bacula
446 * medium would be flagged differently. This is not
447 * currently the case. So, this is identical to the
453 Pmsg1(0, "%s", strerror_dev(dev));
456 Pmsg0(0, _("Moved to end of medium.\n"));
461 * Go to the end of the medium (either hardware determined
462 * or defined by two eofs.
482 if (!bsf_dev(dev, num)) {
483 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
485 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
501 if (!bsr_dev(dev, num)) {
502 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
504 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
509 * List device capabilities as defined in the
514 printf(_("Configured device capabilities:\n"));
515 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
516 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
517 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
518 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
519 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
520 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
521 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
522 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
523 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
524 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
525 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
526 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
527 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
530 printf(_("Device status:\n"));
531 printf("%sOPENED ", dev->state & ST_OPENED ? "" : "!");
532 printf("%sTAPE ", dev->state & ST_TAPE ? "" : "!");
533 printf("%sLABEL ", dev->state & ST_LABEL ? "" : "!");
534 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
535 printf("%sAPPEND ", dev->state & ST_APPEND ? "" : "!");
536 printf("%sREAD ", dev->state & ST_READ ? "" : "!");
537 printf("%sEOT ", dev->state & ST_EOT ? "" : "!");
538 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
539 printf("%sEOF ", dev->state & ST_EOF ? "" : "!");
540 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
541 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
544 printf(_("Device parameters:\n"));
545 printf("Device name: %s\n", dev->dev_name);
546 printf("File=%u block=%u\n", dev->file, dev->block_num);
547 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
555 * Test writting larger and larger records.
556 * This is a torture test for records.
558 static void rectestcmd()
564 Pmsg0(0, "Test writting larger and larger records.\n"
565 "This is a torture test for records.\nI am going to write\n"
566 "larger and larger records. It will stop when the record size\n"
567 "plus the header exceeds the block size (by default about 64K)\n");
570 get_cmd("Do you want to continue? (y/n): ");
572 Pmsg0(000, "Command aborted.\n");
576 sm_check(__FILE__, __LINE__, false);
577 block = new_block(dev);
580 for (i=1; i<500000; i++) {
581 rec->data = check_pool_memory_size(rec->data, i);
582 memset(rec->data, i & 0xFF, i);
584 sm_check(__FILE__, __LINE__, false);
585 if (write_record_to_block(block, rec)) {
588 Pmsg2(0, "Block %d i=%d\n", blkno, i);
592 sm_check(__FILE__, __LINE__, false);
596 sm_check(__FILE__, __LINE__, false);
600 * This test attempts to re-read a block written by Bacula
601 * normally at the end of the tape. Bacula will then back up
602 * over the two eof marks, backup over the record and reread
603 * it to make sure it is valid. Bacula can skip this validation
604 * if you set "Backward space record = no"
606 static int re_read_block_test()
613 if (!(dev->capabilities & CAP_BSR)) {
614 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
618 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
619 "I'm going to write three records and an EOF\n"
620 "then backup over the EOF and re-read the last record.\n"
621 "Bacula does this after writing the last block on the\n"
622 "tape to verify that the block was written correctly.\n\n"
623 "This is not an *essential* feature ...\n\n"));
625 block = new_block(dev);
627 rec->data = check_pool_memory_size(rec->data, block->buf_len);
628 len = rec->data_len = block->buf_len-100;
629 memset(rec->data, 1, rec->data_len);
630 if (!write_record_to_block(block, rec)) {
631 Pmsg0(0, _("Error writing record to block.\n"));
634 if (!write_block_to_dev(jcr->dcr, block)) {
635 Pmsg0(0, _("Error writing block to device.\n"));
638 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
640 memset(rec->data, 2, rec->data_len);
641 if (!write_record_to_block(block, rec)) {
642 Pmsg0(0, _("Error writing record to block.\n"));
645 if (!write_block_to_dev(jcr->dcr, block)) {
646 Pmsg0(0, _("Error writing block to device.\n"));
649 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
651 memset(rec->data, 3, rec->data_len);
652 if (!write_record_to_block(block, rec)) {
653 Pmsg0(0, _("Error writing record to block.\n"));
656 if (!write_block_to_dev(jcr->dcr, block)) {
657 Pmsg0(0, _("Error writing block to device.\n"));
660 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
663 if (dev_cap(dev, CAP_TWOEOF)) {
666 if (!bsf_dev(dev, 1)) {
667 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
670 if (dev_cap(dev, CAP_TWOEOF)) {
671 if (!bsf_dev(dev, 1)) {
672 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
676 Pmsg0(0, "Backspaced over EOF OK.\n");
677 if (!bsr_dev(dev, 1)) {
678 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
681 Pmsg0(0, "Backspace record OK.\n");
682 if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
683 Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
686 memset(rec->data, 0, rec->data_len);
687 if (!read_record_from_block(block, rec)) {
688 Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
691 for (int i=0; i<len; i++) {
692 if (rec->data[i] != 3) {
693 Pmsg0(0, _("Bad data in record. Test failed!\n"));
697 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
698 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
706 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
707 "this function to verify the last block written to the\n"
708 "tape. Bacula will skip the last block verification\n"
710 "Backward Space Record = No\n\n"
711 "to your Storage daemon's Device resource definition.\n"));
718 * This test writes Bacula blocks to the tape in
719 * several files. It then rewinds the tape and attepts
720 * to read these blocks back checking the data.
722 static int write_read_test()
730 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
731 "I'm going to write 1000 records and an EOF\n"
732 "then write 1000 records and an EOF, then rewind,\n"
733 "and re-read the data to verify that it is correct.\n\n"
734 "This is an *essential* feature ...\n\n"));
735 block = new_block(dev);
737 if (!rewind_dev(dev)) {
738 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
741 rec->data = check_pool_memory_size(rec->data, block->buf_len);
742 rec->data_len = block->buf_len-100;
743 len = rec->data_len/sizeof(i);
744 for (i=1; i<=1000; i++) {
745 p = (int *)rec->data;
746 for (j=0; j<len; j++) {
749 if (!write_record_to_block(block, rec)) {
750 Pmsg0(0, _("Error writing record to block.\n"));
753 if (!write_block_to_dev(jcr->dcr, block)) {
754 Pmsg0(0, _("Error writing block to device.\n"));
758 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
760 for (i=1001; i<=2000; i++) {
761 p = (int *)rec->data;
762 for (j=0; j<len; j++) {
765 if (!write_record_to_block(block, rec)) {
766 Pmsg0(0, _("Error writing record to block.\n"));
769 if (!write_block_to_dev(jcr->dcr, block)) {
770 Pmsg0(0, _("Error writing block to device.\n"));
774 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
776 if (dev_cap(dev, CAP_TWOEOF)) {
779 if (!rewind_dev(dev)) {
780 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
783 Pmsg0(0, "Rewind OK.\n");
785 for (i=1; i<=2000; i++) {
787 if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
788 if (dev_state(dev, ST_EOF)) {
789 Pmsg0(-1, _("Got EOF on tape.\n"));
792 Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
795 memset(rec->data, 0, rec->data_len);
796 if (!read_record_from_block(block, rec)) {
797 Pmsg1(0, _("Read record failed! ERR=%s\n"), strerror(dev->dev_errno));
800 p = (int *)rec->data;
801 for (j=0; j<len; j++) {
803 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
809 if (i == 1000 || i == 2000) {
810 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
813 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
823 * This test writes Bacula blocks to the tape in
824 * several files. It then rewinds the tape and attepts
825 * to read these blocks back checking the data.
827 static int position_test()
835 int file = 0, blk = 0;
838 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
839 "I'm going to write 1000 records and an EOF\n"
840 "then write 1000 records and an EOF, then rewind,\n"
841 "and position to a few blocks and verify that it is correct.\n\n"
842 "This is an *essential* feature ...\n\n"));
843 block = new_block(dev);
845 if (!rewind_dev(dev)) {
846 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
849 rec->data = check_pool_memory_size(rec->data, block->buf_len);
850 rec->data_len = block->buf_len-100;
851 len = rec->data_len/sizeof(i);
852 for (i=1; i<=1000; i++) {
853 p = (int *)rec->data;
854 for (j=0; j<len; j++) {
857 if (!write_record_to_block(block, rec)) {
858 Pmsg0(0, _("Error writing record to block.\n"));
861 if (!write_block_to_dev(jcr->dcr, block)) {
862 Pmsg0(0, _("Error writing block to device.\n"));
866 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
868 for (i=1001; i<=2000; i++) {
869 p = (int *)rec->data;
870 for (j=0; j<len; j++) {
873 if (!write_record_to_block(block, rec)) {
874 Pmsg0(0, _("Error writing record to block.\n"));
877 if (!write_block_to_dev(jcr->dcr, block)) {
878 Pmsg0(0, _("Error writing block to device.\n"));
882 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
884 if (dev_cap(dev, CAP_TWOEOF)) {
887 if (!rewind_dev(dev)) {
888 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
891 Pmsg0(0, "Rewind OK.\n");
895 /* Set up next item to read based on where we are */
931 Pmsg2(-1, "Reposition to file:block %d:%d\n", file, blk);
932 if (!reposition_dev(dev, file, blk)) {
933 Pmsg0(0, "Reposition error.\n");
937 if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
938 if (dev_state(dev, ST_EOF)) {
939 Pmsg0(-1, _("Got EOF on tape.\n"));
942 Pmsg1(0, _("Read block failed! ERR=%s\n\n"), strerror(dev->dev_errno));
943 Pmsg0(0, _("This may be because the tape drive block size is not\n"
944 " set to variable blocking as normally used by Bacula.\n"
945 " Please see the Tape Testing chapter in the manual and \n"
946 " look for using mt with defblksize and setoptions\n"));
949 memset(rec->data, 0, rec->data_len);
950 if (!read_record_from_block(block, rec)) {
951 Pmsg1(0, _("Read record failed! ERR=%s\n"), strerror(dev->dev_errno));
954 p = (int *)rec->data;
955 for (j=0; j<len; j++) {
957 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
962 Pmsg0(-1, _("Block re-read correctly.\n"));
964 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
977 * This test writes some records, then writes an end of file,
978 * rewinds the tape, moves to the end of the data and attepts
979 * to append to the tape. This function is essential for
980 * Bacula to be able to write multiple jobs to the tape.
982 static int append_test()
984 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
985 "This test is essential to Bacula.\n\n"
986 "I'm going to write one record in file 0,\n"
987 " two records in file 1,\n"
988 " and three records in file 2\n\n"));
992 weofcmd(); /* end file 0 */
995 weofcmd(); /* end file 1 */
999 weofcmd(); /* end file 2 */
1000 if (dev_cap(dev, CAP_TWOEOF)) {
1004 Pmsg0(0, _("Now moving to end of medium.\n"));
1006 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1007 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1009 if (dev->file != 3) {
1013 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1016 if (dev_cap(dev, CAP_TWOEOF)) {
1020 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1021 Pmsg0(-1, "Doing Bacula scan of blocks:\n");
1023 Pmsg0(-1, _("End scanning the tape.\n"));
1024 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1025 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1027 if (dev->file != 4) {
1035 * This test exercises the autochanger
1037 static int autochanger_test()
1039 POOLMEM *results, *changer;
1040 int slot, status, loaded;
1041 int timeout = jcr->device->max_changer_wait;
1044 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1045 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1048 if (!(jcr->device && jcr->device->changer_name && jcr->device->changer_command)) {
1049 Pmsg0(-1, "\nAutochanger enabled, but no name or no command device specified.\n");
1053 Pmsg0(-1, "\nAh, I see you have an autochanger configured.\n"
1054 "To test the autochanger you must have a blank tape\n"
1055 " that I can write on in Slot 1.\n");
1056 if (!get_cmd("\nDo you wish to continue with the Autochanger test? (y/n): ")) {
1059 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1063 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1065 results = get_pool_memory(PM_MESSAGE);
1066 changer = get_pool_memory(PM_FNAME);
1070 jcr->VolCatInfo.Slot = slot;
1071 /* Find out what is loaded, zero means device is unloaded */
1072 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1073 changer = edit_device_codes(jcr, changer, jcr->device->changer_command,
1075 status = run_program(changer, timeout, results);
1076 Dmsg3(100, "run_prog: %s stat=%d result=%s\n", changer, status, results);
1078 loaded = atoi(results);
1080 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1081 Pmsg2(-1, _("3991 status=%d result=%s\n"), status, results);
1085 Pmsg1(-1, "Slot %d loaded. I am going to unload it.\n", loaded);
1087 Pmsg0(-1, "Nothing loaded in the drive. OK.\n");
1089 Dmsg1(100, "Results from loaded query=%s\n", results);
1091 jcr->VolCatInfo.Slot = loaded;
1092 offline_or_rewind_dev(dev);
1093 /* We are going to load a new tape, so close the device */
1094 force_close_dev(dev);
1095 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1096 loaded, dev->drive_index);
1097 changer = edit_device_codes(jcr, changer,
1098 jcr->device->changer_command, "unload");
1099 status = run_program(changer, timeout, results);
1100 Pmsg2(-1, "unload status=%s %d\n", status==0?"OK":"Bad", status);
1102 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1103 Pmsg2(-1, _("3992 status=%d result=%s\n"), status, results);
1112 jcr->VolCatInfo.Slot = slot;
1113 Pmsg2(-1, _("3303 Issuing autochanger \"load slot %d %d\" command.\n"),
1114 slot, dev->drive_index);
1115 changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "load");
1116 Dmsg1(100, "Changer=%s\n", changer);
1117 force_close_dev(dev);
1118 status = run_program(changer, timeout, results);
1120 Pmsg2(-1, _("3303 Autochanger \"load slot %d %d\" status is OK.\n"),
1121 slot, dev->drive_index);
1123 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1124 Pmsg2(-1, _("3993 status=%d result=%s\n"), status, results);
1128 if (!open_the_device()) {
1131 bmicrosleep(sleep_time, 0);
1132 if (!rewind_dev(dev)) {
1133 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
1134 clrerror_dev(dev, -1);
1135 Pmsg0(-1, "\nThe test failed, probably because you need to put\n"
1136 "a longer sleep time in the mtx-script in the load) case.\n"
1137 "Adding a 30 second sleep and trying again ...\n");
1141 Pmsg1(0, "Rewound %s\n", dev_name(dev));
1144 if ((status = weof_dev(dev, 1)) < 0) {
1145 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", status, strerror_dev(dev));
1148 Pmsg1(0, "Wrote EOF to %s\n", dev_name(dev));
1152 Pmsg1(-1, "\nThe test worked this time. Please add:\n\n"
1154 "to your mtx-changer script in the load) case.\n\n",
1157 Pmsg0(-1, "\nThe test autochanger worked!!\n\n");
1160 free_pool_memory(changer);
1161 free_pool_memory(results);
1166 free_pool_memory(changer);
1167 free_pool_memory(results);
1168 Pmsg0(-1, "You must correct this error or the Autochanger will not work.\n");
1172 static void autochangercmd()
1179 * This test assumes that the append test has been done,
1180 * then it tests the fsf function.
1182 static int fsf_test()
1184 bool set_off = false;
1186 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1187 "This test is essential to Bacula.\n\n"
1188 "I'm going to write five files then test forward spacing\n\n"));
1192 weofcmd(); /* end file 0 */
1195 weofcmd(); /* end file 1 */
1199 weofcmd(); /* end file 2 */
1202 weofcmd(); /* end file 3 */
1204 weofcmd(); /* end file 4 */
1205 if (dev_cap(dev, CAP_TWOEOF)) {
1211 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1212 if (!fsf_dev(dev, 1)) {
1213 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1216 Pmsg2(-1, _("We should be in file 1. I am at file %d. This is %s\n"),
1217 dev->file, dev->file == 1 ? "correct!" : "NOT correct!!!!");
1219 if (dev->file != 1) {
1223 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1224 if (!fsf_dev(dev, 2)) {
1225 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1228 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1229 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1231 if (dev->file != 3) {
1236 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1237 if (!fsf_dev(dev, 4)) {
1238 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1241 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1242 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1244 if (dev->file != 4) {
1248 Pmsg0(-1, "The test worked this time. Please add:\n\n"
1249 " Fast Forward Space File = no\n\n"
1250 "to your Device resource for this drive.\n");
1254 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1255 if (!fsf_dev(dev, 1)) {
1256 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1258 Pmsg2(-1, _("We should be in file 5. I am at file %d. This is %s\n"),
1259 dev->file, dev->file == 5 ? "correct!" : "NOT correct!!!!");
1260 if (dev->file != 5) {
1263 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1267 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1268 if (dev_cap(dev, CAP_FASTFSF)) {
1269 Pmsg0(-1, "You have Fast Forward Space File enabled.\n"
1270 "I am turning it off then retrying the test.\n");
1271 dev->capabilities &= ~CAP_FASTFSF;
1275 Pmsg0(-1, "You must correct this error or Bacula will not work.\n");
1284 * This is a general test of Bacula's functions
1285 * needed to read and write the tape.
1287 static void testcmd()
1291 if (!write_read_test()) {
1294 if (!position_test()) {
1298 stat = append_test();
1299 if (stat == 1) { /* OK get out */
1302 if (stat == -1) { /* first test failed */
1303 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1304 Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
1305 "Setting \"Hardware End of Medium = no\n"
1306 " and \"Fast Forward Space File = no\n"
1307 "and retrying append test.\n\n");
1308 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1309 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1310 stat = append_test();
1312 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1313 " Hardware End of Medium = No\n\n"
1314 " Fast Forward Space File = No\n"
1315 "to your Device resource in the Storage conf file.\n");
1319 Pmsg0(-1, "\n\nThat appears *NOT* to have corrected the problem.\n");
1322 /* Wrong count after append */
1324 Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
1325 "Setting \"BSF at EOM = yes\" and retrying append test.\n");
1326 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1327 stat = append_test();
1329 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1330 " Hardware End of Medium = No\n"
1331 " Fast Forward Space File = No\n"
1332 " BSF at EOM = yes\n\n"
1333 "to your Device resource in the Storage conf file.\n");
1340 Pmsg0(-1, "\nAppend test failed.\n\n");
1341 Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1342 "Unable to correct the problem. You MUST fix this\n"
1343 "problem before Bacula can use your tape drive correctly\n");
1344 Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
1345 "Do so by setting:\n\n"
1346 "Minimum Block Size = nnn\n"
1347 "Maximum Block Size = nnn\n\n"
1348 "in your Storage daemon's Device definition.\n"
1349 "nnn must match your tape driver's block size, which\n"
1350 "can be determined by reading your tape manufacturers\n"
1351 "information, and the information on your kernel dirver.\n"
1352 "Fixed block sizes, however, are not normally an ideal solution.\n");
1357 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1358 "Please double check it ...\n"
1359 "=== Sample correct output ===\n"
1360 "1 block of 64448 bytes in file 1\n"
1361 "End of File mark.\n"
1362 "2 blocks of 64448 bytes in file 2\n"
1363 "End of File mark.\n"
1364 "3 blocks of 64448 bytes in file 3\n"
1365 "End of File mark.\n"
1366 "1 block of 64448 bytes in file 4\n"
1367 "End of File mark.\n"
1368 "Total files=4, blocks=7, bytes = 451,136\n"
1369 "=== End sample correct output ===\n\n"));
1371 Pmsg0(-1, _("If the above scan output is not identical to the\n"
1372 "sample output, you MUST correct the problem\n"
1373 "or Bacula will not be able to write multiple Jobs to \n"
1377 re_read_block_test();
1380 fsf_test(); /* do fast forward space file test */
1382 autochanger_test(); /* do autochanger test */
1386 /* Forward space a file */
1387 static void fsfcmd()
1391 num = atoi(argk[1]);
1396 if (!fsf_dev(dev, num)) {
1397 Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
1400 Pmsg2(0, "Forward spaced %d file%s.\n", num, num==1?"":"s");
1403 /* Forward space a record */
1404 static void fsrcmd()
1408 num = atoi(argk[1]);
1413 if (!fsr_dev(dev, num)) {
1414 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1417 Pmsg2(0, "Forward spaced %d record%s.\n", num, num==1?"":"s");
1422 * Write a Bacula block to the tape
1430 sm_check(__FILE__, __LINE__, false);
1431 block = new_block(dev);
1433 dump_block(block, "test");
1435 i = block->buf_len - 100;
1437 rec->data = check_pool_memory_size(rec->data, i);
1438 memset(rec->data, i & 0xFF, i);
1440 sm_check(__FILE__, __LINE__, false);
1441 if (!write_record_to_block(block, rec)) {
1442 Pmsg0(0, _("Error writing record to block.\n"));
1445 if (!write_block_to_dev(jcr->dcr, block)) {
1446 Pmsg0(0, _("Error writing block to device.\n"));
1449 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1451 Pmsg0(0, _("Wrote block to device.\n"));
1454 sm_check(__FILE__, __LINE__, false);
1457 sm_check(__FILE__, __LINE__, false);
1461 * Read a record from the tape
1468 if (!get_cmd("Enter length to read: ")) {
1472 if (len < 0 || len > 1000000) {
1473 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1476 buf = (char *)malloc(len);
1477 stat = read(dev->fd, buf, len);
1478 if (stat > 0 && stat <= len) {
1481 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1482 len, stat, strerror(errno));
1488 * Scan tape by reading block by block. Report what is
1489 * on the tape. Note, this command does raw reads, and as such
1490 * will not work with fixed block size devices.
1492 static void scancmd()
1495 int blocks, tot_blocks, tot_files;
1501 blocks = block_size = tot_blocks = 0;
1503 if (dev->state & ST_EOT) {
1504 Pmsg0(0, "End of tape\n");
1507 update_pos_dev(dev);
1508 tot_files = dev->file;
1509 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1511 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1512 clrerror_dev(dev, -1);
1513 Mmsg2(&dev->errmsg, "read error on %s. ERR=%s.\n",
1514 dev->dev_name, strerror(dev->dev_errno));
1515 Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
1517 printf("%d block%s of %d bytes in file %d\n",
1518 blocks, blocks>1?"s":"", block_size, dev->file);
1521 Dmsg1(200, "read status = %d\n", stat);
1523 if (stat != block_size) {
1524 update_pos_dev(dev);
1526 printf("%d block%s of %d bytes in file %d\n",
1527 blocks, blocks>1?"s":"", block_size, dev->file);
1532 if (stat == 0) { /* EOF */
1533 update_pos_dev(dev);
1534 printf("End of File mark.\n");
1535 /* Two reads of zero means end of tape */
1536 if (dev->state & ST_EOF)
1537 dev->state |= ST_EOT;
1539 dev->state |= ST_EOF;
1542 if (dev->state & ST_EOT) {
1543 printf("End of tape\n");
1546 } else { /* Got data */
1547 dev->state &= ~ST_EOF;
1553 update_pos_dev(dev);
1554 tot_files = dev->file - tot_files;
1555 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1556 edit_uint64_with_commas(bytes, ec1));
1561 * Scan tape by reading Bacula block by block. Report what is
1562 * on the tape. This function reads Bacula blocks, so if your
1563 * Device resource is correctly defined, it should work with
1564 * either variable or fixed block sizes.
1566 static void scan_blocks()
1568 int blocks, tot_blocks, tot_files;
1569 uint32_t block_size;
1574 block = new_block(dev);
1575 blocks = block_size = tot_blocks = 0;
1578 update_pos_dev(dev);
1579 tot_files = dev->file;
1581 if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
1582 Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
1583 if (dev->state & ST_EOT) {
1585 printf("%d block%s of %d bytes in file %d\n",
1586 blocks, blocks>1?"s":"", block_size, dev->file);
1591 if (dev->state & ST_EOF) {
1593 printf("%d block%s of %d bytes in file %d\n",
1594 blocks, blocks>1?"s":"", block_size, dev->file);
1597 printf(_("End of File mark.\n"));
1600 if (dev->state & ST_SHORT) {
1602 printf("%d block%s of %d bytes in file %d\n",
1603 blocks, blocks>1?"s":"", block_size, dev->file);
1606 printf(_("Short block read.\n"));
1609 printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1612 if (block->block_len != block_size) {
1614 printf("%d block%s of %d bytes in file %d\n",
1615 blocks, blocks>1?"s":"", block_size, dev->file);
1618 block_size = block->block_len;
1622 bytes += block->block_len;
1623 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1624 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1625 block->VolSessionId, block->VolSessionTime);
1627 DEV_RECORD *rec = new_record();
1628 read_record_from_block(block, rec);
1629 Pmsg8(-1, "Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
1630 block->BlockNumber, dev->block_num, block->block_len,
1631 FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1632 stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
1635 } else if (verbose > 1) {
1636 dump_block(block, "");
1642 tot_files = dev->file - tot_files;
1643 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1644 edit_uint64_with_commas(bytes, ec1));
1648 static void statcmd()
1650 int debug = debug_level;
1652 Pmsg2(0, "Device status: %u. ERR=%s\n", status_dev(dev), strerror_dev(dev));
1654 dump_volume_label(dev);
1656 debug_level = debug;
1661 * First we label the tape, then we fill
1662 * it with data get a new tape and write a few blocks.
1664 static void fillcmd()
1671 uint32_t min_block_size;
1681 This command simulates Bacula writing to a tape.\n\
1682 It requires either one or two blank tapes, which it\n\
1683 will label and write.\n\n\
1684 If you have an autochanger configured, it will use\n\
1685 the tapes that are in slots 1 and 2, otherwise, you will\n\
1686 be prompted to insert the tapes when necessary.\n\n\
1687 It will print a status approximately\n\
1688 every 322 MB, and write an EOF every 3.2 GB. If you have\n\
1689 selected the simple test option, after writing the first tape\n\
1690 it will rewind it and re-read the last block written.\n\n\
1691 If you have selected the multiple tape test, when the first tape\n\
1692 fills, it will ask for a second, and after writing a few more \n\
1693 blocks, it will stop. Then it will begin re-reading the\n\
1695 This may take a long time -- hours! ...\n\n");
1697 get_cmd("Do you want to run the simplified test (s) with one tape\n"
1698 "or the complete multiple tape (m) test: (s/m) ");
1699 if (cmd[0] == 's') {
1700 Pmsg0(-1, "Simple test (single tape) selected.\n");
1702 } else if (cmd[0] == 'm') {
1703 Pmsg0(-1, "Multiple tape test selected.\n");
1706 Pmsg0(000, "Command aborted.\n");
1710 Dmsg1(20, "Begin append device=%s\n", dev_name(dev));
1711 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1713 /* Use fixed block size to simplify read back */
1714 min_block_size = dev->min_block_size;
1715 dev->min_block_size = dev->max_block_size;
1718 * Acquire output device for writing. Note, after acquiring a
1719 * device, we MUST release it, which is done at the end of this
1722 Dmsg0(100, "just before acquire_device\n");
1723 if (!acquire_device_for_append(jcr)) {
1724 set_jcr_job_status(jcr, JS_ErrorTerminated);
1727 block = jcr->dcr->block;
1729 Dmsg0(100, "Just after acquire_device_for_append\n");
1731 * Write Begin Session Record
1733 if (!write_session_label(jcr, block, SOS_LABEL)) {
1734 set_jcr_job_status(jcr, JS_ErrorTerminated);
1735 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1739 Pmsg0(-1, "Wrote Start Of Session label.\n");
1741 memset(&rec, 0, sizeof(rec));
1742 rec.data = get_memory(100000); /* max record size */
1744 #define REC_SIZE 32768
1745 rec.data_len = REC_SIZE;
1748 * Put some random data in the record
1750 fd = open("/dev/urandom", O_RDONLY);
1752 read(fd, rec.data, rec.data_len);
1755 uint32_t *p = (uint32_t *)rec.data;
1756 srandom(time(NULL));
1757 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1763 * Generate data as if from File daemon, write to device
1765 jcr->dcr->VolFirstIndex = 0;
1766 time(&jcr->run_time); /* start counting time for rates */
1768 Pmsg0(-1, "Begin writing Bacula records to tape ...\n");
1770 Pmsg0(-1, "Begin writing Bacula records to first tape ...\n");
1772 for (file_index = 0; ok && !job_canceled(jcr); ) {
1773 rec.VolSessionId = jcr->VolSessionId;
1774 rec.VolSessionTime = jcr->VolSessionTime;
1775 rec.FileIndex = ++file_index;
1776 rec.Stream = STREAM_FILE_DATA;
1778 /* Mix up the data just a bit */
1779 uint32_t *lp = (uint32_t *)rec.data;
1781 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1785 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1786 rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1789 while (!write_record_to_block(block, &rec)) {
1791 * When we get here we have just filled a block
1793 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1796 /* Write block to tape */
1797 if (!flush_block(block, 1)) {
1801 /* Every 5000 blocks (approx 322MB) report where we are.
1803 if ((block->BlockNumber % 5000) == 0) {
1805 now -= jcr->run_time;
1807 now = 1; /* prevent divide error */
1809 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1810 Pmsg4(-1, "Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n",
1811 block->BlockNumber, dev->block_num,
1812 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1814 /* Every 15000 blocks (approx 1GB) write an EOF.
1816 if ((block->BlockNumber % 15000) == 0) {
1817 Pmsg0(-1, "Flush block, write EOF\n");
1818 flush_block(block, 0);
1822 /* Get out after writing 10 blocks to the second tape */
1823 if (++BlockNumber > 10 && stop != 0) { /* get out */
1828 Pmsg0(000, _("Not OK\n"));
1831 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1832 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1833 FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1834 stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1836 /* Get out after writing 10 blocks to the second tape */
1837 if (BlockNumber > 10 && stop != 0) { /* get out */
1838 Pmsg0(-1, "Done writing ...\n");
1843 Dmsg0(100, "Write_end_session_label()\n");
1844 /* Create Job status for end of session label */
1845 if (!job_canceled(jcr) && ok) {
1846 set_jcr_job_status(jcr, JS_Terminated);
1848 set_jcr_job_status(jcr, JS_ErrorTerminated);
1850 if (!write_session_label(jcr, block, EOS_LABEL)) {
1851 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1854 /* Write out final block of this session */
1855 if (!write_block_to_device(jcr->dcr, block)) {
1856 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1859 Pmsg0(-1, _("Wrote End Of Session label.\n"));
1861 /* Save last block info for second tape */
1862 last_block_num2 = last_block_num;
1863 last_file2 = last_file;
1865 free_block(last_block2);
1867 last_block2 = dup_block(last_block);
1870 sprintf(buf, "%s/btape.state", working_directory);
1871 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1873 write(fd, &btape_state_level, sizeof(btape_state_level));
1874 write(fd, &simple, sizeof(simple));
1875 write(fd, &last_block_num1, sizeof(last_block_num1));
1876 write(fd, &last_block_num2, sizeof(last_block_num2));
1877 write(fd, &last_file1, sizeof(last_file1));
1878 write(fd, &last_file2, sizeof(last_file2));
1879 write(fd, last_block1->buf, last_block1->buf_len);
1880 write(fd, last_block2->buf, last_block2->buf_len);
1881 write(fd, first_block->buf, first_block->buf_len);
1883 Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
1884 last_block_num1, last_block_num2);
1886 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
1890 /* Release the device if multiple tapes being used */
1891 if (!simple && !release_device(jcr)) {
1892 Pmsg0(-1, _("Error in release_device\n"));
1896 Pmsg2(-1, _("\n\nDone filling tape%s. Now beginning re-read of %stape ...\n"),
1897 simple?"":"s", simple?"":"first ");
1901 dev->min_block_size = min_block_size;
1902 free_memory(rec.data);
1906 * Read two tapes written by the "fill" command and ensure
1907 * that the data is valid. If stop==1 we simulate full read back
1908 * of two tapes. If stop==-1 we simply read the last block and
1909 * verify that it is correct.
1911 static void unfillcmd()
1915 last_block1 = new_block(dev);
1916 last_block2 = new_block(dev);
1917 first_block = new_block(dev);
1918 sprintf(buf, "%s/btape.state", working_directory);
1919 fd = open(buf, O_RDONLY);
1921 uint32_t state_level;
1922 read(fd, &state_level, sizeof(btape_state_level));
1923 read(fd, &simple, sizeof(simple));
1924 read(fd, &last_block_num1, sizeof(last_block_num1));
1925 read(fd, &last_block_num2, sizeof(last_block_num2));
1926 read(fd, &last_file1, sizeof(last_file1));
1927 read(fd, &last_file2, sizeof(last_file2));
1928 read(fd, last_block1->buf, last_block1->buf_len);
1929 read(fd, last_block2->buf, last_block2->buf_len);
1930 read(fd, first_block->buf, first_block->buf_len);
1932 if (state_level != btape_state_level) {
1933 Pmsg0(-1, "\nThe state file level has changed. You must redo\n"
1934 "the fill command.\n");
1938 Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
1939 "You must redo the fill command.\n", buf, strerror(errno));
1946 static void do_unfill()
1954 block = new_block(dev);
1956 Dmsg0(20, "Enter do_unfill\n");
1957 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
1958 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
1962 time(&jcr->run_time); /* start counting time for rates */
1966 free_block(last_block);
1968 last_block_num = last_block_num1;
1969 last_file = last_file1;
1970 last_block = last_block1;
1973 /* Multiple Volume tape */
1974 /* Close device so user can use autochanger if desired */
1975 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1978 autochanger = autoload_device(jcr, dev, 1, NULL);
1980 force_close_dev(dev);
1981 get_cmd(_("Mount first tape. Press enter when ready: "));
1984 jcr->dcr = new_dcr(jcr, dev);
1985 set_volume_name("TestVolume1", 1);
1987 create_vol_list(jcr);
1989 dev->state &= ~ST_READ;
1990 if (!acquire_device_for_read(jcr)) {
1991 Pmsg1(-1, "%s", dev->errmsg);
1996 * We now have the first tape mounted.
1997 * Note, re-reading last block may have caused us to
1998 * loose track of where we are (block number unknown).
2000 rewind_dev(dev); /* get to a known place on tape */
2001 /* Read the first 1000 records */
2002 Pmsg0(-1, _("Reading the first 1000 records.\n"));
2003 read_records(jcr, dev, quickie_cb, my_mount_next_read_volume);
2004 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2005 last_file, last_block_num);
2006 if (!reposition_dev(dev, last_file, last_block_num)) {
2007 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2009 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2010 if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
2011 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2014 if (compare_blocks(last_block, block)) {
2016 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2018 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2025 /* restore info for last block on second Volume */
2026 last_block_num = last_block_num2;
2027 last_file = last_file2;
2028 last_block = last_block2;
2030 /* Multiple Volume tape */
2031 /* Close device so user can use autochanger if desired */
2032 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2037 set_volume_name("TestVolume2", 2);
2039 create_vol_list(jcr);
2040 autochanger = autoload_device(jcr, dev, 1, NULL);
2042 force_close_dev(dev);
2043 get_cmd(_("Mount second tape. Press enter when ready: "));
2046 dev->state &= ~ST_READ;
2047 if (!acquire_device_for_read(jcr)) {
2048 Pmsg1(-1, "%s", dev->errmsg);
2052 /* Space to "first" block which is last block not written
2053 * on the previous tape.
2055 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2056 if (!reposition_dev(dev, 0, 1)) {
2057 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2060 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2061 if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
2062 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2065 if (compare_blocks(first_block, block)) {
2066 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2069 /* Now find and compare the last block */
2070 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2071 last_file, last_block_num);
2072 if (!reposition_dev(dev, last_file, last_block_num)) {
2073 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2076 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2077 if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
2078 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2081 if (compare_blocks(last_block, block)) {
2082 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2087 free_block(last_block1);
2088 free_block(last_block2);
2089 free_block(first_block);
2092 /* Read 1000 records then stop */
2093 static int quickie_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
2096 return quickie_count <= 1000;
2099 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2102 uint32_t CheckSum, block_len;
2105 p = last_block->buf;
2107 unser_begin(q, BLKHDR2_LENGTH);
2108 unser_uint32(CheckSum);
2109 unser_uint32(block_len);
2110 while (q < (block->buf+block_len)) {
2117 dump_block(last_block, _("Last block written"));
2119 dump_block(block, _("Block read back"));
2120 Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf);
2121 Pmsg0(-1, "\n\n!!!! The last block written and the block\n"
2122 "that was read back differ. The test FAILED !!!!\n"
2123 "This must be corrected before you use Bacula\n"
2124 "to write multi-tape Volumes.!!!!\n");
2128 dump_block(last_block, _("Last block written"));
2129 dump_block(block, _("Block read back"));
2139 * Write current block to tape regardless of whether or
2140 * not it is full. If the tape fills, attempt to
2141 * acquire another tape.
2143 static int flush_block(DEV_BLOCK *block, int dump)
2148 uint32_t this_file, this_block_num;
2151 this_block = new_block(dev);
2154 last_block = new_block(dev);
2157 this_file = dev->file;
2158 this_block_num = dev->block_num;
2159 if (!write_block_to_dev(jcr->dcr, block)) {
2160 Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n",
2161 last_file, last_block_num, this_block_num);
2164 * This is 1st tape, so save first tape info separate
2165 * from second tape info
2167 last_block_num1 = last_block_num;
2168 last_file1 = last_file;
2169 last_block1 = dup_block(last_block);
2170 last_block2 = dup_block(last_block);
2171 first_block = dup_block(block); /* first block second tape */
2174 Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n",
2175 (unsigned)file_index, block->BlockNumber, block->block_len);
2176 dump_block(last_block, "Last block written");
2178 dump_block(block, "Block not written");
2181 eot_block = block->BlockNumber;
2182 eot_block_len = block->block_len;
2183 eot_FileIndex = file_index;
2187 now -= jcr->run_time;
2189 now = 1; /* don't divide by zero */
2191 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2192 vol_size = dev->VolCatInfo.VolCatBytes;
2193 Pmsg2(000, "End of tape. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
2194 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2197 stop = -1; /* stop, but do simplified test */
2199 /* Full test in progress */
2200 if (!fixup_device_block_write_error(jcr, dev, block)) {
2201 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2206 BlockNumber = 0; /* start counting for second tape */
2209 return 1; /* end of tape reached */
2212 /* Save contents after write so that the header is serialized */
2213 memcpy(this_block->buf, block->buf, this_block->buf_len);
2216 * Toggle between two allocated blocks for efficiency.
2217 * Switch blocks so that the block just successfully written is
2218 * always in last_block.
2220 tblock = last_block;
2221 last_block = this_block;
2222 this_block = tblock;
2223 last_file = this_file;
2224 last_block_num = this_block_num;
2232 * First we label the tape, then we fill
2233 * it with data get a new tape and write a few blocks.
2235 static void qfillcmd()
2241 Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
2243 get_cmd("How many blocks do you want to write? (1000): ");
2250 sm_check(__FILE__, __LINE__, false);
2251 block = new_block(dev);
2254 i = block->buf_len - 100;
2256 rec->data = check_pool_memory_size(rec->data, i);
2257 memset(rec->data, i & 0xFF, i);
2260 Pmsg1(0, "Begin writing %d Bacula blocks to tape ...\n", count);
2261 for (i=0; i < count; i++) {
2266 if (!write_record_to_block(block, rec)) {
2267 Pmsg0(0, _("Error writing record to block.\n"));
2270 if (!write_block_to_dev(jcr->dcr, block)) {
2271 Pmsg0(0, _("Error writing block to device.\n"));
2277 if (dev_cap(dev, CAP_TWOEOF)) {
2284 sm_check(__FILE__, __LINE__, false);
2287 sm_check(__FILE__, __LINE__, false);
2292 * Fill a tape using raw write() command
2294 static void rawfill_cmd()
2299 uint32_t block_num = 0;
2304 block = new_block(dev);
2305 fd = open("/dev/urandom", O_RDONLY);
2307 read(fd, block->buf, block->buf_len);
2310 uint32_t *p = (uint32_t *)block->buf;
2311 srandom(time(NULL));
2312 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2316 p = (uint32_t *)block->buf;
2317 Pmsg1(0, "Begin writing raw blocks of %u bytes.\n", block->buf_len);
2320 stat = write(dev->fd, block->buf, block->buf_len);
2321 if (stat == (int)block->buf_len) {
2322 if ((block_num++ % 100) == 0) {
2327 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2336 printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
2337 strerror(my_errno));
2344 * Fill a tape using raw write() command
2346 static void bfill_cmd()
2349 uint32_t block_num = 0;
2355 block = new_block(dev);
2356 fd = open("/dev/urandom", O_RDONLY);
2358 read(fd, block->buf, block->buf_len);
2361 uint32_t *p = (uint32_t *)block->buf;
2362 srandom(time(NULL));
2363 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2367 p = (uint32_t *)block->buf;
2368 Pmsg1(0, "Begin writing Bacula blocks of %u bytes.\n", block->buf_len);
2371 block->binbuf = block->buf_len;
2372 block->bufp = block->buf + block->binbuf;
2373 if (!write_block_to_dev(jcr->dcr, block)) {
2376 if ((block_num++ % 100) == 0) {
2381 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2387 printf("Write failed at block %u.\n", block_num);
2393 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2394 static struct cmdstruct commands[] = {
2395 {"autochanger", autochangercmd, "test autochanger"},
2396 {"bsf", bsfcmd, "backspace file"},
2397 {"bsr", bsrcmd, "backspace record"},
2398 {"bfill", bfill_cmd, "fill tape using Bacula writes"},
2399 {"cap", capcmd, "list device capabilities"},
2400 {"clear", clearcmd, "clear tape errors"},
2401 {"eod", eodcmd, "go to end of Bacula data for append"},
2402 {"eom", eomcmd, "go to the physical end of medium"},
2403 {"fill", fillcmd, "fill tape, write onto second volume"},
2404 {"unfill", unfillcmd, "read filled tape"},
2405 {"fsf", fsfcmd, "forward space a file"},
2406 {"fsr", fsrcmd, "forward space a record"},
2407 {"help", helpcmd, "print this command"},
2408 {"label", labelcmd, "write a Bacula label to the tape"},
2409 {"load", loadcmd, "load a tape"},
2410 {"quit", quitcmd, "quit btape"},
2411 {"rawfill", rawfill_cmd, "use write() to fill tape"},
2412 {"readlabel", readlabelcmd, "read and print the Bacula tape label"},
2413 {"rectest", rectestcmd, "test record handling functions"},
2414 {"rewind", rewindcmd, "rewind the tape"},
2415 {"scan", scancmd, "read() tape block by block to EOT and report"},
2416 {"scanblocks", scan_blocks, "Bacula read block by block to EOT and report"},
2417 {"status", statcmd, "print tape status"},
2418 {"test", testcmd, "General test Bacula tape functions"},
2419 {"weof", weofcmd, "write an EOF on the tape"},
2420 {"wr", wrcmd, "write a single Bacula block"},
2421 {"rr", rrcmd, "read a single record"},
2422 {"qfill", qfillcmd, "quick fill command"},
2424 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2432 while (get_cmd("*")) {
2433 sm_check(__FILE__, __LINE__, false);
2435 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2436 for (i=0; i<comsize; i++) /* search for command */
2437 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2438 (*commands[i].func)(); /* go execute command */
2443 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2449 static void helpcmd()
2453 printf(_("Interactive commands:\n"));
2454 printf(_(" Command Description\n ======= ===========\n"));
2455 for (i=0; i<comsize; i++)
2456 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2463 "\nVersion: " VERSION " (" BDATE ")\n\n"
2464 "Usage: btape <options> <device_name>\n"
2465 " -b <file> specify bootstrap file\n"
2466 " -c <file> set configuration file to file\n"
2467 " -d <nn> set debug level to nn\n"
2468 " -p proceed inspite of I/O errors\n"
2469 " -s turn off signals\n"
2471 " -? print this message.\n"
2477 * Get next input command from terminal. This
2478 * routine is REALLY primitive, and should be enhanced
2479 * to have correct backspacing, etc.
2482 get_cmd(const char *prompt)
2486 fprintf(stdout, prompt);
2488 /* We really should turn off echoing and pretty this
2492 while ((ch = fgetc(stdin)) != EOF) {
2494 strip_trailing_junk(cmd);
2496 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2509 /* Dummies to replace askdir.c */
2510 int dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
2511 int dir_send_job_status(JCR *jcr) {return 1;}
2513 int dir_update_volume_info(JCR *jcr, DEVICE *dev, int relabel)
2519 int dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing)
2521 Dmsg0(20, "Enter dir_get_volume_info\n");
2522 bstrncpy(jcr->VolCatInfo.VolCatName, jcr->VolumeName, sizeof(jcr->VolCatInfo.VolCatName));
2526 int dir_create_jobmedia_record(JCR *jcr)
2528 jcr->dcr->WroteVol = false;
2533 int dir_find_next_appendable_volume(JCR *jcr)
2535 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2536 return jcr->VolumeName[0] != 0;
2539 int dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev)
2541 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2542 if (jcr->VolumeName[0] == 0) {
2543 return dir_ask_sysop_to_create_appendable_volume(jcr, dev);
2545 /* Close device so user can use autochanger if desired */
2546 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2549 force_close_dev(dev);
2550 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2551 if (jcr->VolumeName[0] == 0 || strcmp(jcr->VolumeName, "TestVolume2") == 0) {
2552 fprintf(stderr, "Mount second Volume on device %s and press return when ready: ",
2555 fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
2556 jcr->VolumeName, dev_name(dev));
2562 int dir_ask_sysop_to_create_appendable_volume(JCR *jcr, DEVICE *dev)
2565 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2567 set_volume_name("TestVolume1", 1);
2569 set_volume_name("TestVolume2", 2);
2571 /* Close device so user can use autochanger if desired */
2572 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2575 autochanger = autoload_device(jcr, dev, 1, NULL);
2577 force_close_dev(dev);
2578 fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
2582 open_device(jcr, dev);
2589 static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)
2593 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2594 Pmsg1(000, "End of Volume \"%s\"\n", jcr->VolumeName);
2596 if (LastBlock != block->BlockNumber) {
2597 VolBytes += block->block_len;
2599 LastBlock = block->BlockNumber;
2601 now -= jcr->run_time;
2605 kbs = (double)VolBytes / (1000.0 * (double)now);
2606 Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2607 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2609 if (strcmp(jcr->VolumeName, "TestVolume2") == 0) {
2615 set_volume_name("TestVolume2", 2);
2617 create_vol_list(jcr);
2619 dev->state &= ~ST_READ;
2620 if (!acquire_device_for_read(jcr)) {
2621 Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), jcr->VolumeName);
2624 return 1; /* next volume mounted */
2627 static void set_volume_name(const char *VolName, int volnum)
2629 DCR *dcr = jcr->dcr;
2630 VolumeName = VolName;
2632 pm_strcpy(&jcr->VolumeName, VolName);
2633 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2634 bstrncpy(jcr->VolCatInfo.VolCatName, VolName, sizeof(jcr->VolCatInfo.VolCatName));
2635 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2636 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2637 jcr->VolCatInfo.Slot = volnum;
2638 dcr->VolCatInfo.Slot = volnum;
2643 * Edit codes into ChangerCommand
2645 * %a = archive device name
2646 * %c = changer device name
2647 * %f = Client's name
2655 * omsg = edited output message
2656 * imsg = input string containing edit codes (%x)
2657 * cmd = command string (load, unload, ...)
2660 static char *edit_device_codes(JCR *jcr, char *omsg, const char *imsg, const char *cmd)
2667 Dmsg1(400, "edit_device_codes: %s\n", imsg);
2668 for (p=imsg; *p; p++) {
2675 str = dev_name(jcr->device->dev);
2678 str = NPRT(jcr->device->changer_name);
2684 sprintf(add, "%d", jcr->VolCatInfo.Slot - 1);
2688 sprintf(add, "%d", jcr->VolCatInfo.Slot);
2691 case 'j': /* Job name */
2695 str = NPRT(jcr->VolumeName);
2698 str = NPRT(jcr->client_name);
2713 Dmsg1(400, "add_str %s\n", str);
2714 pm_strcat(&omsg, (char *)str);
2715 Dmsg1(400, "omsg=%s\n", omsg);
2723 * We are called here from "unfill" for each record on the tape.
2725 static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
2727 SESSION_LABEL label;
2729 if (stop > 1 && !dumped) { /* on second tape */
2732 dump_block(block, "First block on second tape");
2734 Pmsg4(-1, "Blk: FileIndex=%d: block=%u size=%d vol=%s\n",
2735 rec->FileIndex, block->BlockNumber, block->block_len, dev->VolHdr.VolName);
2736 Pmsg6(-1, " Rec: VId=%d VT=%d FI=%s Strm=%s len=%d state=%x\n",
2737 rec->VolSessionId, rec->VolSessionTime,
2738 FI_to_ascii(rec->FileIndex), stream_to_ascii(rec->Stream, rec->FileIndex),
2739 rec->data_len, rec->state);
2741 if (rec->FileIndex < 0) {
2743 dump_label_record(dev, rec, 1);
2745 switch (rec->FileIndex) {
2747 Pmsg0(-1, "Volume is prelabeled. This tape cannot be scanned.\n");
2750 unser_volume_label(dev, rec);
2751 Pmsg3(-1, "VOL_LABEL: block=%u size=%d vol=%s\n", block->BlockNumber,
2752 block->block_len, dev->VolHdr.VolName);
2756 unser_session_label(&label, rec);
2757 Pmsg1(-1, "SOS_LABEL: JobId=%u\n", label.JobId);
2760 unser_session_label(&label, rec);
2761 Pmsg2(-1, "EOS_LABEL: block=%u JobId=%u\n", block->BlockNumber,
2765 Pmsg0(-1, "EOM_LABEL:\n");
2767 case EOT_LABEL: /* end of all tapes */
2770 if (LastBlock != block->BlockNumber) {
2771 VolBytes += block->block_len;
2773 LastBlock = block->BlockNumber;
2775 now -= jcr->run_time;
2779 kbs = (double)VolBytes / (1000 * now);
2780 Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2781 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2783 Pmsg0(000, "End of all tapes.\n");
2791 if (++file_index != rec->FileIndex) {
2792 Pmsg3(000, "Incorrect FileIndex in Block %u. Got %d, expected %d.\n",
2793 block->BlockNumber, rec->FileIndex, file_index);
2795 if (LastBlock != block->BlockNumber) {
2796 VolBytes += block->block_len;
2798 if ((block->BlockNumber != LastBlock) && (block->BlockNumber % 50000) == 0) {
2801 now -= jcr->run_time;
2805 kbs = (double)VolBytes / (1000 * now);
2806 Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2807 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2809 LastBlock = block->BlockNumber;
2811 Pmsg1(000, "End of all blocks. Block=%u\n", block->BlockNumber);