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, char *imsg, 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);
76 static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec);
78 static int quickie_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec);
79 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
80 static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
81 static void scan_blocks();
82 static void set_volume_name(char *VolName, int volnum);
83 static void rawfill_cmd();
84 static void bfill_cmd();
85 static bool open_the_device();
86 static void autochangercmd();
87 static void do_unfill();
90 /* Static variables */
91 #define CONFIG_FILE "bacula-sd.conf"
94 #define MAX_CMD_ARGS 30
97 static char *argk[MAX_CMD_ARGS];
98 static char *argv[MAX_CMD_ARGS];
101 static int quickie_count = 0;
102 static BSR *bsr = NULL;
103 static int signals = TRUE;
106 static uint64_t vol_size;
107 static uint64_t VolBytes;
110 static int32_t file_index;
111 static int end_of_tape = 0;
112 static uint32_t LastBlock = 0;
113 static uint32_t eot_block;
114 static uint32_t eot_block_len;
115 static uint32_t eot_FileIndex;
116 static int dumped = 0;
117 static DEV_BLOCK *last_block1 = NULL;
118 static DEV_BLOCK *last_block2 = NULL;
119 static DEV_BLOCK *last_block = NULL;
120 static DEV_BLOCK *this_block = NULL;
121 static DEV_BLOCK *first_block = NULL;
122 static uint32_t last_file1 = 0;
123 static uint32_t last_file2 = 0;
124 static uint32_t last_file = 0;
125 static uint32_t last_block_num1 = 0;
126 static uint32_t last_block_num2 = 0;
127 static uint32_t last_block_num = 0;
128 static uint32_t BlockNumber = 0;
129 static bool simple = true;
131 static char *VolumeName = NULL;
132 static int vol_num = 0;
134 static JCR *jcr = NULL;
138 static void terminate_btape(int sig);
139 int get_cmd(char *prompt);
142 /*********************************************************************
144 * Main Bacula Pool Creation Program
147 int main(int margc, char *margv[])
152 if (TAPE_BSIZE % DEV_BSIZE != 0 || TAPE_BSIZE / DEV_BSIZE == 0) {
153 Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
154 TAPE_BSIZE, DEV_BSIZE);
156 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
157 Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE);
160 printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
162 working_directory = "/tmp";
163 my_name_is(margc, margv, "btape");
164 init_msg(NULL, NULL);
166 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
168 case 'b': /* bootstrap file */
169 bsr = parse_bsr(NULL, optarg);
170 // dump_bsr(bsr, true);
173 case 'c': /* specify config file */
174 if (configfile != NULL) {
177 configfile = bstrdup(optarg);
180 case 'd': /* set debug level */
181 debug_level = atoi(optarg);
182 if (debug_level <= 0) {
209 cmd = get_pool_memory(PM_FNAME);
210 args = get_pool_memory(PM_FNAME);
213 init_signals(terminate_btape);
216 if (configfile == NULL) {
217 configfile = bstrdup(CONFIG_FILE);
220 daemon_start_time = time(NULL);
222 parse_config(configfile);
225 /* See if we can open a device */
227 Pmsg0(000, "No archive name specified.\n");
230 } else if (margc != 1) {
231 Pmsg0(000, "Improper number of arguments specified.\n");
236 jcr = setup_jcr("btape", margv[0], bsr, NULL);
237 dev = setup_to_access_device(jcr, 0); /* acquire for write */
241 if (!open_the_device()) {
245 Dmsg0(200, "Do tape commands\n");
253 static void terminate_btape(int stat)
256 sm_check(__FILE__, __LINE__, false);
260 free_config_resources();
262 free_pool_memory(args);
266 free_pool_memory(cmd);
274 if (debug_level > 10)
275 print_memory_pool_stats();
285 free_block(this_block);
289 close_memory_pool(); /* free memory in pool */
295 static bool open_the_device()
299 block = new_block(dev);
301 if (!(dev->state & ST_OPENED)) {
302 Dmsg1(200, "Opening device %s\n", jcr->VolumeName);
303 if (open_dev(dev, jcr->VolumeName, OPEN_READ_WRITE) < 0) {
304 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
310 Pmsg1(000, "open_dev %s OK\n", dev_name(dev));
323 * Write a label to the tape
325 static void labelcmd()
328 pm_strcpy(&cmd, VolumeName);
330 if (!get_cmd("Enter Volume Name: ")) {
335 if (!(dev->state & ST_OPENED)) {
336 if (!first_open_device(dev)) {
337 Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
341 write_volume_label_to_dev(jcr, jcr->device, cmd, "Default");
342 Pmsg1(-1, "Wrote Volume label for volume \"%s\".\n", cmd);
346 * Read the tape label
348 static void readlabelcmd()
350 int save_debug_level = debug_level;
354 block = new_block(dev);
355 stat = read_dev_volume_label(jcr, dev, block);
358 Pmsg0(0, "Volume has no label.\n");
361 Pmsg0(0, "Volume label read correctly.\n");
364 Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev));
367 Pmsg0(0, "Volume name error\n");
369 case VOL_CREATE_ERROR:
370 Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
372 case VOL_VERSION_ERROR:
373 Pmsg0(0, "Volume version error.\n");
375 case VOL_LABEL_ERROR:
376 Pmsg0(0, "Bad Volume label type.\n");
379 Pmsg0(0, "Unknown error.\n");
384 dump_volume_label(dev);
385 debug_level = save_debug_level;
391 * Load the tape should have prevously been taken
392 * off line, otherwise this command is not necessary.
394 static void loadcmd()
397 if (!load_dev(dev)) {
398 Pmsg1(0, "Bad status from load. ERR=%s\n", strerror_dev(dev));
400 Pmsg1(0, "Loaded %s\n", dev_name(dev));
406 static void rewindcmd()
408 if (!rewind_dev(dev)) {
409 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
410 clrerror_dev(dev, -1);
412 Pmsg1(0, "Rewound %s\n", dev_name(dev));
417 * Clear any tape error
419 static void clearcmd()
421 clrerror_dev(dev, -1);
425 * Write and end of file on the tape
427 static void weofcmd()
438 if ((stat = weof_dev(dev, num)) < 0) {
439 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
442 Pmsg3(0, "Wrote %d EOF%s to %s\n", num, num==1?"":"s", dev_name(dev));
447 /* Go to the end of the medium -- raw command
448 * The idea was orginally that the end of the Bacula
449 * medium would be flagged differently. This is not
450 * currently the case. So, this is identical to the
456 Pmsg1(0, "%s", strerror_dev(dev));
459 Pmsg0(0, _("Moved to end of medium.\n"));
464 * Go to the end of the medium (either hardware determined
465 * or defined by two eofs.
485 if (!bsf_dev(dev, num)) {
486 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
488 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
504 if (!bsr_dev(dev, num)) {
505 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
507 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
512 * List device capabilities as defined in the
517 printf(_("Configured device capabilities:\n"));
518 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
519 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
520 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
521 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
522 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
523 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
524 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
525 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
526 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
527 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
528 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
529 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
530 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
533 printf(_("Device status:\n"));
534 printf("%sOPENED ", dev->state & ST_OPENED ? "" : "!");
535 printf("%sTAPE ", dev->state & ST_TAPE ? "" : "!");
536 printf("%sLABEL ", dev->state & ST_LABEL ? "" : "!");
537 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
538 printf("%sAPPEND ", dev->state & ST_APPEND ? "" : "!");
539 printf("%sREAD ", dev->state & ST_READ ? "" : "!");
540 printf("%sEOT ", dev->state & ST_EOT ? "" : "!");
541 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
542 printf("%sEOF ", dev->state & ST_EOF ? "" : "!");
543 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
544 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
547 printf(_("Device parameters:\n"));
548 printf("Device name: %s\n", dev->dev_name);
549 printf("File=%u block=%u\n", dev->file, dev->block_num);
550 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
558 * Test writting larger and larger records.
559 * This is a torture test for records.
561 static void rectestcmd()
567 Pmsg0(0, "Test writting larger and larger records.\n"
568 "This is a torture test for records.\nI am going to write\n"
569 "larger and larger records. It will stop when the record size\n"
570 "plus the header exceeds the block size (by default about 64K)\n");
573 get_cmd("Do you want to continue? (y/n): ");
575 Pmsg0(000, "Command aborted.\n");
579 sm_check(__FILE__, __LINE__, false);
580 block = new_block(dev);
583 for (i=1; i<500000; i++) {
584 rec->data = check_pool_memory_size(rec->data, i);
585 memset(rec->data, i & 0xFF, i);
587 sm_check(__FILE__, __LINE__, false);
588 if (write_record_to_block(block, rec)) {
591 Pmsg2(0, "Block %d i=%d\n", blkno, i);
595 sm_check(__FILE__, __LINE__, false);
599 sm_check(__FILE__, __LINE__, false);
603 * This test attempts to re-read a block written by Bacula
604 * normally at the end of the tape. Bacula will then back up
605 * over the two eof marks, backup over the record and reread
606 * it to make sure it is valid. Bacula can skip this validation
607 * if you set "Backward space record = no"
609 static int re_read_block_test()
616 if (!(dev->capabilities & CAP_BSR)) {
617 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
621 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
622 "I'm going to write three records and an EOF\n"
623 "then backup over the EOF and re-read the last record.\n"
624 "Bacula does this after writing the last block on the\n"
625 "tape to verify that the block was written correctly.\n\n"
626 "This is not an *essential* feature ...\n\n"));
628 block = new_block(dev);
630 rec->data = check_pool_memory_size(rec->data, block->buf_len);
631 len = rec->data_len = block->buf_len-100;
632 memset(rec->data, 1, rec->data_len);
633 if (!write_record_to_block(block, rec)) {
634 Pmsg0(0, _("Error writing record to block.\n"));
637 if (!write_block_to_dev(jcr->dcr, block)) {
638 Pmsg0(0, _("Error writing block to device.\n"));
641 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
643 memset(rec->data, 2, rec->data_len);
644 if (!write_record_to_block(block, rec)) {
645 Pmsg0(0, _("Error writing record to block.\n"));
648 if (!write_block_to_dev(jcr->dcr, block)) {
649 Pmsg0(0, _("Error writing block to device.\n"));
652 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
654 memset(rec->data, 3, rec->data_len);
655 if (!write_record_to_block(block, rec)) {
656 Pmsg0(0, _("Error writing record to block.\n"));
659 if (!write_block_to_dev(jcr->dcr, block)) {
660 Pmsg0(0, _("Error writing block to device.\n"));
663 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
666 if (dev_cap(dev, CAP_TWOEOF)) {
669 if (!bsf_dev(dev, 1)) {
670 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
673 if (dev_cap(dev, CAP_TWOEOF)) {
674 if (!bsf_dev(dev, 1)) {
675 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
679 Pmsg0(0, "Backspaced over EOF OK.\n");
680 if (!bsr_dev(dev, 1)) {
681 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
684 Pmsg0(0, "Backspace record OK.\n");
685 if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
686 Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
689 memset(rec->data, 0, rec->data_len);
690 if (!read_record_from_block(block, rec)) {
691 Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
694 for (int i=0; i<len; i++) {
695 if (rec->data[i] != 3) {
696 Pmsg0(0, _("Bad data in record. Test failed!\n"));
700 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
701 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
709 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
710 "this function to verify the last block written to the\n"
711 "tape. Bacula will skip the last block verification\n"
713 "Backward Space Record = No\n\n"
714 "to your Storage daemon's Device resource definition.\n"));
721 * This test writes Bacula blocks to the tape in
722 * several files. It then rewinds the tape and attepts
723 * to read these blocks back checking the data.
725 static int write_read_test()
733 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
734 "I'm going to write 1000 records and an EOF\n"
735 "then write 1000 records and an EOF, then rewind,\n"
736 "and re-read the data to verify that it is correct.\n\n"
737 "This is an *essential* feature ...\n\n"));
738 block = new_block(dev);
740 if (!rewind_dev(dev)) {
741 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
744 rec->data = check_pool_memory_size(rec->data, block->buf_len);
745 rec->data_len = block->buf_len-100;
746 len = rec->data_len/sizeof(i);
747 for (i=1; i<=1000; i++) {
748 p = (int *)rec->data;
749 for (j=0; j<len; j++) {
752 if (!write_record_to_block(block, rec)) {
753 Pmsg0(0, _("Error writing record to block.\n"));
756 if (!write_block_to_dev(jcr->dcr, block)) {
757 Pmsg0(0, _("Error writing block to device.\n"));
761 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
763 for (i=1001; i<=2000; i++) {
764 p = (int *)rec->data;
765 for (j=0; j<len; j++) {
768 if (!write_record_to_block(block, rec)) {
769 Pmsg0(0, _("Error writing record to block.\n"));
772 if (!write_block_to_dev(jcr->dcr, block)) {
773 Pmsg0(0, _("Error writing block to device.\n"));
777 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
779 if (dev_cap(dev, CAP_TWOEOF)) {
782 if (!rewind_dev(dev)) {
783 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
786 Pmsg0(0, "Rewind OK.\n");
788 for (i=1; i<=2000; i++) {
790 if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
791 if (dev_state(dev, ST_EOF)) {
792 Pmsg0(-1, _("Got EOF on tape.\n"));
795 Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
798 memset(rec->data, 0, rec->data_len);
799 if (!read_record_from_block(block, rec)) {
800 Pmsg1(0, _("Read record failed! ERR=%s\n"), strerror(dev->dev_errno));
803 p = (int *)rec->data;
804 for (j=0; j<len; j++) {
806 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
812 if (i == 1000 || i == 2000) {
813 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
816 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
826 * This test writes Bacula blocks to the tape in
827 * several files. It then rewinds the tape and attepts
828 * to read these blocks back checking the data.
830 static int position_test()
838 int file = 0, blk = 0;
841 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
842 "I'm going to write 1000 records and an EOF\n"
843 "then write 1000 records and an EOF, then rewind,\n"
844 "and position to a few blocks and verify that it is correct.\n\n"
845 "This is an *essential* feature ...\n\n"));
846 block = new_block(dev);
848 if (!rewind_dev(dev)) {
849 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
852 rec->data = check_pool_memory_size(rec->data, block->buf_len);
853 rec->data_len = block->buf_len-100;
854 len = rec->data_len/sizeof(i);
855 for (i=1; i<=1000; i++) {
856 p = (int *)rec->data;
857 for (j=0; j<len; j++) {
860 if (!write_record_to_block(block, rec)) {
861 Pmsg0(0, _("Error writing record to block.\n"));
864 if (!write_block_to_dev(jcr->dcr, block)) {
865 Pmsg0(0, _("Error writing block to device.\n"));
869 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
871 for (i=1001; i<=2000; i++) {
872 p = (int *)rec->data;
873 for (j=0; j<len; j++) {
876 if (!write_record_to_block(block, rec)) {
877 Pmsg0(0, _("Error writing record to block.\n"));
880 if (!write_block_to_dev(jcr->dcr, block)) {
881 Pmsg0(0, _("Error writing block to device.\n"));
885 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
887 if (dev_cap(dev, CAP_TWOEOF)) {
890 if (!rewind_dev(dev)) {
891 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
894 Pmsg0(0, "Rewind OK.\n");
898 /* Set up next item to read based on where we are */
934 Pmsg2(-1, "Reposition to file:block %d:%d\n", file, blk);
935 if (!reposition_dev(dev, file, blk)) {
936 Pmsg0(0, "Reposition error.\n");
940 if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
941 if (dev_state(dev, ST_EOF)) {
942 Pmsg0(-1, _("Got EOF on tape.\n"));
945 Pmsg1(0, _("Read block failed! ERR=%s\n\n"), strerror(dev->dev_errno));
946 Pmsg0(0, _("This may be because the tape drive block size is not\n"
947 " set to variable blocking as normally used by Bacula.\n"
948 " Please see the Tape Testing chapter in the manual and \n"
949 " look for using mt with defblksize and setoptions\n"));
952 memset(rec->data, 0, rec->data_len);
953 if (!read_record_from_block(block, rec)) {
954 Pmsg1(0, _("Read record failed! ERR=%s\n"), strerror(dev->dev_errno));
957 p = (int *)rec->data;
958 for (j=0; j<len; j++) {
960 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
965 Pmsg0(-1, _("Block re-read correctly.\n"));
967 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
980 * This test writes some records, then writes an end of file,
981 * rewinds the tape, moves to the end of the data and attepts
982 * to append to the tape. This function is essential for
983 * Bacula to be able to write multiple jobs to the tape.
985 static int append_test()
987 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
988 "This test is essential to Bacula.\n\n"
989 "I'm going to write one record in file 0,\n"
990 " two records in file 1,\n"
991 " and three records in file 2\n\n"));
995 weofcmd(); /* end file 0 */
998 weofcmd(); /* end file 1 */
1002 weofcmd(); /* end file 2 */
1003 if (dev_cap(dev, CAP_TWOEOF)) {
1007 Pmsg0(0, _("Now moving to end of medium.\n"));
1009 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1010 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1012 if (dev->file != 3) {
1016 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1019 if (dev_cap(dev, CAP_TWOEOF)) {
1023 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1024 Pmsg0(-1, "Doing Bacula scan of blocks:\n");
1026 Pmsg0(-1, _("End scanning the tape.\n"));
1027 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1028 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1030 if (dev->file != 4) {
1038 * This test exercises the autochanger
1040 static int autochanger_test()
1042 POOLMEM *results, *changer;
1043 int slot, status, loaded;
1044 int timeout = jcr->device->max_changer_wait;
1047 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1048 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1051 if (!(jcr->device && jcr->device->changer_name && jcr->device->changer_command)) {
1052 Pmsg0(-1, "\nAutochanger enabled, but no name or no command device specified.\n");
1056 Pmsg0(-1, "\nAh, I see you have an autochanger configured.\n"
1057 "To test the autochanger you must have a blank tape\n"
1058 " that I can write on in Slot 1.\n");
1059 if (!get_cmd("\nDo you wish to continue with the Autochanger test? (y/n): ")) {
1062 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1066 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1068 results = get_pool_memory(PM_MESSAGE);
1069 changer = get_pool_memory(PM_FNAME);
1073 jcr->VolCatInfo.Slot = slot;
1074 /* Find out what is loaded, zero means device is unloaded */
1075 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1076 changer = edit_device_codes(jcr, changer, jcr->device->changer_command,
1078 status = run_program(changer, timeout, results);
1079 Dmsg3(100, "run_prog: %s stat=%d result=%s\n", changer, status, results);
1081 loaded = atoi(results);
1083 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1084 Pmsg2(-1, _("3991 status=%d result=%s\n"), status, results);
1088 Pmsg1(-1, "Slot %d loaded. I am going to unload it.\n", loaded);
1090 Pmsg0(-1, "Nothing loaded in the drive. OK.\n");
1092 Dmsg1(100, "Results from loaded query=%s\n", results);
1094 jcr->VolCatInfo.Slot = loaded;
1095 offline_or_rewind_dev(dev);
1096 /* We are going to load a new tape, so close the device */
1097 force_close_dev(dev);
1098 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1099 loaded, dev->drive_index);
1100 changer = edit_device_codes(jcr, changer,
1101 jcr->device->changer_command, "unload");
1102 status = run_program(changer, timeout, results);
1103 Pmsg2(-1, "unload status=%s %d\n", status==0?"OK":"Bad", status);
1105 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1106 Pmsg2(-1, _("3992 status=%d result=%s\n"), status, results);
1115 jcr->VolCatInfo.Slot = slot;
1116 Pmsg2(-1, _("3303 Issuing autochanger \"load slot %d %d\" command.\n"),
1117 slot, dev->drive_index);
1118 changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "load");
1119 Dmsg1(100, "Changer=%s\n", changer);
1120 force_close_dev(dev);
1121 status = run_program(changer, timeout, results);
1123 Pmsg2(-1, _("3303 Autochanger \"load slot %d %d\" status is OK.\n"),
1124 slot, dev->drive_index);
1126 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1127 Pmsg2(-1, _("3993 status=%d result=%s\n"), status, results);
1131 if (!open_the_device()) {
1134 bmicrosleep(sleep_time, 0);
1135 if (!rewind_dev(dev)) {
1136 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
1137 clrerror_dev(dev, -1);
1138 Pmsg0(-1, "\nThe test failed, probably because you need to put\n"
1139 "a longer sleep time in the mtx-script in the load) case.\n"
1140 "Adding a 30 second sleep and trying again ...\n");
1144 Pmsg1(0, "Rewound %s\n", dev_name(dev));
1147 if ((status = weof_dev(dev, 1)) < 0) {
1148 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", status, strerror_dev(dev));
1151 Pmsg1(0, "Wrote EOF to %s\n", dev_name(dev));
1155 Pmsg1(-1, "\nThe test worked this time. Please add:\n\n"
1157 "to your mtx-changer script in the load) case.\n\n",
1160 Pmsg0(-1, "\nThe test autochanger worked!!\n\n");
1163 free_pool_memory(changer);
1164 free_pool_memory(results);
1169 free_pool_memory(changer);
1170 free_pool_memory(results);
1171 Pmsg0(-1, "You must correct this error or the Autochanger will not work.\n");
1175 static void autochangercmd()
1182 * This test assumes that the append test has been done,
1183 * then it tests the fsf function.
1185 static int fsf_test()
1187 bool set_off = false;
1189 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1190 "This test is essential to Bacula.\n\n"
1191 "I'm going to write five files then test forward spacing\n\n"));
1195 weofcmd(); /* end file 0 */
1198 weofcmd(); /* end file 1 */
1202 weofcmd(); /* end file 2 */
1205 weofcmd(); /* end file 3 */
1207 weofcmd(); /* end file 4 */
1208 if (dev_cap(dev, CAP_TWOEOF)) {
1214 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1215 if (!fsf_dev(dev, 1)) {
1216 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1219 Pmsg2(-1, _("We should be in file 1. I am at file %d. This is %s\n"),
1220 dev->file, dev->file == 1 ? "correct!" : "NOT correct!!!!");
1222 if (dev->file != 1) {
1226 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1227 if (!fsf_dev(dev, 2)) {
1228 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1231 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1232 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1234 if (dev->file != 3) {
1239 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1240 if (!fsf_dev(dev, 4)) {
1241 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1244 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1245 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1247 if (dev->file != 4) {
1251 Pmsg0(-1, "The test worked this time. Please add:\n\n"
1252 " Fast Forward Space File = no\n\n"
1253 "to your Device resource for this drive.\n");
1257 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1258 if (!fsf_dev(dev, 1)) {
1259 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1261 Pmsg2(-1, _("We should be in file 5. I am at file %d. This is %s\n"),
1262 dev->file, dev->file == 5 ? "correct!" : "NOT correct!!!!");
1263 if (dev->file != 5) {
1266 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1270 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1271 if (dev_cap(dev, CAP_FASTFSF)) {
1272 Pmsg0(-1, "You have Fast Forward Space File enabled.\n"
1273 "I am turning it off then retrying the test.\n");
1274 dev->capabilities &= ~CAP_FASTFSF;
1278 Pmsg0(-1, "You must correct this error or Bacula will not work.\n");
1287 * This is a general test of Bacula's functions
1288 * needed to read and write the tape.
1290 static void testcmd()
1294 if (!write_read_test()) {
1297 if (!position_test()) {
1301 stat = append_test();
1302 if (stat == 1) { /* OK get out */
1305 if (stat == -1) { /* first test failed */
1306 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1307 Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
1308 "Setting \"Hardware End of Medium = no\n"
1309 " and \"Fast Forward Space File = no\n"
1310 "and retrying append test.\n\n");
1311 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1312 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1313 stat = append_test();
1315 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1316 " Hardware End of Medium = No\n\n"
1317 " Fast Forward Space File = No\n"
1318 "to your Device resource in the Storage conf file.\n");
1322 Pmsg0(-1, "\n\nThat appears *NOT* to have corrected the problem.\n");
1325 /* Wrong count after append */
1327 Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
1328 "Setting \"BSF at EOM = yes\" and retrying append test.\n");
1329 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1330 stat = append_test();
1332 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1333 " Hardware End of Medium = No\n"
1334 " Fast Forward Space File = No\n"
1335 " BSF at EOM = yes\n\n"
1336 "to your Device resource in the Storage conf file.\n");
1343 Pmsg0(-1, "\nAppend test failed.\n\n");
1344 Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1345 "Unable to correct the problem. You MUST fix this\n"
1346 "problem before Bacula can use your tape drive correctly\n");
1347 Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
1348 "Do so by setting:\n\n"
1349 "Minimum Block Size = nnn\n"
1350 "Maximum Block Size = nnn\n\n"
1351 "in your Storage daemon's Device definition.\n"
1352 "nnn must match your tape driver's block size, which\n"
1353 "can be determined by reading your tape manufacturers\n"
1354 "information, and the information on your kernel dirver.\n"
1355 "Fixed block sizes, however, are not normally an ideal solution.\n");
1360 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1361 "Please double check it ...\n"
1362 "=== Sample correct output ===\n"
1363 "1 block of 64448 bytes in file 1\n"
1364 "End of File mark.\n"
1365 "2 blocks of 64448 bytes in file 2\n"
1366 "End of File mark.\n"
1367 "3 blocks of 64448 bytes in file 3\n"
1368 "End of File mark.\n"
1369 "1 block of 64448 bytes in file 4\n"
1370 "End of File mark.\n"
1371 "Total files=4, blocks=7, bytes = 451,136\n"
1372 "=== End sample correct output ===\n\n"));
1374 Pmsg0(-1, _("If the above scan output is not identical to the\n"
1375 "sample output, you MUST correct the problem\n"
1376 "or Bacula will not be able to write multiple Jobs to \n"
1380 re_read_block_test();
1383 fsf_test(); /* do fast forward space file test */
1385 autochanger_test(); /* do autochanger test */
1389 /* Forward space a file */
1390 static void fsfcmd()
1394 num = atoi(argk[1]);
1399 if (!fsf_dev(dev, num)) {
1400 Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
1403 Pmsg2(0, "Forward spaced %d file%s.\n", num, num==1?"":"s");
1406 /* Forward space a record */
1407 static void fsrcmd()
1411 num = atoi(argk[1]);
1416 if (!fsr_dev(dev, num)) {
1417 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1420 Pmsg2(0, "Forward spaced %d record%s.\n", num, num==1?"":"s");
1425 * Write a Bacula block to the tape
1433 sm_check(__FILE__, __LINE__, false);
1434 block = new_block(dev);
1436 dump_block(block, "test");
1438 i = block->buf_len - 100;
1440 rec->data = check_pool_memory_size(rec->data, i);
1441 memset(rec->data, i & 0xFF, i);
1443 sm_check(__FILE__, __LINE__, false);
1444 if (!write_record_to_block(block, rec)) {
1445 Pmsg0(0, _("Error writing record to block.\n"));
1448 if (!write_block_to_dev(jcr->dcr, block)) {
1449 Pmsg0(0, _("Error writing block to device.\n"));
1452 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1454 Pmsg0(0, _("Wrote block to device.\n"));
1457 sm_check(__FILE__, __LINE__, false);
1460 sm_check(__FILE__, __LINE__, false);
1464 * Read a record from the tape
1471 if (!get_cmd("Enter length to read: ")) {
1475 if (len < 0 || len > 1000000) {
1476 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1479 buf = (char *)malloc(len);
1480 stat = read(dev->fd, buf, len);
1481 if (stat > 0 && stat <= len) {
1484 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1485 len, stat, strerror(errno));
1491 * Scan tape by reading block by block. Report what is
1492 * on the tape. Note, this command does raw reads, and as such
1493 * will not work with fixed block size devices.
1495 static void scancmd()
1498 int blocks, tot_blocks, tot_files;
1504 blocks = block_size = tot_blocks = 0;
1506 if (dev->state & ST_EOT) {
1507 Pmsg0(0, "End of tape\n");
1510 update_pos_dev(dev);
1511 tot_files = dev->file;
1512 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1514 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1515 clrerror_dev(dev, -1);
1516 Mmsg2(&dev->errmsg, "read error on %s. ERR=%s.\n",
1517 dev->dev_name, strerror(dev->dev_errno));
1518 Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
1520 printf("%d block%s of %d bytes in file %d\n",
1521 blocks, blocks>1?"s":"", block_size, dev->file);
1524 Dmsg1(200, "read status = %d\n", stat);
1526 if (stat != block_size) {
1527 update_pos_dev(dev);
1529 printf("%d block%s of %d bytes in file %d\n",
1530 blocks, blocks>1?"s":"", block_size, dev->file);
1535 if (stat == 0) { /* EOF */
1536 update_pos_dev(dev);
1537 printf("End of File mark.\n");
1538 /* Two reads of zero means end of tape */
1539 if (dev->state & ST_EOF)
1540 dev->state |= ST_EOT;
1542 dev->state |= ST_EOF;
1545 if (dev->state & ST_EOT) {
1546 printf("End of tape\n");
1549 } else { /* Got data */
1550 dev->state &= ~ST_EOF;
1556 update_pos_dev(dev);
1557 tot_files = dev->file - tot_files;
1558 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1559 edit_uint64_with_commas(bytes, ec1));
1564 * Scan tape by reading Bacula block by block. Report what is
1565 * on the tape. This function reads Bacula blocks, so if your
1566 * Device resource is correctly defined, it should work with
1567 * either variable or fixed block sizes.
1569 static void scan_blocks()
1571 int blocks, tot_blocks, tot_files;
1572 uint32_t block_size;
1577 block = new_block(dev);
1578 blocks = block_size = tot_blocks = 0;
1581 update_pos_dev(dev);
1582 tot_files = dev->file;
1584 if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
1585 Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
1586 if (dev->state & ST_EOT) {
1588 printf("%d block%s of %d bytes in file %d\n",
1589 blocks, blocks>1?"s":"", block_size, dev->file);
1594 if (dev->state & ST_EOF) {
1596 printf("%d block%s of %d bytes in file %d\n",
1597 blocks, blocks>1?"s":"", block_size, dev->file);
1600 printf(_("End of File mark.\n"));
1603 if (dev->state & ST_SHORT) {
1605 printf("%d block%s of %d bytes in file %d\n",
1606 blocks, blocks>1?"s":"", block_size, dev->file);
1609 printf(_("Short block read.\n"));
1612 printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1615 if (block->block_len != block_size) {
1617 printf("%d block%s of %d bytes in file %d\n",
1618 blocks, blocks>1?"s":"", block_size, dev->file);
1621 block_size = block->block_len;
1625 bytes += block->block_len;
1626 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1627 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1628 block->VolSessionId, block->VolSessionTime);
1630 DEV_RECORD *rec = new_record();
1631 read_record_from_block(block, rec);
1632 Pmsg8(-1, "Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
1633 block->BlockNumber, dev->block_num, block->block_len,
1634 FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1635 stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
1638 } else if (verbose > 1) {
1639 dump_block(block, "");
1645 tot_files = dev->file - tot_files;
1646 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1647 edit_uint64_with_commas(bytes, ec1));
1651 static void statcmd()
1653 int debug = debug_level;
1655 Pmsg2(0, "Device status: %u. ERR=%s\n", status_dev(dev), strerror_dev(dev));
1657 dump_volume_label(dev);
1659 debug_level = debug;
1664 * First we label the tape, then we fill
1665 * it with data get a new tape and write a few blocks.
1667 static void fillcmd()
1674 uint32_t min_block_size;
1684 This command simulates Bacula writing to a tape.\n\
1685 It requires either one or two blank tapes, which it\n\
1686 will label and write.\n\n\
1687 If you have an autochanger configured, it will use\n\
1688 the tapes that are in slots 1 and 2, otherwise, you will\n\
1689 be prompted to insert the tapes when necessary.\n\n\
1690 It will print a status approximately\n\
1691 every 322 MB, and write an EOF every 3.2 GB. If you have\n\
1692 selected the simple test option, after writing the first tape\n\
1693 it will rewind it and re-read the last block written.\n\n\
1694 If you have selected the multiple tape test, when the first tape\n\
1695 fills, it will ask for a second, and after writing a few more \n\
1696 blocks, it will stop. Then it will begin re-reading the\n\
1698 This may take a long time -- hours! ...\n\n");
1700 get_cmd("Do you want to run the simplified test (s) with one tape\n"
1701 "or the complete multiple tape (m) test: (s/m) ");
1702 if (cmd[0] == 's') {
1703 Pmsg0(-1, "Simple test (single tape) selected.\n");
1705 } else if (cmd[0] == 'm') {
1706 Pmsg0(-1, "Multiple tape test selected.\n");
1709 Pmsg0(000, "Command aborted.\n");
1713 Dmsg1(20, "Begin append device=%s\n", dev_name(dev));
1714 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1716 /* Use fixed block size to simplify read back */
1717 min_block_size = dev->min_block_size;
1718 dev->min_block_size = dev->max_block_size;
1721 * Acquire output device for writing. Note, after acquiring a
1722 * device, we MUST release it, which is done at the end of this
1725 Dmsg0(100, "just before acquire_device\n");
1726 if (!acquire_device_for_append(jcr)) {
1727 set_jcr_job_status(jcr, JS_ErrorTerminated);
1730 block = jcr->dcr->block;
1732 Dmsg0(100, "Just after acquire_device_for_append\n");
1734 * Write Begin Session Record
1736 if (!write_session_label(jcr, block, SOS_LABEL)) {
1737 set_jcr_job_status(jcr, JS_ErrorTerminated);
1738 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1742 Pmsg0(-1, "Wrote Start Of Session label.\n");
1744 memset(&rec, 0, sizeof(rec));
1745 rec.data = get_memory(100000); /* max record size */
1747 #define REC_SIZE 32768
1748 rec.data_len = REC_SIZE;
1751 * Put some random data in the record
1753 fd = open("/dev/urandom", O_RDONLY);
1755 read(fd, rec.data, rec.data_len);
1758 uint32_t *p = (uint32_t *)rec.data;
1759 srandom(time(NULL));
1760 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1766 * Generate data as if from File daemon, write to device
1768 jcr->dcr->VolFirstIndex = 0;
1769 time(&jcr->run_time); /* start counting time for rates */
1771 Pmsg0(-1, "Begin writing Bacula records to tape ...\n");
1773 Pmsg0(-1, "Begin writing Bacula records to first tape ...\n");
1775 for (file_index = 0; ok && !job_canceled(jcr); ) {
1776 rec.VolSessionId = jcr->VolSessionId;
1777 rec.VolSessionTime = jcr->VolSessionTime;
1778 rec.FileIndex = ++file_index;
1779 rec.Stream = STREAM_FILE_DATA;
1781 /* Mix up the data just a bit */
1782 uint32_t *lp = (uint32_t *)rec.data;
1784 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1788 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1789 rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1792 while (!write_record_to_block(block, &rec)) {
1794 * When we get here we have just filled a block
1796 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1799 /* Write block to tape */
1800 if (!flush_block(block, 1)) {
1804 /* Every 5000 blocks (approx 322MB) report where we are.
1806 if ((block->BlockNumber % 5000) == 0) {
1808 now -= jcr->run_time;
1810 now = 1; /* prevent divide error */
1812 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1813 Pmsg4(-1, "Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n",
1814 block->BlockNumber, dev->block_num,
1815 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1817 /* Every 15000 blocks (approx 1GB) write an EOF.
1819 if ((block->BlockNumber % 15000) == 0) {
1820 Pmsg0(-1, "Flush block, write EOF\n");
1821 flush_block(block, 0);
1825 /* Get out after writing 10 blocks to the second tape */
1826 if (++BlockNumber > 10 && stop != 0) { /* get out */
1831 Pmsg0(000, _("Not OK\n"));
1834 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1835 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1836 FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1837 stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1839 /* Get out after writing 10 blocks to the second tape */
1840 if (BlockNumber > 10 && stop != 0) { /* get out */
1841 Pmsg0(-1, "Done writing ...\n");
1846 Dmsg0(100, "Write_end_session_label()\n");
1847 /* Create Job status for end of session label */
1848 if (!job_canceled(jcr) && ok) {
1849 set_jcr_job_status(jcr, JS_Terminated);
1851 set_jcr_job_status(jcr, JS_ErrorTerminated);
1853 if (!write_session_label(jcr, block, EOS_LABEL)) {
1854 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1857 /* Write out final block of this session */
1858 if (!write_block_to_device(jcr->dcr, block)) {
1859 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1862 Pmsg0(-1, _("Wrote End Of Session label.\n"));
1864 /* Save last block info for second tape */
1865 last_block_num2 = last_block_num;
1866 last_file2 = last_file;
1868 free_block(last_block2);
1870 last_block2 = dup_block(last_block);
1873 sprintf(buf, "%s/btape.state", working_directory);
1874 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1876 write(fd, &btape_state_level, sizeof(btape_state_level));
1877 write(fd, &simple, sizeof(simple));
1878 write(fd, &last_block_num1, sizeof(last_block_num1));
1879 write(fd, &last_block_num2, sizeof(last_block_num2));
1880 write(fd, &last_file1, sizeof(last_file1));
1881 write(fd, &last_file2, sizeof(last_file2));
1882 write(fd, last_block1->buf, last_block1->buf_len);
1883 write(fd, last_block2->buf, last_block2->buf_len);
1884 write(fd, first_block->buf, first_block->buf_len);
1886 Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
1887 last_block_num1, last_block_num2);
1889 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
1893 /* Release the device if multiple tapes being used */
1894 if (!simple && !release_device(jcr)) {
1895 Pmsg0(-1, _("Error in release_device\n"));
1900 Pmsg2(-1, _("\n\nDone filling tape%s. Now beginning re-read of %stape ...\n"),
1901 simple?"":"s", simple?"":"first ");
1905 dev->min_block_size = min_block_size;
1906 free_memory(rec.data);
1910 * Read two tapes written by the "fill" command and ensure
1911 * that the data is valid. If stop==1 we simulate full read back
1912 * of two tapes. If stop==-1 we simply read the last block and
1913 * verify that it is correct.
1915 static void unfillcmd()
1919 last_block1 = new_block(dev);
1920 last_block2 = new_block(dev);
1921 first_block = new_block(dev);
1922 sprintf(buf, "%s/btape.state", working_directory);
1923 fd = open(buf, O_RDONLY);
1925 uint32_t state_level;
1926 read(fd, &state_level, sizeof(btape_state_level));
1927 read(fd, &simple, sizeof(simple));
1928 read(fd, &last_block_num1, sizeof(last_block_num1));
1929 read(fd, &last_block_num2, sizeof(last_block_num2));
1930 read(fd, &last_file1, sizeof(last_file1));
1931 read(fd, &last_file2, sizeof(last_file2));
1932 read(fd, last_block1->buf, last_block1->buf_len);
1933 read(fd, last_block2->buf, last_block2->buf_len);
1934 read(fd, first_block->buf, first_block->buf_len);
1936 if (state_level != btape_state_level) {
1937 Pmsg0(-1, "\nThe state file level has changed. You must redo\n"
1938 "the fill command.\n");
1942 Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
1943 "You must redo the fill command.\n", buf, strerror(errno));
1950 static void do_unfill()
1958 block = new_block(dev);
1960 Dmsg0(20, "Enter do_unfill\n");
1961 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
1962 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
1966 time(&jcr->run_time); /* start counting time for rates */
1970 free_block(last_block);
1972 last_block_num = last_block_num1;
1973 last_file = last_file1;
1974 last_block = last_block1;
1977 /* Multiple Volume tape */
1978 /* Close device so user can use autochanger if desired */
1979 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1982 autochanger = autoload_device(jcr, dev, 1, NULL);
1984 force_close_dev(dev);
1985 get_cmd(_("Mount first tape. Press enter when ready: "));
1989 set_volume_name("TestVolume1", 1);
1991 create_vol_list(jcr);
1993 dev->state &= ~ST_READ;
1994 if (!acquire_device_for_read(jcr)) {
1995 Pmsg1(-1, "%s", dev->errmsg);
2000 * We now have the first tape mounted.
2001 * Note, re-reading last block may have caused us to
2002 * loose track of where we are (block number unknown).
2004 rewind_dev(dev); /* get to a known place on tape */
2005 /* Read the first 1000 records */
2006 Pmsg0(-1, _("Reading the first 1000 records.\n"));
2007 read_records(jcr, dev, quickie_cb, my_mount_next_read_volume);
2008 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2009 last_file, last_block_num);
2010 if (!reposition_dev(dev, last_file, last_block_num)) {
2011 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2013 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2014 if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
2015 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2018 if (compare_blocks(last_block, block)) {
2020 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2022 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2029 /* restore info for last block on second Volume */
2030 last_block_num = last_block_num2;
2031 last_file = last_file2;
2032 last_block = last_block2;
2034 /* Multiple Volume tape */
2035 /* Close device so user can use autochanger if desired */
2036 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2041 set_volume_name("TestVolume2", 2);
2043 create_vol_list(jcr);
2044 autochanger = autoload_device(jcr, dev, 1, NULL);
2046 force_close_dev(dev);
2047 get_cmd(_("Mount second tape. Press enter when ready: "));
2050 dev->state &= ~ST_READ;
2051 if (!acquire_device_for_read(jcr)) {
2052 Pmsg1(-1, "%s", dev->errmsg);
2056 /* Space to "first" block which is last block not written
2057 * on the previous tape.
2059 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2060 if (!reposition_dev(dev, 0, 1)) {
2061 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2064 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2065 if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
2066 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2069 if (compare_blocks(first_block, block)) {
2070 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2073 /* Now find and compare the last block */
2074 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2075 last_file, last_block_num);
2076 if (!reposition_dev(dev, last_file, last_block_num)) {
2077 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2080 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2081 if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
2082 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2085 if (compare_blocks(last_block, block)) {
2086 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2091 free_block(last_block1);
2092 free_block(last_block2);
2093 free_block(first_block);
2096 /* Read 1000 records then stop */
2097 static int quickie_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
2100 return quickie_count <= 1000;
2103 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2106 uint32_t CheckSum, block_len;
2109 p = last_block->buf;
2111 unser_begin(q, BLKHDR2_LENGTH);
2112 unser_uint32(CheckSum);
2113 unser_uint32(block_len);
2114 while (q < (block->buf+block_len)) {
2121 dump_block(last_block, _("Last block written"));
2123 dump_block(block, _("Block read back"));
2124 Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf);
2125 Pmsg0(-1, "\n\n!!!! The last block written and the block\n"
2126 "that was read back differ. The test FAILED !!!!\n"
2127 "This must be corrected before you use Bacula\n"
2128 "to write multi-tape Volumes.!!!!\n");
2132 dump_block(last_block, _("Last block written"));
2133 dump_block(block, _("Block read back"));
2143 * Write current block to tape regardless of whether or
2144 * not it is full. If the tape fills, attempt to
2145 * acquire another tape.
2147 static int flush_block(DEV_BLOCK *block, int dump)
2152 uint32_t this_file, this_block_num;
2155 this_block = new_block(dev);
2158 last_block = new_block(dev);
2161 this_file = dev->file;
2162 this_block_num = dev->block_num;
2163 if (!write_block_to_dev(jcr->dcr, block)) {
2164 Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n",
2165 last_file, last_block_num, this_block_num);
2168 * This is 1st tape, so save first tape info separate
2169 * from second tape info
2171 last_block_num1 = last_block_num;
2172 last_file1 = last_file;
2173 last_block1 = dup_block(last_block);
2174 last_block2 = dup_block(last_block);
2175 first_block = dup_block(block); /* first block second tape */
2178 Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n",
2179 (unsigned)file_index, block->BlockNumber, block->block_len);
2180 dump_block(last_block, "Last block written");
2182 dump_block(block, "Block not written");
2185 eot_block = block->BlockNumber;
2186 eot_block_len = block->block_len;
2187 eot_FileIndex = file_index;
2191 now -= jcr->run_time;
2193 now = 1; /* don't divide by zero */
2195 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2196 vol_size = dev->VolCatInfo.VolCatBytes;
2197 Pmsg2(000, "End of tape. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
2198 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2201 stop = -1; /* stop, but do simplified test */
2203 /* Full test in progress */
2204 if (!fixup_device_block_write_error(jcr, dev, block)) {
2205 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2210 BlockNumber = 0; /* start counting for second tape */
2213 return 1; /* end of tape reached */
2216 /* Save contents after write so that the header is serialized */
2217 memcpy(this_block->buf, block->buf, this_block->buf_len);
2220 * Toggle between two allocated blocks for efficiency.
2221 * Switch blocks so that the block just successfully written is
2222 * always in last_block.
2224 tblock = last_block;
2225 last_block = this_block;
2226 this_block = tblock;
2227 last_file = this_file;
2228 last_block_num = this_block_num;
2236 * First we label the tape, then we fill
2237 * it with data get a new tape and write a few blocks.
2239 static void qfillcmd()
2245 Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
2247 get_cmd("How many blocks do you want to write? (1000): ");
2254 sm_check(__FILE__, __LINE__, false);
2255 block = new_block(dev);
2258 i = block->buf_len - 100;
2260 rec->data = check_pool_memory_size(rec->data, i);
2261 memset(rec->data, i & 0xFF, i);
2264 Pmsg1(0, "Begin writing %d Bacula blocks to tape ...\n", count);
2265 for (i=0; i < count; i++) {
2270 if (!write_record_to_block(block, rec)) {
2271 Pmsg0(0, _("Error writing record to block.\n"));
2274 if (!write_block_to_dev(jcr->dcr, block)) {
2275 Pmsg0(0, _("Error writing block to device.\n"));
2281 if (dev_cap(dev, CAP_TWOEOF)) {
2288 sm_check(__FILE__, __LINE__, false);
2291 sm_check(__FILE__, __LINE__, false);
2296 * Fill a tape using raw write() command
2298 static void rawfill_cmd()
2303 uint32_t block_num = 0;
2308 block = new_block(dev);
2309 fd = open("/dev/urandom", O_RDONLY);
2311 read(fd, block->buf, block->buf_len);
2314 uint32_t *p = (uint32_t *)block->buf;
2315 srandom(time(NULL));
2316 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2320 p = (uint32_t *)block->buf;
2321 Pmsg1(0, "Begin writing raw blocks of %u bytes.\n", block->buf_len);
2324 stat = write(dev->fd, block->buf, block->buf_len);
2325 if (stat == (int)block->buf_len) {
2326 if ((block_num++ % 100) == 0) {
2331 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2340 printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
2341 strerror(my_errno));
2348 * Fill a tape using raw write() command
2350 static void bfill_cmd()
2353 uint32_t block_num = 0;
2359 block = new_block(dev);
2360 fd = open("/dev/urandom", O_RDONLY);
2362 read(fd, block->buf, block->buf_len);
2365 uint32_t *p = (uint32_t *)block->buf;
2366 srandom(time(NULL));
2367 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2371 p = (uint32_t *)block->buf;
2372 Pmsg1(0, "Begin writing Bacula blocks of %u bytes.\n", block->buf_len);
2375 block->binbuf = block->buf_len;
2376 block->bufp = block->buf + block->binbuf;
2377 if (!write_block_to_dev(jcr->dcr, block)) {
2380 if ((block_num++ % 100) == 0) {
2385 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2391 printf("Write failed at block %u.\n", block_num);
2397 struct cmdstruct { char *key; void (*func)(); char *help; };
2398 static struct cmdstruct commands[] = {
2399 {"autochanger", autochangercmd, "test autochanger"},
2400 {"bsf", bsfcmd, "backspace file"},
2401 {"bsr", bsrcmd, "backspace record"},
2402 {"bfill", bfill_cmd, "fill tape using Bacula writes"},
2403 {"cap", capcmd, "list device capabilities"},
2404 {"clear", clearcmd, "clear tape errors"},
2405 {"eod", eodcmd, "go to end of Bacula data for append"},
2406 {"eom", eomcmd, "go to the physical end of medium"},
2407 {"fill", fillcmd, "fill tape, write onto second volume"},
2408 {"unfill", unfillcmd, "read filled tape"},
2409 {"fsf", fsfcmd, "forward space a file"},
2410 {"fsr", fsrcmd, "forward space a record"},
2411 {"help", helpcmd, "print this command"},
2412 {"label", labelcmd, "write a Bacula label to the tape"},
2413 {"load", loadcmd, "load a tape"},
2414 {"quit", quitcmd, "quit btape"},
2415 {"rawfill", rawfill_cmd, "use write() to fill tape"},
2416 {"readlabel", readlabelcmd, "read and print the Bacula tape label"},
2417 {"rectest", rectestcmd, "test record handling functions"},
2418 {"rewind", rewindcmd, "rewind the tape"},
2419 {"scan", scancmd, "read() tape block by block to EOT and report"},
2420 {"scanblocks", scan_blocks, "Bacula read block by block to EOT and report"},
2421 {"status", statcmd, "print tape status"},
2422 {"test", testcmd, "General test Bacula tape functions"},
2423 {"weof", weofcmd, "write an EOF on the tape"},
2424 {"wr", wrcmd, "write a single Bacula block"},
2425 {"rr", rrcmd, "read a single record"},
2426 {"qfill", qfillcmd, "quick fill command"},
2428 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2436 while (get_cmd("*")) {
2437 sm_check(__FILE__, __LINE__, false);
2439 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2440 for (i=0; i<comsize; i++) /* search for command */
2441 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2442 (*commands[i].func)(); /* go execute command */
2447 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2453 static void helpcmd()
2457 printf(_("Interactive commands:\n"));
2458 printf(_(" Command Description\n ======= ===========\n"));
2459 for (i=0; i<comsize; i++)
2460 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2467 "\nVersion: " VERSION " (" BDATE ")\n\n"
2468 "Usage: btape <options> <device_name>\n"
2469 " -b <file> specify bootstrap file\n"
2470 " -c <file> set configuration file to file\n"
2471 " -d <nn> set debug level to nn\n"
2472 " -p proceed inspite of I/O errors\n"
2473 " -s turn off signals\n"
2475 " -? print this message.\n"
2481 * Get next input command from terminal. This
2482 * routine is REALLY primitive, and should be enhanced
2483 * to have correct backspacing, etc.
2486 get_cmd(char *prompt)
2490 fprintf(stdout, prompt);
2492 /* We really should turn off echoing and pretty this
2496 while ((ch = fgetc(stdin)) != EOF) {
2498 strip_trailing_junk(cmd);
2500 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2513 /* Dummies to replace askdir.c */
2514 int dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
2515 int dir_send_job_status(JCR *jcr) {return 1;}
2517 int dir_update_volume_info(JCR *jcr, DEVICE *dev, int relabel)
2523 int dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing)
2525 Dmsg0(20, "Enter dir_get_volume_info\n");
2526 bstrncpy(jcr->VolCatInfo.VolCatName, jcr->VolumeName, sizeof(jcr->VolCatInfo.VolCatName));
2530 int dir_create_jobmedia_record(JCR *jcr)
2532 jcr->dcr->WroteVol = false;
2537 int dir_find_next_appendable_volume(JCR *jcr)
2539 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2540 return jcr->VolumeName[0] != 0;
2543 int dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev)
2545 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2546 if (jcr->VolumeName[0] == 0) {
2547 return dir_ask_sysop_to_create_appendable_volume(jcr, dev);
2549 /* Close device so user can use autochanger if desired */
2550 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2553 force_close_dev(dev);
2554 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2555 if (jcr->VolumeName[0] == 0 || strcmp(jcr->VolumeName, "TestVolume2") == 0) {
2556 fprintf(stderr, "Mount second Volume on device %s and press return when ready: ",
2559 fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
2560 jcr->VolumeName, dev_name(dev));
2566 int dir_ask_sysop_to_create_appendable_volume(JCR *jcr, DEVICE *dev)
2569 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2571 set_volume_name("TestVolume1", 1);
2573 set_volume_name("TestVolume2", 2);
2575 /* Close device so user can use autochanger if desired */
2576 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2579 autochanger = autoload_device(jcr, dev, 1, NULL);
2581 force_close_dev(dev);
2582 fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
2586 open_device(jcr, dev);
2593 static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)
2597 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2598 Pmsg1(000, "End of Volume \"%s\"\n", jcr->VolumeName);
2600 if (LastBlock != block->BlockNumber) {
2601 VolBytes += block->block_len;
2603 LastBlock = block->BlockNumber;
2605 now -= jcr->run_time;
2609 kbs = (double)VolBytes / (1000.0 * (double)now);
2610 Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2611 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2613 if (strcmp(jcr->VolumeName, "TestVolume2") == 0) {
2619 set_volume_name("TestVolume2", 2);
2621 create_vol_list(jcr);
2623 dev->state &= ~ST_READ;
2624 if (!acquire_device_for_read(jcr)) {
2625 Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), jcr->VolumeName);
2628 return 1; /* next volume mounted */
2631 static void set_volume_name(char *VolName, int volnum)
2633 DCR *dcr = jcr->dcr;
2634 VolumeName = VolName;
2636 pm_strcpy(&jcr->VolumeName, VolName);
2637 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2638 bstrncpy(jcr->VolCatInfo.VolCatName, VolName, sizeof(jcr->VolCatInfo.VolCatName));
2639 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2640 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2641 jcr->VolCatInfo.Slot = volnum;
2642 dcr->VolCatInfo.Slot = volnum;
2647 * Edit codes into ChangerCommand
2649 * %a = archive device name
2650 * %c = changer device name
2651 * %f = Client's name
2659 * omsg = edited output message
2660 * imsg = input string containing edit codes (%x)
2661 * cmd = command string (load, unload, ...)
2664 static char *edit_device_codes(JCR *jcr, char *omsg, char *imsg, char *cmd)
2671 Dmsg1(400, "edit_device_codes: %s\n", imsg);
2672 for (p=imsg; *p; p++) {
2679 str = dev_name(jcr->device->dev);
2682 str = NPRT(jcr->device->changer_name);
2688 sprintf(add, "%d", jcr->VolCatInfo.Slot - 1);
2692 sprintf(add, "%d", jcr->VolCatInfo.Slot);
2695 case 'j': /* Job name */
2699 str = NPRT(jcr->VolumeName);
2702 str = NPRT(jcr->client_name);
2717 Dmsg1(400, "add_str %s\n", str);
2718 pm_strcat(&omsg, (char *)str);
2719 Dmsg1(400, "omsg=%s\n", omsg);
2727 * We are called here from "unfill" for each record on the tape.
2729 static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
2731 SESSION_LABEL label;
2733 if (stop > 1 && !dumped) { /* on second tape */
2736 dump_block(block, "First block on second tape");
2738 Pmsg4(-1, "Blk: FileIndex=%d: block=%u size=%d vol=%s\n",
2739 rec->FileIndex, block->BlockNumber, block->block_len, dev->VolHdr.VolName);
2740 Pmsg6(-1, " Rec: VId=%d VT=%d FI=%s Strm=%s len=%d state=%x\n",
2741 rec->VolSessionId, rec->VolSessionTime,
2742 FI_to_ascii(rec->FileIndex), stream_to_ascii(rec->Stream, rec->FileIndex),
2743 rec->data_len, rec->state);
2745 if (rec->FileIndex < 0) {
2747 dump_label_record(dev, rec, 1);
2749 switch (rec->FileIndex) {
2751 Pmsg0(-1, "Volume is prelabeled. This tape cannot be scanned.\n");
2754 unser_volume_label(dev, rec);
2755 Pmsg3(-1, "VOL_LABEL: block=%u size=%d vol=%s\n", block->BlockNumber,
2756 block->block_len, dev->VolHdr.VolName);
2760 unser_session_label(&label, rec);
2761 Pmsg1(-1, "SOS_LABEL: JobId=%u\n", label.JobId);
2764 unser_session_label(&label, rec);
2765 Pmsg2(-1, "EOS_LABEL: block=%u JobId=%u\n", block->BlockNumber,
2769 Pmsg0(-1, "EOM_LABEL:\n");
2771 case EOT_LABEL: /* end of all tapes */
2774 if (LastBlock != block->BlockNumber) {
2775 VolBytes += block->block_len;
2777 LastBlock = block->BlockNumber;
2779 now -= jcr->run_time;
2783 kbs = (double)VolBytes / (1000 * now);
2784 Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2785 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2787 Pmsg0(000, "End of all tapes.\n");
2795 if (++file_index != rec->FileIndex) {
2796 Pmsg3(000, "Incorrect FileIndex in Block %u. Got %d, expected %d.\n",
2797 block->BlockNumber, rec->FileIndex, file_index);
2799 if (LastBlock != block->BlockNumber) {
2800 VolBytes += block->block_len;
2802 if ((block->BlockNumber != LastBlock) && (block->BlockNumber % 50000) == 0) {
2805 now -= jcr->run_time;
2809 kbs = (double)VolBytes / (1000 * now);
2810 Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2811 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2813 LastBlock = block->BlockNumber;
2815 Pmsg1(000, "End of all blocks. Block=%u\n", block->BlockNumber);