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-2005 Kern Sibbald
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 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
42 /* External subroutines */
43 extern void free_config_resources();
45 /* Exported variables */
48 int bsize = TAPE_BSIZE;
49 char VolName[MAX_NAME_LENGTH];
50 STORES *me = NULL; /* our Global resource */
51 bool forge_on = false; /* proceed inspite of I/O errors */
52 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
53 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
56 * If you change the format of the state file,
57 * increment this value
59 static uint32_t btape_state_level = 2;
63 DEVRES *device = NULL;
66 /* Forward referenced subroutines */
67 static void do_tape_cmds();
68 static void helpcmd();
69 static void scancmd();
70 static void rewindcmd();
71 static void clearcmd();
75 static void fillcmd();
76 static void qfillcmd();
77 static void statcmd();
78 static void unfillcmd();
79 static int flush_block(DEV_BLOCK *block, int dump);
80 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
81 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
82 static bool my_mount_next_read_volume(DCR *dcr);
83 static void scan_blocks();
84 static void set_volume_name(const char *VolName, int volnum);
85 static void rawfill_cmd();
86 static void bfill_cmd();
87 static bool open_the_device();
88 static void autochangercmd();
89 static void do_unfill();
92 /* Static variables */
93 #define CONFIG_FILE "bacula-sd.conf"
96 #define MAX_CMD_ARGS 30
99 static char *argk[MAX_CMD_ARGS];
100 static char *argv[MAX_CMD_ARGS];
103 static int quickie_count = 0;
104 static BSR *bsr = NULL;
105 static int signals = TRUE;
108 static uint64_t vol_size;
109 static uint64_t VolBytes;
112 static int32_t file_index;
113 static int end_of_tape = 0;
114 static uint32_t LastBlock = 0;
115 static uint32_t eot_block;
116 static uint32_t eot_block_len;
117 static uint32_t eot_FileIndex;
118 static int dumped = 0;
119 static DEV_BLOCK *last_block1 = NULL;
120 static DEV_BLOCK *last_block2 = NULL;
121 static DEV_BLOCK *last_block = NULL;
122 static DEV_BLOCK *this_block = NULL;
123 static DEV_BLOCK *first_block = NULL;
124 static uint32_t last_file1 = 0;
125 static uint32_t last_file2 = 0;
126 static uint32_t last_file = 0;
127 static uint32_t last_block_num1 = 0;
128 static uint32_t last_block_num2 = 0;
129 static uint32_t last_block_num = 0;
130 static uint32_t BlockNumber = 0;
131 static bool simple = true;
133 static const char *VolumeName = NULL;
134 static int vol_num = 0;
136 static JCR *jcr = NULL;
140 static void terminate_btape(int sig);
141 int get_cmd(const char *prompt);
144 /*********************************************************************
146 * Main Bacula Pool Creation Program
149 int main(int margc, char *margv[])
157 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
158 Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
159 TAPE_BSIZE, B_DEV_BSIZE);
161 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
162 Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE);
164 if (sizeof(off_t) < 8) {
165 Pmsg1(-1, "\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n",
169 bsnprintf(buf, sizeof(buf), "%u", x32);
170 i = bsscanf(buf, "%u", &y32);
171 if (i != 1 || x32 != y32) {
172 Pmsg3(-1, "32 bit printf/scanf problem. i=%d x32=%u y32=%u\n", i, x32, y32);
178 bsnprintf(buf, sizeof(buf), "%" llu, x64);
179 i = bsscanf(buf, "%llu", &y64);
180 if (i != 1 || x64 != y64) {
181 Pmsg3(-1, "64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n", i, x64, y64);
185 printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
187 working_directory = "/tmp";
188 my_name_is(margc, margv, "btape");
189 init_msg(NULL, NULL);
191 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
193 case 'b': /* bootstrap file */
194 bsr = parse_bsr(NULL, optarg);
195 // dump_bsr(bsr, true);
198 case 'c': /* specify config file */
199 if (configfile != NULL) {
202 configfile = bstrdup(optarg);
205 case 'd': /* set debug level */
206 debug_level = atoi(optarg);
207 if (debug_level <= 0) {
234 cmd = get_pool_memory(PM_FNAME);
235 args = get_pool_memory(PM_FNAME);
238 init_signals(terminate_btape);
241 if (configfile == NULL) {
242 configfile = bstrdup(CONFIG_FILE);
245 daemon_start_time = time(NULL);
247 parse_config(configfile);
250 /* See if we can open a device */
252 Pmsg0(000, "No archive name specified.\n");
255 } else if (margc != 1) {
256 Pmsg0(000, "Improper number of arguments specified.\n");
261 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
270 if (!open_the_device()) {
274 Dmsg0(200, "Do tape commands\n");
282 static void terminate_btape(int stat)
285 sm_check(__FILE__, __LINE__, false);
289 free_config_resources();
291 free_pool_memory(args);
295 free_pool_memory(cmd);
310 if (debug_level > 10)
311 print_memory_pool_stats();
314 free_block(this_block);
319 close_memory_pool(); /* free memory in pool */
325 static bool open_the_device()
329 block = new_block(dev);
331 if (!dev->is_open()) {
332 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
333 if (open_dev(dev, dcr->VolumeName, OPEN_READ_WRITE) < 0) {
334 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
340 Pmsg1(000, "open_dev %s OK\n", dev->print_name());
341 dev->set_append(); /* put volume in append mode */
354 * Write a label to the tape
356 static void labelcmd()
359 pm_strcpy(cmd, VolumeName);
361 if (!get_cmd("Enter Volume Name: ")) {
366 if (!dev->is_open()) {
367 if (!first_open_device(dev)) {
368 Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
372 write_new_volume_label_to_dev(dcr, cmd, "Default");
373 Pmsg1(-1, "Wrote Volume label for volume \"%s\".\n", cmd);
377 * Read the tape label
379 static void readlabelcmd()
381 int save_debug_level = debug_level;
384 stat = read_dev_volume_label(dcr);
387 Pmsg0(0, "Volume has no label.\n");
390 Pmsg0(0, "Volume label read correctly.\n");
393 Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev));
396 Pmsg0(0, "Volume name error\n");
398 case VOL_CREATE_ERROR:
399 Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
401 case VOL_VERSION_ERROR:
402 Pmsg0(0, "Volume version error.\n");
404 case VOL_LABEL_ERROR:
405 Pmsg0(0, "Bad Volume label type.\n");
408 Pmsg0(0, "Unknown error.\n");
413 dump_volume_label(dev);
414 debug_level = save_debug_level;
419 * Load the tape should have prevously been taken
420 * off line, otherwise this command is not necessary.
422 static void loadcmd()
425 if (!load_dev(dev)) {
426 Pmsg1(0, "Bad status from load. ERR=%s\n", strerror_dev(dev));
428 Pmsg1(0, "Loaded %s\n", dev->print_name());
434 static void rewindcmd()
436 if (!rewind_dev(dev)) {
437 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
438 clrerror_dev(dev, -1);
440 Pmsg1(0, "Rewound %s\n", dev->print_name());
445 * Clear any tape error
447 static void clearcmd()
449 clrerror_dev(dev, -1);
453 * Write and end of file on the tape
455 static void weofcmd()
466 if ((stat = weof_dev(dev, num)) < 0) {
467 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
470 Pmsg3(0, "Wrote %d EOF%s to %s\n", num, num==1?"":"s", dev->print_name());
475 /* Go to the end of the medium -- raw command
476 * The idea was orginally that the end of the Bacula
477 * medium would be flagged differently. This is not
478 * currently the case. So, this is identical to the
484 Pmsg1(0, "%s", strerror_dev(dev));
487 Pmsg0(0, _("Moved to end of medium.\n"));
492 * Go to the end of the medium (either hardware determined
493 * or defined by two eofs.
513 if (!bsf_dev(dev, num)) {
514 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
516 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
532 if (!bsr_dev(dev, num)) {
533 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
535 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
540 * List device capabilities as defined in the
545 printf(_("Configured device capabilities:\n"));
546 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
547 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
548 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
549 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
550 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
551 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
552 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
553 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
554 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
555 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
556 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
557 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
558 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
559 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
560 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
563 printf(_("Device status:\n"));
564 printf("%sOPENED ", dev->is_open() ? "" : "!");
565 printf("%sTAPE ", dev->is_tape() ? "" : "!");
566 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
567 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
568 printf("%sAPPEND ", dev->can_append() ? "" : "!");
569 printf("%sREAD ", dev->can_read() ? "" : "!");
570 printf("%sEOT ", dev->at_eot() ? "" : "!");
571 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
572 printf("%sEOF ", dev->at_eof() ? "" : "!");
573 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
574 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
577 printf(_("Device parameters:\n"));
578 printf("Device name: %s\n", dev->dev_name);
579 printf("File=%u block=%u\n", dev->file, dev->block_num);
580 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
588 * Test writting larger and larger records.
589 * This is a torture test for records.
591 static void rectestcmd()
597 Pmsg0(0, "Test writting larger and larger records.\n"
598 "This is a torture test for records.\nI am going to write\n"
599 "larger and larger records. It will stop when the record size\n"
600 "plus the header exceeds the block size (by default about 64K)\n");
603 get_cmd("Do you want to continue? (y/n): ");
605 Pmsg0(000, "Command aborted.\n");
609 sm_check(__FILE__, __LINE__, false);
610 block = new_block(dev);
613 for (i=1; i<500000; i++) {
614 rec->data = check_pool_memory_size(rec->data, i);
615 memset(rec->data, i & 0xFF, i);
617 sm_check(__FILE__, __LINE__, false);
618 if (write_record_to_block(block, rec)) {
621 Pmsg2(0, "Block %d i=%d\n", blkno, i);
625 sm_check(__FILE__, __LINE__, false);
629 sm_check(__FILE__, __LINE__, false);
633 * This test attempts to re-read a block written by Bacula
634 * normally at the end of the tape. Bacula will then back up
635 * over the two eof marks, backup over the record and reread
636 * it to make sure it is valid. Bacula can skip this validation
637 * if you set "Backward space record = no"
639 static int re_read_block_test()
641 DEV_BLOCK *block = dcr->block;
646 if (!(dev->capabilities & CAP_BSR)) {
647 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
651 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
652 "I'm going to write three records and an EOF\n"
653 "then backup over the EOF and re-read the last record.\n"
654 "Bacula does this after writing the last block on the\n"
655 "tape to verify that the block was written correctly.\n\n"
656 "This is not an *essential* feature ...\n\n"));
660 rec->data = check_pool_memory_size(rec->data, block->buf_len);
661 len = rec->data_len = block->buf_len-100;
662 memset(rec->data, 1, rec->data_len);
663 if (!write_record_to_block(block, rec)) {
664 Pmsg0(0, _("Error writing record to block.\n"));
667 if (!write_block_to_dev(dcr)) {
668 Pmsg0(0, _("Error writing block to device.\n"));
671 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
673 memset(rec->data, 2, rec->data_len);
674 if (!write_record_to_block(block, rec)) {
675 Pmsg0(0, _("Error writing record to block.\n"));
678 if (!write_block_to_dev(dcr)) {
679 Pmsg0(0, _("Error writing block to device.\n"));
682 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
684 memset(rec->data, 3, rec->data_len);
685 if (!write_record_to_block(block, rec)) {
686 Pmsg0(0, _("Error writing record to block.\n"));
689 if (!write_block_to_dev(dcr)) {
690 Pmsg0(0, _("Error writing block to device.\n"));
693 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
696 if (dev_cap(dev, CAP_TWOEOF)) {
699 if (!bsf_dev(dev, 1)) {
700 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
703 if (dev_cap(dev, CAP_TWOEOF)) {
704 if (!bsf_dev(dev, 1)) {
705 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
709 Pmsg0(0, "Backspaced over EOF OK.\n");
710 if (!bsr_dev(dev, 1)) {
711 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
714 Pmsg0(0, "Backspace record OK.\n");
715 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
717 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
720 memset(rec->data, 0, rec->data_len);
721 if (!read_record_from_block(block, rec)) {
723 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
726 for (int i=0; i<len; i++) {
727 if (rec->data[i] != 3) {
728 Pmsg0(0, _("Bad data in record. Test failed!\n"));
732 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
733 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
740 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
741 "this function to verify the last block written to the\n"
742 "tape. Bacula will skip the last block verification\n"
744 "Backward Space Record = No\n\n"
745 "to your Storage daemon's Device resource definition.\n"));
752 * This test writes Bacula blocks to the tape in
753 * several files. It then rewinds the tape and attepts
754 * to read these blocks back checking the data.
756 static int write_read_test()
764 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
765 "I'm going to write 1000 records and an EOF\n"
766 "then write 1000 records and an EOF, then rewind,\n"
767 "and re-read the data to verify that it is correct.\n\n"
768 "This is an *essential* feature ...\n\n"));
771 if (!rewind_dev(dev)) {
772 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
775 rec->data = check_pool_memory_size(rec->data, block->buf_len);
776 rec->data_len = block->buf_len-100;
777 len = rec->data_len/sizeof(i);
778 for (i=1; i<=1000; i++) {
779 p = (int *)rec->data;
780 for (j=0; j<len; j++) {
783 if (!write_record_to_block(block, rec)) {
784 Pmsg0(0, _("Error writing record to block.\n"));
787 if (!write_block_to_dev(dcr)) {
788 Pmsg0(0, _("Error writing block to device.\n"));
792 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
794 for (i=1001; i<=2000; i++) {
795 p = (int *)rec->data;
796 for (j=0; j<len; j++) {
799 if (!write_record_to_block(block, rec)) {
800 Pmsg0(0, _("Error writing record to block.\n"));
803 if (!write_block_to_dev(dcr)) {
804 Pmsg0(0, _("Error writing block to device.\n"));
808 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
810 if (dev_cap(dev, CAP_TWOEOF)) {
813 if (!rewind_dev(dev)) {
814 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
817 Pmsg0(0, "Rewind OK.\n");
819 for (i=1; i<=2000; i++) {
821 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
823 if (dev_state(dev, ST_EOF)) {
824 Pmsg0(-1, _("Got EOF on tape.\n"));
829 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
832 memset(rec->data, 0, rec->data_len);
833 if (!read_record_from_block(block, rec)) {
835 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
838 p = (int *)rec->data;
839 for (j=0; j<len; j++) {
841 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
847 if (i == 1000 || i == 2000) {
848 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
851 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
860 * This test writes Bacula blocks to the tape in
861 * several files. It then rewinds the tape and attepts
862 * to read these blocks back checking the data.
864 static int position_test()
866 DEV_BLOCK *block = dcr->block;
872 int file = 0, blk = 0;
874 bool got_eof = false;
876 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
877 "I'm going to write 1000 records and an EOF\n"
878 "then write 1000 records and an EOF, then rewind,\n"
879 "and position to a few blocks and verify that it is correct.\n\n"
880 "This is an *essential* feature ...\n\n"));
883 if (!rewind_dev(dev)) {
884 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
887 rec->data = check_pool_memory_size(rec->data, block->buf_len);
888 rec->data_len = block->buf_len-100;
889 len = rec->data_len/sizeof(i);
890 for (i=1; i<=1000; i++) {
891 p = (int *)rec->data;
892 for (j=0; j<len; j++) {
895 if (!write_record_to_block(block, rec)) {
896 Pmsg0(0, _("Error writing record to block.\n"));
899 if (!write_block_to_dev(dcr)) {
900 Pmsg0(0, _("Error writing block to device.\n"));
904 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
906 for (i=1001; i<=2000; i++) {
907 p = (int *)rec->data;
908 for (j=0; j<len; j++) {
911 if (!write_record_to_block(block, rec)) {
912 Pmsg0(0, _("Error writing record to block.\n"));
915 if (!write_block_to_dev(dcr)) {
916 Pmsg0(0, _("Error writing block to device.\n"));
920 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
922 if (dev_cap(dev, CAP_TWOEOF)) {
925 if (!rewind_dev(dev)) {
926 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
929 Pmsg0(0, "Rewind OK.\n");
933 /* Set up next item to read based on where we are */
969 Pmsg2(-1, "Reposition to file:block %d:%d\n", file, blk);
970 if (!reposition_dev(dev, file, blk)) {
971 Pmsg0(0, "Reposition error.\n");
975 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
977 if (dev_state(dev, ST_EOF)) {
978 Pmsg0(-1, _("Got EOF on tape.\n"));
984 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
985 recno, file, blk, be.strerror(dev->dev_errno));
986 Pmsg0(0, _("This may be because the tape drive block size is not\n"
987 " set to variable blocking as normally used by Bacula.\n"
988 " Please see the Tape Testing chapter in the manual and \n"
989 " look for using mt with defblksize and setoptions\n"
990 "If your tape drive block size is correct, then perhaps\n"
991 " your SCSI driver is *really* stupid and does not\n"
992 " correctly report the file:block after a FSF. In this\n"
993 " case try setting:\n"
994 " Fast Forward Space File = no\n"
995 " in your Device resource.\n"));
999 memset(rec->data, 0, rec->data_len);
1000 if (!read_record_from_block(block, rec)) {
1002 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1005 p = (int *)rec->data;
1006 for (j=0; j<len; j++) {
1007 if (p[j] != recno) {
1008 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1013 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1015 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1027 * This test writes some records, then writes an end of file,
1028 * rewinds the tape, moves to the end of the data and attepts
1029 * to append to the tape. This function is essential for
1030 * Bacula to be able to write multiple jobs to the tape.
1032 static int append_test()
1034 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1035 "This test is essential to Bacula.\n\n"
1036 "I'm going to write one record in file 0,\n"
1037 " two records in file 1,\n"
1038 " and three records in file 2\n\n"));
1042 weofcmd(); /* end file 0 */
1045 weofcmd(); /* end file 1 */
1049 weofcmd(); /* end file 2 */
1050 if (dev_cap(dev, CAP_TWOEOF)) {
1053 force_close_dev(dev); /* release device */
1054 if (!open_the_device()) {
1058 Pmsg0(0, _("Now moving to end of medium.\n"));
1060 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1061 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1063 if (dev->file != 3) {
1067 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1070 if (dev_cap(dev, CAP_TWOEOF)) {
1074 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1075 Pmsg0(-1, "Doing Bacula scan of blocks:\n");
1077 Pmsg0(-1, _("End scanning the tape.\n"));
1078 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1079 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1081 if (dev->file != 4) {
1089 * This test exercises the autochanger
1091 static int autochanger_test()
1093 POOLMEM *results, *changer;
1094 int slot, status, loaded;
1095 int timeout = dcr->device->max_changer_wait;
1098 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1099 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1102 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1103 Pmsg0(-1, "\nAutochanger enabled, but no name or no command device specified.\n");
1107 Pmsg0(-1, "\nAh, I see you have an autochanger configured.\n"
1108 "To test the autochanger you must have a blank tape\n"
1109 " that I can write on in Slot 1.\n");
1110 if (!get_cmd("\nDo you wish to continue with the Autochanger test? (y/n): ")) {
1113 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1117 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1119 results = get_pool_memory(PM_MESSAGE);
1120 changer = get_pool_memory(PM_FNAME);
1124 dcr->VolCatInfo.Slot = slot;
1125 /* Find out what is loaded, zero means device is unloaded */
1126 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1127 changer = edit_device_codes(dcr, changer,
1128 dcr->device->changer_command, "loaded");
1129 status = run_program(changer, timeout, results);
1130 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1132 loaded = atoi(results);
1135 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1136 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1140 Pmsg1(-1, "Slot %d loaded. I am going to unload it.\n", loaded);
1142 Pmsg0(-1, "Nothing loaded in the drive. OK.\n");
1144 Dmsg1(100, "Results from loaded query=%s\n", results);
1146 dcr->VolCatInfo.Slot = loaded;
1147 offline_or_rewind_dev(dev);
1148 /* We are going to load a new tape, so close the device */
1149 force_close_dev(dev);
1150 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1151 loaded, dev->drive_index);
1152 changer = edit_device_codes(dcr, changer,
1153 dcr->device->changer_command, "unload");
1154 status = run_program(changer, timeout, results);
1155 Pmsg2(-1, "unload status=%s %d\n", status==0?"OK":"Bad", status);
1158 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1159 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1168 dcr->VolCatInfo.Slot = slot;
1169 Pmsg2(-1, _("3303 Issuing autochanger \"load slot %d %d\" command.\n"),
1170 slot, dev->drive_index);
1171 changer = edit_device_codes(dcr, changer,
1172 dcr->device->changer_command, "load");
1173 Dmsg1(100, "Changer=%s\n", changer);
1174 force_close_dev(dev);
1175 status = run_program(changer, timeout, results);
1177 Pmsg2(-1, _("3303 Autochanger \"load slot %d %d\" status is OK.\n"),
1178 slot, dev->drive_index);
1181 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1182 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1186 if (!open_the_device()) {
1190 * Start with sleep_time 0 then increment by 30 seconds if we get
1193 bmicrosleep(sleep_time, 0);
1194 if (!rewind_dev(dev) || weof_dev(dev,1) < 0) {
1195 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
1196 clrerror_dev(dev, -1);
1197 Pmsg0(-1, "\nThe test failed, probably because you need to put\n"
1198 "a longer sleep time in the mtx-script in the load) case.\n"
1199 "Adding a 30 second sleep and trying again ...\n");
1203 Pmsg1(0, "Rewound %s\n", dev->print_name());
1206 if ((status = weof_dev(dev, 1)) < 0) {
1207 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", status, strerror_dev(dev));
1210 Pmsg1(0, "Wrote EOF to %s\n", dev->print_name());
1214 Pmsg1(-1, "\nThe test worked this time. Please add:\n\n"
1216 "to your mtx-changer script in the load) case.\n\n",
1219 Pmsg0(-1, "\nThe test autochanger worked!!\n\n");
1222 free_pool_memory(changer);
1223 free_pool_memory(results);
1228 free_pool_memory(changer);
1229 free_pool_memory(results);
1230 Pmsg0(-1, "You must correct this error or the Autochanger will not work.\n");
1234 static void autochangercmd()
1241 * This test assumes that the append test has been done,
1242 * then it tests the fsf function.
1244 static int fsf_test()
1246 bool set_off = false;
1248 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1249 "This test is essential to Bacula.\n\n"
1250 "I'm going to write five files then test forward spacing\n\n"));
1254 weofcmd(); /* end file 0 */
1257 weofcmd(); /* end file 1 */
1261 weofcmd(); /* end file 2 */
1264 weofcmd(); /* end file 3 */
1266 weofcmd(); /* end file 4 */
1267 if (dev_cap(dev, CAP_TWOEOF)) {
1273 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1274 if (!fsf_dev(dev, 1)) {
1275 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1278 Pmsg2(-1, _("We should be in file 1. I am at file %d. This is %s\n"),
1279 dev->file, dev->file == 1 ? "correct!" : "NOT correct!!!!");
1281 if (dev->file != 1) {
1285 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1286 if (!fsf_dev(dev, 2)) {
1287 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1290 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1291 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1293 if (dev->file != 3) {
1298 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1299 if (!fsf_dev(dev, 4)) {
1300 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1303 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1304 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1306 if (dev->file != 4) {
1310 Pmsg0(-1, "The test worked this time. Please add:\n\n"
1311 " Fast Forward Space File = no\n\n"
1312 "to your Device resource for this drive.\n");
1316 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1317 if (!fsf_dev(dev, 1)) {
1318 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1320 Pmsg2(-1, _("We should be in file 5. I am at file %d. This is %s\n"),
1321 dev->file, dev->file == 5 ? "correct!" : "NOT correct!!!!");
1322 if (dev->file != 5) {
1325 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1329 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1330 if (dev_cap(dev, CAP_FASTFSF)) {
1331 Pmsg0(-1, "You have Fast Forward Space File enabled.\n"
1332 "I am turning it off then retrying the test.\n");
1333 dev->capabilities &= ~CAP_FASTFSF;
1337 Pmsg0(-1, "You must correct this error or Bacula will not work.\n"
1338 "Some systems, e.g. OpenBSD, require you to set\n"
1339 " Use MTIOCGET= no\n"
1340 "in your device resource. Use with caution.\n");
1349 * This is a general test of Bacula's functions
1350 * needed to read and write the tape.
1352 static void testcmd()
1356 if (!write_read_test()) {
1359 if (!position_test()) {
1363 stat = append_test();
1364 if (stat == 1) { /* OK get out */
1367 if (stat == -1) { /* first test failed */
1368 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1369 Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
1370 "Setting \"Hardware End of Medium = no\n"
1371 " and \"Fast Forward Space File = no\n"
1372 "and retrying append test.\n\n");
1373 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1374 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1375 stat = append_test();
1377 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1378 " Hardware End of Medium = No\n\n"
1379 " Fast Forward Space File = No\n"
1380 "to your Device resource in the Storage conf file.\n");
1384 Pmsg0(-1, "\n\nThat appears *NOT* to have corrected the problem.\n");
1387 /* Wrong count after append */
1389 Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
1390 "Setting \"BSF at EOM = yes\" and retrying append test.\n");
1391 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1392 stat = append_test();
1394 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1395 " Hardware End of Medium = No\n"
1396 " Fast Forward Space File = No\n"
1397 " BSF at EOM = yes\n\n"
1398 "to your Device resource in the Storage conf file.\n");
1405 Pmsg0(-1, "\nAppend test failed.\n\n");
1406 Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1407 "Unable to correct the problem. You MUST fix this\n"
1408 "problem before Bacula can use your tape drive correctly\n");
1409 Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
1410 "Do so by setting:\n\n"
1411 "Minimum Block Size = nnn\n"
1412 "Maximum Block Size = nnn\n\n"
1413 "in your Storage daemon's Device definition.\n"
1414 "nnn must match your tape driver's block size, which\n"
1415 "can be determined by reading your tape manufacturers\n"
1416 "information, and the information on your kernel dirver.\n"
1417 "Fixed block sizes, however, are not normally an ideal solution.\n"
1419 "Some systems, e.g. OpenBSD, require you to set\n"
1420 " Use MTIOCGET= no\n"
1421 "in your device resource. Use with caution.\n");
1426 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1427 "Please double check it ...\n"
1428 "=== Sample correct output ===\n"
1429 "1 block of 64448 bytes in file 1\n"
1430 "End of File mark.\n"
1431 "2 blocks of 64448 bytes in file 2\n"
1432 "End of File mark.\n"
1433 "3 blocks of 64448 bytes in file 3\n"
1434 "End of File mark.\n"
1435 "1 block of 64448 bytes in file 4\n"
1436 "End of File mark.\n"
1437 "Total files=4, blocks=7, bytes = 451,136\n"
1438 "=== End sample correct output ===\n\n"));
1440 Pmsg0(-1, _("If the above scan output is not identical to the\n"
1441 "sample output, you MUST correct the problem\n"
1442 "or Bacula will not be able to write multiple Jobs to \n"
1446 re_read_block_test();
1449 fsf_test(); /* do fast forward space file test */
1451 autochanger_test(); /* do autochanger test */
1455 /* Forward space a file */
1456 static void fsfcmd()
1460 num = atoi(argk[1]);
1465 if (!fsf_dev(dev, num)) {
1466 Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
1469 Pmsg2(0, "Forward spaced %d file%s.\n", num, num==1?"":"s");
1472 /* Forward space a record */
1473 static void fsrcmd()
1477 num = atoi(argk[1]);
1482 if (!dev->fsr(num)) {
1483 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1486 Pmsg2(0, "Forward spaced %d record%s.\n", num, num==1?"":"s");
1491 * Write a Bacula block to the tape
1495 DEV_BLOCK *block = dcr->block;
1496 DEV_RECORD *rec = dcr->rec;
1499 sm_check(__FILE__, __LINE__, false);
1502 dump_block(block, "test");
1505 i = block->buf_len - 100;
1507 rec->data = check_pool_memory_size(rec->data, i);
1508 memset(rec->data, i & 0xFF, i);
1510 sm_check(__FILE__, __LINE__, false);
1511 if (!write_record_to_block(block, rec)) {
1512 Pmsg0(0, _("Error writing record to block.\n"));
1515 if (!write_block_to_dev(dcr)) {
1516 Pmsg0(0, _("Error writing block to device.\n"));
1519 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1521 Pmsg0(0, _("Wrote block to device.\n"));
1524 sm_check(__FILE__, __LINE__, false);
1525 sm_check(__FILE__, __LINE__, false);
1529 * Read a record from the tape
1536 if (!get_cmd("Enter length to read: ")) {
1540 if (len < 0 || len > 1000000) {
1541 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1544 buf = (char *)malloc(len);
1545 stat = read(dev->fd, buf, len);
1546 if (stat > 0 && stat <= len) {
1550 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1551 len, stat, be.strerror());
1557 * Scan tape by reading block by block. Report what is
1558 * on the tape. Note, this command does raw reads, and as such
1559 * will not work with fixed block size devices.
1561 static void scancmd()
1564 int blocks, tot_blocks, tot_files;
1570 blocks = block_size = tot_blocks = 0;
1572 if (dev->state & ST_EOT) {
1573 Pmsg0(0, "End of tape\n");
1576 update_pos_dev(dev);
1577 tot_files = dev->file;
1578 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1580 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1582 clrerror_dev(dev, -1);
1583 Mmsg2(dev->errmsg, "read error on %s. ERR=%s.\n",
1584 dev->dev_name, be.strerror());
1585 Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
1587 printf("%d block%s of %d bytes in file %d\n",
1588 blocks, blocks>1?"s":"", block_size, dev->file);
1591 Dmsg1(200, "read status = %d\n", stat);
1593 if (stat != block_size) {
1594 update_pos_dev(dev);
1596 printf("%d block%s of %d bytes in file %d\n",
1597 blocks, blocks>1?"s":"", block_size, dev->file);
1602 if (stat == 0) { /* EOF */
1603 update_pos_dev(dev);
1604 printf("End of File mark.\n");
1605 /* Two reads of zero means end of tape */
1606 if (dev->state & ST_EOF)
1607 dev->state |= ST_EOT;
1609 dev->state |= ST_EOF;
1612 if (dev->state & ST_EOT) {
1613 printf("End of tape\n");
1616 } else { /* Got data */
1617 dev->state &= ~ST_EOF;
1623 update_pos_dev(dev);
1624 tot_files = dev->file - tot_files;
1625 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1626 edit_uint64_with_commas(bytes, ec1));
1631 * Scan tape by reading Bacula block by block. Report what is
1632 * on the tape. This function reads Bacula blocks, so if your
1633 * Device resource is correctly defined, it should work with
1634 * either variable or fixed block sizes.
1636 static void scan_blocks()
1638 int blocks, tot_blocks, tot_files;
1639 uint32_t block_size;
1641 DEV_BLOCK *block = dcr->block;
1644 blocks = block_size = tot_blocks = 0;
1648 update_pos_dev(dev);
1649 tot_files = dev->file;
1651 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1652 Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
1653 if (dev->state & ST_EOT) {
1655 printf("%d block%s of %d bytes in file %d\n",
1656 blocks, blocks>1?"s":"", block_size, dev->file);
1661 if (dev->state & ST_EOF) {
1663 printf("%d block%s of %d bytes in file %d\n",
1664 blocks, blocks>1?"s":"", block_size, dev->file);
1667 printf(_("End of File mark.\n"));
1670 if (dev->state & ST_SHORT) {
1672 printf("%d block%s of %d bytes in file %d\n",
1673 blocks, blocks>1?"s":"", block_size, dev->file);
1676 printf(_("Short block read.\n"));
1679 printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1682 if (block->block_len != block_size) {
1684 printf("%d block%s of %d bytes in file %d\n",
1685 blocks, blocks>1?"s":"", block_size, dev->file);
1688 block_size = block->block_len;
1692 bytes += block->block_len;
1693 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1694 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1695 block->VolSessionId, block->VolSessionTime);
1697 DEV_RECORD *rec = new_record();
1698 read_record_from_block(block, rec);
1699 Pmsg8(-1, "Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
1700 block->BlockNumber, dev->block_num, block->block_len,
1701 FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1702 stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
1705 } else if (verbose > 1) {
1706 dump_block(block, "");
1711 tot_files = dev->file - tot_files;
1712 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1713 edit_uint64_with_commas(bytes, ec1));
1717 static void statcmd()
1719 int debug = debug_level;
1721 Pmsg2(0, "Device status: %u. ERR=%s\n", status_dev(dev), strerror_dev(dev));
1723 dump_volume_label(dev);
1725 debug_level = debug;
1730 * First we label the tape, then we fill
1731 * it with data get a new tape and write a few blocks.
1733 static void fillcmd()
1736 DEV_BLOCK *block = dcr->block;
1740 uint32_t min_block_size;
1750 "This command simulates Bacula writing to a tape.\n"
1751 "It requires either one or two blank tapes, which it\n"
1752 "will label and write.\n\n"
1753 "If you have an autochanger configured, it will use\n"
1754 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1755 "be prompted to insert the tapes when necessary.\n\n"
1756 "It will print a status approximately\n"
1757 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1758 "selected the simple test option, after writing the first tape\n"
1759 "it will rewind it and re-read the last block written.\n\n"
1760 "If you have selected the multiple tape test, when the first tape\n"
1761 "fills, it will ask for a second, and after writing a few more \n"
1762 "blocks, it will stop. Then it will begin re-reading the\n"
1764 "This may take a long time -- hours! ...\n\n");
1766 get_cmd("Do you want to run the simplified test (s) with one tape\n"
1767 "or the complete multiple tape (m) test: (s/m) ");
1768 if (cmd[0] == 's') {
1769 Pmsg0(-1, "Simple test (single tape) selected.\n");
1771 } else if (cmd[0] == 'm') {
1772 Pmsg0(-1, "Multiple tape test selected.\n");
1775 Pmsg0(000, "Command aborted.\n");
1779 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1780 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1782 /* Use fixed block size to simplify read back */
1783 min_block_size = dev->min_block_size;
1784 dev->min_block_size = dev->max_block_size;
1785 set_volume_name("TestVolume1", 1);
1787 if (!dev->rewind()) {
1788 Pmsg0(000, "Rewind failed.\n");
1791 Pmsg0(000, "Write EOF failed.\n");
1794 dev->set_append(); /* force volume to be relabeled */
1797 * Acquire output device for writing. Note, after acquiring a
1798 * device, we MUST release it, which is done at the end of this
1801 Dmsg0(100, "just before acquire_device\n");
1802 if (!acquire_device_for_append(dcr)) {
1803 set_jcr_job_status(jcr, JS_ErrorTerminated);
1806 block = jcr->dcr->block;
1808 Dmsg0(100, "Just after acquire_device_for_append\n");
1810 * Write Begin Session Record
1812 if (!write_session_label(dcr, SOS_LABEL)) {
1813 set_jcr_job_status(jcr, JS_ErrorTerminated);
1814 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1818 Pmsg0(-1, "Wrote Start of Session label.\n");
1820 memset(&rec, 0, sizeof(rec));
1821 rec.data = get_memory(100000); /* max record size */
1823 #define REC_SIZE 32768
1824 rec.data_len = REC_SIZE;
1827 * Put some random data in the record
1829 fd = open("/dev/urandom", O_RDONLY);
1831 read(fd, rec.data, rec.data_len);
1834 uint32_t *p = (uint32_t *)rec.data;
1835 srandom(time(NULL));
1836 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1842 * Generate data as if from File daemon, write to device
1844 jcr->dcr->VolFirstIndex = 0;
1845 time(&jcr->run_time); /* start counting time for rates */
1847 Pmsg0(-1, "Begin writing Bacula records to tape ...\n");
1849 Pmsg0(-1, "Begin writing Bacula records to first tape ...\n");
1851 for (file_index = 0; ok && !job_canceled(jcr); ) {
1852 rec.VolSessionId = jcr->VolSessionId;
1853 rec.VolSessionTime = jcr->VolSessionTime;
1854 rec.FileIndex = ++file_index;
1855 rec.Stream = STREAM_FILE_DATA;
1857 /* Mix up the data just a bit */
1858 uint32_t *lp = (uint32_t *)rec.data;
1860 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1864 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1865 rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1868 while (!write_record_to_block(block, &rec)) {
1870 * When we get here we have just filled a block
1872 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1875 /* Write block to tape */
1876 if (!flush_block(block, 1)) {
1880 /* Every 5000 blocks (approx 322MB) report where we are.
1882 if ((block->BlockNumber % 5000) == 0) {
1884 now -= jcr->run_time;
1886 now = 1; /* prevent divide error */
1888 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1889 Pmsg4(-1, "Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n",
1890 block->BlockNumber, dev->block_num,
1891 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1893 /* Every 15000 blocks (approx 1GB) write an EOF.
1895 if ((block->BlockNumber % 15000) == 0) {
1896 Pmsg0(-1, "Flush block, write EOF\n");
1897 flush_block(block, 0);
1901 /* Get out after writing 10 blocks to the second tape */
1902 if (++BlockNumber > 10 && stop != 0) { /* get out */
1907 Pmsg0(000, _("Not OK\n"));
1910 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1911 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1912 FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1913 stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1915 /* Get out after writing 10 blocks to the second tape */
1916 if (BlockNumber > 10 && stop != 0) { /* get out */
1917 Pmsg0(-1, "Done writing ...\n");
1922 Dmsg0(100, "Write_end_session_label()\n");
1923 /* Create Job status for end of session label */
1924 if (!job_canceled(jcr) && ok) {
1925 set_jcr_job_status(jcr, JS_Terminated);
1927 set_jcr_job_status(jcr, JS_ErrorTerminated);
1929 if (!write_session_label(dcr, EOS_LABEL)) {
1930 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1933 /* Write out final block of this session */
1934 if (!write_block_to_device(dcr)) {
1935 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1938 Pmsg0(-1, _("Wrote End of Session label.\n"));
1940 /* Save last block info for second tape */
1941 last_block_num2 = last_block_num;
1942 last_file2 = last_file;
1944 free_block(last_block2);
1946 last_block2 = dup_block(last_block);
1949 sprintf(buf, "%s/btape.state", working_directory);
1950 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1952 write(fd, &btape_state_level, sizeof(btape_state_level));
1953 write(fd, &simple, sizeof(simple));
1954 write(fd, &last_block_num1, sizeof(last_block_num1));
1955 write(fd, &last_block_num2, sizeof(last_block_num2));
1956 write(fd, &last_file1, sizeof(last_file1));
1957 write(fd, &last_file2, sizeof(last_file2));
1958 write(fd, last_block1->buf, last_block1->buf_len);
1959 write(fd, last_block2->buf, last_block2->buf_len);
1960 write(fd, first_block->buf, first_block->buf_len);
1962 Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
1963 last_block_num1, last_block_num2);
1966 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
1970 Pmsg4(-1, _("\n\nDone filling tape%s at %d:%d. Now beginning re-read of %stape ...\n"),
1971 simple?"":"s", jcr->dcr->dev->file, jcr->dcr->dev->block_num, simple?"":"first ");
1973 jcr->dcr->block = block;
1976 dev->min_block_size = min_block_size;
1977 free_memory(rec.data);
1981 * Read two tapes written by the "fill" command and ensure
1982 * that the data is valid. If stop==1 we simulate full read back
1983 * of two tapes. If stop==-1 we simply read the last block and
1984 * verify that it is correct.
1986 static void unfillcmd()
1990 last_block1 = new_block(dev);
1991 last_block2 = new_block(dev);
1992 first_block = new_block(dev);
1993 sprintf(buf, "%s/btape.state", working_directory);
1994 fd = open(buf, O_RDONLY);
1996 uint32_t state_level;
1997 read(fd, &state_level, sizeof(btape_state_level));
1998 read(fd, &simple, sizeof(simple));
1999 read(fd, &last_block_num1, sizeof(last_block_num1));
2000 read(fd, &last_block_num2, sizeof(last_block_num2));
2001 read(fd, &last_file1, sizeof(last_file1));
2002 read(fd, &last_file2, sizeof(last_file2));
2003 read(fd, last_block1->buf, last_block1->buf_len);
2004 read(fd, last_block2->buf, last_block2->buf_len);
2005 read(fd, first_block->buf, first_block->buf_len);
2007 if (state_level != btape_state_level) {
2008 Pmsg0(-1, "\nThe state file level has changed. You must redo\n"
2009 "the fill command.\n");
2014 Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
2015 "You must redo the fill command.\n", buf, be.strerror());
2022 static void do_unfill()
2024 DEV_BLOCK *block = dcr->block;
2031 Dmsg0(20, "Enter do_unfill\n");
2032 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2033 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2037 time(&jcr->run_time); /* start counting time for rates */
2041 free_block(last_block);
2043 last_block_num = last_block_num1;
2044 last_file = last_file1;
2045 last_block = last_block1;
2048 /* Multiple Volume tape */
2049 /* Close device so user can use autochanger if desired */
2050 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2053 autochanger = autoload_device(dcr, 1, NULL);
2055 force_close_dev(dev);
2056 get_cmd(_("Mount first tape. Press enter when ready: "));
2059 jcr->dcr = new_dcr(jcr, dev);
2060 set_volume_name("TestVolume1", 1);
2062 create_vol_list(jcr);
2064 dev->state &= ~(ST_READ|ST_APPEND);
2065 dev->num_writers = 0;
2066 if (!acquire_device_for_read(dcr)) {
2067 Pmsg1(-1, "%s", dev->errmsg);
2072 * We now have the first tape mounted.
2073 * Note, re-reading last block may have caused us to
2074 * loose track of where we are (block number unknown).
2076 if (!rewind_dev(dev)) { /* get to a known place on tape */
2079 /* Read the first 10000 records */
2080 Pmsg0(-1, _("Reading the first 10000 records.\n"));
2082 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2083 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2084 last_file, last_block_num);
2085 if (!reposition_dev(dev, last_file, last_block_num)) {
2086 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2089 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2090 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2091 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2094 if (compare_blocks(last_block, block)) {
2096 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2098 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2105 /* restore info for last block on second Volume */
2106 last_block_num = last_block_num2;
2107 last_file = last_file2;
2108 last_block = last_block2;
2110 /* Multiple Volume tape */
2111 /* Close device so user can use autochanger if desired */
2112 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2117 set_volume_name("TestVolume2", 2);
2119 create_vol_list(jcr);
2120 autochanger = autoload_device(dcr, 1, NULL);
2122 force_close_dev(dev);
2123 get_cmd(_("Mount second tape. Press enter when ready: "));
2127 if (!acquire_device_for_read(dcr)) {
2128 Pmsg1(-1, "%s", dev->errmsg);
2132 /* Space to "first" block which is last block not written
2133 * on the previous tape.
2135 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2136 if (!reposition_dev(dev, 0, 1)) {
2137 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2140 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2141 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2142 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2145 if (compare_blocks(first_block, block)) {
2146 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2149 /* Now find and compare the last block */
2150 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2151 last_file, last_block_num);
2152 if (!reposition_dev(dev, last_file, last_block_num)) {
2153 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2156 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2157 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2158 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2161 if (compare_blocks(last_block, block)) {
2162 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2166 free_block(last_block1);
2167 free_block(last_block2);
2168 free_block(first_block);
2171 /* Read 10000 records then stop */
2172 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2174 DEVICE *dev = dcr->dev;
2175 if (dev->file != 0) {
2176 Pmsg3(-1, "ERROR! device at %d:%d count=%d\n", dev->file, dev->block_num,
2181 if (quickie_count == 10000) {
2182 Pmsg2(-1, "1000 records read now at %d:%d\n", dev->file, dev->block_num);
2184 return quickie_count < 10000;
2187 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2190 uint32_t CheckSum, block_len;
2193 p = last_block->buf;
2195 unser_begin(q, BLKHDR2_LENGTH);
2196 unser_uint32(CheckSum);
2197 unser_uint32(block_len);
2198 while (q < (block->buf+block_len)) {
2205 dump_block(last_block, _("Last block written"));
2207 dump_block(block, _("Block read back"));
2208 Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf);
2209 Pmsg0(-1, "\n\n!!!! The last block written and the block\n"
2210 "that was read back differ. The test FAILED !!!!\n"
2211 "This must be corrected before you use Bacula\n"
2212 "to write multi-tape Volumes.!!!!\n");
2216 dump_block(last_block, _("Last block written"));
2217 dump_block(block, _("Block read back"));
2227 * Write current block to tape regardless of whether or
2228 * not it is full. If the tape fills, attempt to
2229 * acquire another tape.
2231 static int flush_block(DEV_BLOCK *block, int dump)
2235 uint32_t this_file, this_block_num;
2239 this_block = new_block(dev);
2242 last_block = new_block(dev);
2245 this_file = dev->file;
2246 this_block_num = dev->block_num;
2247 if (!write_block_to_dev(dcr)) {
2248 Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n",
2249 last_file, last_block_num, this_block_num);
2252 * This is 1st tape, so save first tape info separate
2253 * from second tape info
2255 last_block_num1 = last_block_num;
2256 last_file1 = last_file;
2257 last_block1 = dup_block(last_block);
2258 last_block2 = dup_block(last_block);
2259 first_block = dup_block(block); /* first block second tape */
2262 Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n",
2263 (unsigned)file_index, block->BlockNumber, block->block_len);
2264 dump_block(last_block, "Last block written");
2266 dump_block(block, "Block not written");
2269 eot_block = block->BlockNumber;
2270 eot_block_len = block->block_len;
2271 eot_FileIndex = file_index;
2275 now -= jcr->run_time;
2277 now = 1; /* don't divide by zero */
2279 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2280 vol_size = dev->VolCatInfo.VolCatBytes;
2281 Pmsg4(000, "End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
2282 dev->file, dev->block_num,
2283 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2286 stop = -1; /* stop, but do simplified test */
2288 /* Full test in progress */
2289 if (!fixup_device_block_write_error(jcr->dcr)) {
2290 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2295 BlockNumber = 0; /* start counting for second tape */
2298 return 1; /* end of tape reached */
2301 /* Save contents after write so that the header is serialized */
2302 memcpy(this_block->buf, block->buf, this_block->buf_len);
2305 * Note, we always read/write to block, but we toggle
2306 * copying it to one or another of two allocated blocks.
2307 * Switch blocks so that the block just successfully written is
2308 * always in last_block.
2310 tblock = last_block;
2311 last_block = this_block;
2312 this_block = tblock;
2313 last_file = this_file;
2314 last_block_num = this_block_num;
2322 * First we label the tape, then we fill
2323 * it with data get a new tape and write a few blocks.
2325 static void qfillcmd()
2327 DEV_BLOCK *block = dcr->block;
2328 DEV_RECORD *rec = dcr->rec;
2331 Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
2333 get_cmd("How many blocks do you want to write? (1000): ");
2340 sm_check(__FILE__, __LINE__, false);
2342 i = block->buf_len - 100;
2344 rec->data = check_pool_memory_size(rec->data, i);
2345 memset(rec->data, i & 0xFF, i);
2348 Pmsg1(0, "Begin writing %d Bacula blocks to tape ...\n", count);
2349 for (i=0; i < count; i++) {
2354 if (!write_record_to_block(block, rec)) {
2355 Pmsg0(0, _("Error writing record to block.\n"));
2358 if (!write_block_to_dev(dcr)) {
2359 Pmsg0(0, _("Error writing block to device.\n"));
2365 if (dev_cap(dev, CAP_TWOEOF)) {
2372 sm_check(__FILE__, __LINE__, false);
2376 * Fill a tape using raw write() command
2378 static void rawfill_cmd()
2380 DEV_BLOCK *block = dcr->block;
2383 uint32_t block_num = 0;
2388 fd = open("/dev/urandom", O_RDONLY);
2390 read(fd, block->buf, block->buf_len);
2393 uint32_t *p = (uint32_t *)block->buf;
2394 srandom(time(NULL));
2395 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2399 p = (uint32_t *)block->buf;
2400 Pmsg1(0, "Begin writing raw blocks of %u bytes.\n", block->buf_len);
2403 stat = write(dev->fd, block->buf, block->buf_len);
2404 if (stat == (int)block->buf_len) {
2405 if ((block_num++ % 100) == 0) {
2410 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2420 printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
2421 be.strerror(my_errno));
2427 * Fill a tape using Bacula block writes
2429 static void bfill_cmd()
2431 DEV_BLOCK *block = dcr->block;
2432 uint32_t block_num = 0;
2438 fd = open("/dev/urandom", O_RDONLY);
2440 read(fd, block->buf, block->buf_len);
2443 uint32_t *p = (uint32_t *)block->buf;
2444 srandom(time(NULL));
2445 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2449 p = (uint32_t *)block->buf;
2450 Pmsg1(0, "Begin writing Bacula blocks of %u bytes.\n", block->buf_len);
2453 block->binbuf = block->buf_len;
2454 block->bufp = block->buf + block->binbuf;
2455 if (!write_block_to_dev(dcr)) {
2458 if ((block_num++ % 100) == 0) {
2463 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2469 printf("Write failed at block %u.\n", block_num);
2474 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2475 static struct cmdstruct commands[] = {
2476 {"autochanger", autochangercmd, "test autochanger"},
2477 {"bsf", bsfcmd, "backspace file"},
2478 {"bsr", bsrcmd, "backspace record"},
2479 {"bfill", bfill_cmd, "fill tape using Bacula writes"},
2480 {"cap", capcmd, "list device capabilities"},
2481 {"clear", clearcmd, "clear tape errors"},
2482 {"eod", eodcmd, "go to end of Bacula data for append"},
2483 {"eom", eomcmd, "go to the physical end of medium"},
2484 {"fill", fillcmd, "fill tape, write onto second volume"},
2485 {"unfill", unfillcmd, "read filled tape"},
2486 {"fsf", fsfcmd, "forward space a file"},
2487 {"fsr", fsrcmd, "forward space a record"},
2488 {"help", helpcmd, "print this command"},
2489 {"label", labelcmd, "write a Bacula label to the tape"},
2490 {"load", loadcmd, "load a tape"},
2491 {"quit", quitcmd, "quit btape"},
2492 {"rawfill", rawfill_cmd, "use write() to fill tape"},
2493 {"readlabel", readlabelcmd, "read and print the Bacula tape label"},
2494 {"rectest", rectestcmd, "test record handling functions"},
2495 {"rewind", rewindcmd, "rewind the tape"},
2496 {"scan", scancmd, "read() tape block by block to EOT and report"},
2497 {"scanblocks", scan_blocks, "Bacula read block by block to EOT and report"},
2498 {"status", statcmd, "print tape status"},
2499 {"test", testcmd, "General test Bacula tape functions"},
2500 {"weof", weofcmd, "write an EOF on the tape"},
2501 {"wr", wrcmd, "write a single Bacula block"},
2502 {"rr", rrcmd, "read a single record"},
2503 {"qfill", qfillcmd, "quick fill command"},
2505 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2513 while (get_cmd("*")) {
2514 sm_check(__FILE__, __LINE__, false);
2516 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2517 for (i=0; i<comsize; i++) /* search for command */
2518 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2519 (*commands[i].func)(); /* go execute command */
2524 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2530 static void helpcmd()
2534 printf(_("Interactive commands:\n"));
2535 printf(_(" Command Description\n ======= ===========\n"));
2536 for (i=0; i<comsize; i++)
2537 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2544 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2545 "\nVersion: " VERSION " (" BDATE ")\n\n"
2546 "Usage: btape <options> <device_name>\n"
2547 " -b <file> specify bootstrap file\n"
2548 " -c <file> set configuration file to file\n"
2549 " -d <nn> set debug level to nn\n"
2550 " -p proceed inspite of I/O errors\n"
2551 " -s turn off signals\n"
2553 " -? print this message.\n"
2559 * Get next input command from terminal. This
2560 * routine is REALLY primitive, and should be enhanced
2561 * to have correct backspacing, etc.
2564 get_cmd(const char *prompt)
2568 fprintf(stdout, prompt);
2570 /* We really should turn off echoing and pretty this
2574 while ((ch = fgetc(stdin)) != EOF) {
2576 strip_trailing_junk(cmd);
2578 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2591 /* Dummies to replace askdir.c */
2592 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2593 bool dir_send_job_status(JCR *jcr) {return 1;}
2595 bool dir_update_volume_info(DCR *dcr, bool relabel)
2601 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2603 Dmsg0(20, "Enter dir_get_volume_info\n");
2604 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2608 bool dir_create_jobmedia_record(DCR *dcr)
2610 dcr->WroteVol = false;
2615 bool dir_find_next_appendable_volume(DCR *dcr)
2617 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2618 return dcr->VolumeName[0] != 0;
2621 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2623 DEVICE *dev = dcr->dev;
2624 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2625 if (dcr->VolumeName[0] == 0) {
2626 return dir_ask_sysop_to_create_appendable_volume(dcr);
2628 /* Close device so user can use autochanger if desired */
2629 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2632 force_close_dev(dev);
2633 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2634 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2635 fprintf(stderr, "Mount second Volume on device %s and press return when ready: ",
2638 fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
2639 dcr->VolumeName, dev->print_name());
2645 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2648 DEVICE *dev = dcr->dev;
2649 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2651 set_volume_name("TestVolume1", 1);
2653 set_volume_name("TestVolume2", 2);
2655 /* Close device so user can use autochanger if desired */
2656 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2659 autochanger = autoload_device(dcr, 1, NULL);
2661 force_close_dev(dev);
2662 fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
2673 static bool my_mount_next_read_volume(DCR *dcr)
2676 JCR *jcr = dcr->jcr;
2677 DEV_BLOCK *block = dcr->block;
2679 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2680 Pmsg1(000, "End of Volume \"%s\"\n", dcr->VolumeName);
2682 if (LastBlock != block->BlockNumber) {
2683 VolBytes += block->block_len;
2685 LastBlock = block->BlockNumber;
2687 now -= jcr->run_time;
2691 kbs = (double)VolBytes / (1000.0 * (double)now);
2692 Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2693 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2695 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2701 set_volume_name("TestVolume2", 2);
2703 create_vol_list(jcr);
2706 if (!acquire_device_for_read(dcr)) {
2707 Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev->print_name(), dcr->VolumeName);
2710 return true; /* next volume mounted */
2713 static void set_volume_name(const char *VolName, int volnum)
2715 DCR *dcr = jcr->dcr;
2716 VolumeName = VolName;
2718 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2719 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2720 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2721 dcr->VolCatInfo.Slot = volnum;