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();
43 /* Exported variables */
46 int bsize = TAPE_BSIZE;
47 char VolName[MAX_NAME_LENGTH];
48 bool forge_on = false;
51 * If you change the format of the state file,
52 * increment this value
54 static uint32_t btape_state_level = 2;
58 DEVRES *device = NULL;
61 /* Forward referenced subroutines */
62 static void do_tape_cmds();
63 static void helpcmd();
64 static void scancmd();
65 static void rewindcmd();
66 static void clearcmd();
70 static void fillcmd();
71 static void qfillcmd();
72 static void statcmd();
73 static void unfillcmd();
74 static int flush_block(DEV_BLOCK *block, int dump);
75 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
76 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
77 static bool my_mount_next_read_volume(DCR *dcr);
78 static void scan_blocks();
79 static void set_volume_name(const char *VolName, int volnum);
80 static void rawfill_cmd();
81 static void bfill_cmd();
82 static bool open_the_device();
83 static void autochangercmd();
84 static void do_unfill();
87 /* Static variables */
88 #define CONFIG_FILE "bacula-sd.conf"
91 #define MAX_CMD_ARGS 30
94 static char *argk[MAX_CMD_ARGS];
95 static char *argv[MAX_CMD_ARGS];
98 static int quickie_count = 0;
99 static BSR *bsr = NULL;
100 static int signals = TRUE;
103 static uint64_t vol_size;
104 static uint64_t VolBytes;
107 static int32_t file_index;
108 static int end_of_tape = 0;
109 static uint32_t LastBlock = 0;
110 static uint32_t eot_block;
111 static uint32_t eot_block_len;
112 static uint32_t eot_FileIndex;
113 static int dumped = 0;
114 static DEV_BLOCK *last_block1 = NULL;
115 static DEV_BLOCK *last_block2 = NULL;
116 static DEV_BLOCK *last_block = NULL;
117 static DEV_BLOCK *this_block = NULL;
118 static DEV_BLOCK *first_block = NULL;
119 static uint32_t last_file1 = 0;
120 static uint32_t last_file2 = 0;
121 static uint32_t last_file = 0;
122 static uint32_t last_block_num1 = 0;
123 static uint32_t last_block_num2 = 0;
124 static uint32_t last_block_num = 0;
125 static uint32_t BlockNumber = 0;
126 static bool simple = true;
128 static const char *VolumeName = NULL;
129 static int vol_num = 0;
131 static JCR *jcr = NULL;
135 static void terminate_btape(int sig);
136 int get_cmd(const char *prompt);
139 /*********************************************************************
141 * Main Bacula Pool Creation Program
144 int main(int margc, char *margv[])
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);
159 if (sizeof(off_t) < 8) {
160 Pmsg1(-1, "\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n",
164 bsnprintf(buf, sizeof(buf), "%u", x32);
165 i = bsscanf(buf, "%u", &y32);
166 if (i != 1 || x32 != y32) {
167 Pmsg3(-1, "32 bit printf/scanf problem. i=%d x32=%u y32=%u\n", i, x32, y32);
173 bsnprintf(buf, sizeof(buf), "%" llu, x64);
174 i = bsscanf(buf, "%llu", &y64);
175 if (i != 1 || x64 != y64) {
176 Pmsg3(-1, "64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n", i, x64, y64);
180 printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
182 working_directory = "/tmp";
183 my_name_is(margc, margv, "btape");
184 init_msg(NULL, NULL);
186 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
188 case 'b': /* bootstrap file */
189 bsr = parse_bsr(NULL, optarg);
190 // dump_bsr(bsr, true);
193 case 'c': /* specify config file */
194 if (configfile != NULL) {
197 configfile = bstrdup(optarg);
200 case 'd': /* set debug level */
201 debug_level = atoi(optarg);
202 if (debug_level <= 0) {
229 cmd = get_pool_memory(PM_FNAME);
230 args = get_pool_memory(PM_FNAME);
233 init_signals(terminate_btape);
236 if (configfile == NULL) {
237 configfile = bstrdup(CONFIG_FILE);
240 daemon_start_time = time(NULL);
242 parse_config(configfile);
245 /* See if we can open a device */
247 Pmsg0(000, "No archive name specified.\n");
250 } else if (margc != 1) {
251 Pmsg0(000, "Improper number of arguments specified.\n");
256 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
265 if (!open_the_device()) {
269 Dmsg0(200, "Do tape commands\n");
277 static void terminate_btape(int stat)
280 sm_check(__FILE__, __LINE__, false);
284 free_config_resources();
286 free_pool_memory(args);
290 free_pool_memory(cmd);
305 if (debug_level > 10)
306 print_memory_pool_stats();
309 free_block(this_block);
314 close_memory_pool(); /* free memory in pool */
320 static bool open_the_device()
324 block = new_block(dev);
326 if (!(dev->state & ST_OPENED)) {
327 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
328 if (open_dev(dev, dcr->VolumeName, OPEN_READ_WRITE) < 0) {
329 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
335 Pmsg1(000, "open_dev %s OK\n", dev_name(dev));
336 dev->state |= ST_APPEND;
349 * Write a label to the tape
351 static void labelcmd()
354 pm_strcpy(cmd, VolumeName);
356 if (!get_cmd("Enter Volume Name: ")) {
361 if (!(dev->state & ST_OPENED)) {
362 if (!first_open_device(dev)) {
363 Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
367 write_new_volume_label_to_dev(dcr, cmd, "Default");
368 Pmsg1(-1, "Wrote Volume label for volume \"%s\".\n", cmd);
372 * Read the tape label
374 static void readlabelcmd()
376 int save_debug_level = debug_level;
379 stat = read_dev_volume_label(dcr);
382 Pmsg0(0, "Volume has no label.\n");
385 Pmsg0(0, "Volume label read correctly.\n");
388 Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev));
391 Pmsg0(0, "Volume name error\n");
393 case VOL_CREATE_ERROR:
394 Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
396 case VOL_VERSION_ERROR:
397 Pmsg0(0, "Volume version error.\n");
399 case VOL_LABEL_ERROR:
400 Pmsg0(0, "Bad Volume label type.\n");
403 Pmsg0(0, "Unknown error.\n");
408 dump_volume_label(dev);
409 debug_level = save_debug_level;
414 * Load the tape should have prevously been taken
415 * off line, otherwise this command is not necessary.
417 static void loadcmd()
420 if (!load_dev(dev)) {
421 Pmsg1(0, "Bad status from load. ERR=%s\n", strerror_dev(dev));
423 Pmsg1(0, "Loaded %s\n", dev_name(dev));
429 static void rewindcmd()
431 if (!rewind_dev(dev)) {
432 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
433 clrerror_dev(dev, -1);
435 Pmsg1(0, "Rewound %s\n", dev_name(dev));
440 * Clear any tape error
442 static void clearcmd()
444 clrerror_dev(dev, -1);
448 * Write and end of file on the tape
450 static void weofcmd()
461 if ((stat = weof_dev(dev, num)) < 0) {
462 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
465 Pmsg3(0, "Wrote %d EOF%s to %s\n", num, num==1?"":"s", dev_name(dev));
470 /* Go to the end of the medium -- raw command
471 * The idea was orginally that the end of the Bacula
472 * medium would be flagged differently. This is not
473 * currently the case. So, this is identical to the
479 Pmsg1(0, "%s", strerror_dev(dev));
482 Pmsg0(0, _("Moved to end of medium.\n"));
487 * Go to the end of the medium (either hardware determined
488 * or defined by two eofs.
508 if (!bsf_dev(dev, num)) {
509 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
511 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
527 if (!bsr_dev(dev, num)) {
528 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
530 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
535 * List device capabilities as defined in the
540 printf(_("Configured device capabilities:\n"));
541 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
542 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
543 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
544 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
545 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
546 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
547 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
548 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
549 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
550 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
551 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
552 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
553 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
554 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
555 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
558 printf(_("Device status:\n"));
559 printf("%sOPENED ", dev->state & ST_OPENED ? "" : "!");
560 printf("%sTAPE ", dev->state & ST_TAPE ? "" : "!");
561 printf("%sLABEL ", dev->state & ST_LABEL ? "" : "!");
562 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
563 printf("%sAPPEND ", dev->state & ST_APPEND ? "" : "!");
564 printf("%sREAD ", dev->state & ST_READ ? "" : "!");
565 printf("%sEOT ", dev->state & ST_EOT ? "" : "!");
566 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
567 printf("%sEOF ", dev->state & ST_EOF ? "" : "!");
568 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
569 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
572 printf(_("Device parameters:\n"));
573 printf("Device name: %s\n", dev->dev_name);
574 printf("File=%u block=%u\n", dev->file, dev->block_num);
575 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
583 * Test writting larger and larger records.
584 * This is a torture test for records.
586 static void rectestcmd()
592 Pmsg0(0, "Test writting larger and larger records.\n"
593 "This is a torture test for records.\nI am going to write\n"
594 "larger and larger records. It will stop when the record size\n"
595 "plus the header exceeds the block size (by default about 64K)\n");
598 get_cmd("Do you want to continue? (y/n): ");
600 Pmsg0(000, "Command aborted.\n");
604 sm_check(__FILE__, __LINE__, false);
605 block = new_block(dev);
608 for (i=1; i<500000; i++) {
609 rec->data = check_pool_memory_size(rec->data, i);
610 memset(rec->data, i & 0xFF, i);
612 sm_check(__FILE__, __LINE__, false);
613 if (write_record_to_block(block, rec)) {
616 Pmsg2(0, "Block %d i=%d\n", blkno, i);
620 sm_check(__FILE__, __LINE__, false);
624 sm_check(__FILE__, __LINE__, false);
628 * This test attempts to re-read a block written by Bacula
629 * normally at the end of the tape. Bacula will then back up
630 * over the two eof marks, backup over the record and reread
631 * it to make sure it is valid. Bacula can skip this validation
632 * if you set "Backward space record = no"
634 static int re_read_block_test()
636 DEV_BLOCK *block = dcr->block;
641 if (!(dev->capabilities & CAP_BSR)) {
642 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
646 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
647 "I'm going to write three records and an EOF\n"
648 "then backup over the EOF and re-read the last record.\n"
649 "Bacula does this after writing the last block on the\n"
650 "tape to verify that the block was written correctly.\n\n"
651 "This is not an *essential* feature ...\n\n"));
655 rec->data = check_pool_memory_size(rec->data, block->buf_len);
656 len = rec->data_len = block->buf_len-100;
657 memset(rec->data, 1, rec->data_len);
658 if (!write_record_to_block(block, rec)) {
659 Pmsg0(0, _("Error writing record to block.\n"));
662 if (!write_block_to_dev(dcr)) {
663 Pmsg0(0, _("Error writing block to device.\n"));
666 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
668 memset(rec->data, 2, rec->data_len);
669 if (!write_record_to_block(block, rec)) {
670 Pmsg0(0, _("Error writing record to block.\n"));
673 if (!write_block_to_dev(dcr)) {
674 Pmsg0(0, _("Error writing block to device.\n"));
677 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
679 memset(rec->data, 3, rec->data_len);
680 if (!write_record_to_block(block, rec)) {
681 Pmsg0(0, _("Error writing record to block.\n"));
684 if (!write_block_to_dev(dcr)) {
685 Pmsg0(0, _("Error writing block to device.\n"));
688 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
691 if (dev_cap(dev, CAP_TWOEOF)) {
694 if (!bsf_dev(dev, 1)) {
695 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
698 if (dev_cap(dev, CAP_TWOEOF)) {
699 if (!bsf_dev(dev, 1)) {
700 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
704 Pmsg0(0, "Backspaced over EOF OK.\n");
705 if (!bsr_dev(dev, 1)) {
706 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
709 Pmsg0(0, "Backspace record OK.\n");
710 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
712 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
715 memset(rec->data, 0, rec->data_len);
716 if (!read_record_from_block(block, rec)) {
718 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
721 for (int i=0; i<len; i++) {
722 if (rec->data[i] != 3) {
723 Pmsg0(0, _("Bad data in record. Test failed!\n"));
727 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
728 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
735 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
736 "this function to verify the last block written to the\n"
737 "tape. Bacula will skip the last block verification\n"
739 "Backward Space Record = No\n\n"
740 "to your Storage daemon's Device resource definition.\n"));
747 * This test writes Bacula blocks to the tape in
748 * several files. It then rewinds the tape and attepts
749 * to read these blocks back checking the data.
751 static int write_read_test()
759 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
760 "I'm going to write 1000 records and an EOF\n"
761 "then write 1000 records and an EOF, then rewind,\n"
762 "and re-read the data to verify that it is correct.\n\n"
763 "This is an *essential* feature ...\n\n"));
766 if (!rewind_dev(dev)) {
767 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
770 rec->data = check_pool_memory_size(rec->data, block->buf_len);
771 rec->data_len = block->buf_len-100;
772 len = rec->data_len/sizeof(i);
773 for (i=1; i<=1000; i++) {
774 p = (int *)rec->data;
775 for (j=0; j<len; j++) {
778 if (!write_record_to_block(block, rec)) {
779 Pmsg0(0, _("Error writing record to block.\n"));
782 if (!write_block_to_dev(dcr)) {
783 Pmsg0(0, _("Error writing block to device.\n"));
787 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
789 for (i=1001; i<=2000; i++) {
790 p = (int *)rec->data;
791 for (j=0; j<len; j++) {
794 if (!write_record_to_block(block, rec)) {
795 Pmsg0(0, _("Error writing record to block.\n"));
798 if (!write_block_to_dev(dcr)) {
799 Pmsg0(0, _("Error writing block to device.\n"));
803 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
805 if (dev_cap(dev, CAP_TWOEOF)) {
808 if (!rewind_dev(dev)) {
809 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
812 Pmsg0(0, "Rewind OK.\n");
814 for (i=1; i<=2000; i++) {
816 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
818 if (dev_state(dev, ST_EOF)) {
819 Pmsg0(-1, _("Got EOF on tape.\n"));
824 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
827 memset(rec->data, 0, rec->data_len);
828 if (!read_record_from_block(block, rec)) {
830 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
833 p = (int *)rec->data;
834 for (j=0; j<len; j++) {
836 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
842 if (i == 1000 || i == 2000) {
843 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
846 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
855 * This test writes Bacula blocks to the tape in
856 * several files. It then rewinds the tape and attepts
857 * to read these blocks back checking the data.
859 static int position_test()
861 DEV_BLOCK *block = dcr->block;
867 int file = 0, blk = 0;
869 bool got_eof = false;
871 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
872 "I'm going to write 1000 records and an EOF\n"
873 "then write 1000 records and an EOF, then rewind,\n"
874 "and position to a few blocks and verify that it is correct.\n\n"
875 "This is an *essential* feature ...\n\n"));
878 if (!rewind_dev(dev)) {
879 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
882 rec->data = check_pool_memory_size(rec->data, block->buf_len);
883 rec->data_len = block->buf_len-100;
884 len = rec->data_len/sizeof(i);
885 for (i=1; i<=1000; i++) {
886 p = (int *)rec->data;
887 for (j=0; j<len; j++) {
890 if (!write_record_to_block(block, rec)) {
891 Pmsg0(0, _("Error writing record to block.\n"));
894 if (!write_block_to_dev(dcr)) {
895 Pmsg0(0, _("Error writing block to device.\n"));
899 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
901 for (i=1001; i<=2000; i++) {
902 p = (int *)rec->data;
903 for (j=0; j<len; j++) {
906 if (!write_record_to_block(block, rec)) {
907 Pmsg0(0, _("Error writing record to block.\n"));
910 if (!write_block_to_dev(dcr)) {
911 Pmsg0(0, _("Error writing block to device.\n"));
915 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
917 if (dev_cap(dev, CAP_TWOEOF)) {
920 if (!rewind_dev(dev)) {
921 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
924 Pmsg0(0, "Rewind OK.\n");
928 /* Set up next item to read based on where we are */
964 Pmsg2(-1, "Reposition to file:block %d:%d\n", file, blk);
965 if (!reposition_dev(dev, file, blk)) {
966 Pmsg0(0, "Reposition error.\n");
970 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
972 if (dev_state(dev, ST_EOF)) {
973 Pmsg0(-1, _("Got EOF on tape.\n"));
979 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
980 recno, file, blk, be.strerror(dev->dev_errno));
981 Pmsg0(0, _("This may be because the tape drive block size is not\n"
982 " set to variable blocking as normally used by Bacula.\n"
983 " Please see the Tape Testing chapter in the manual and \n"
984 " look for using mt with defblksize and setoptions\n"
985 "If your tape drive block size is correct, then perhaps\n"
986 " your SCSI driver is *really* stupid and does not\n"
987 " correctly report the file:block after a FSF. In this\n"
988 " case try setting:\n"
989 " Fast Forward Space File = no\n"
990 " in your Device resource.\n"));
994 memset(rec->data, 0, rec->data_len);
995 if (!read_record_from_block(block, rec)) {
997 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1000 p = (int *)rec->data;
1001 for (j=0; j<len; j++) {
1002 if (p[j] != recno) {
1003 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1008 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1010 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1022 * This test writes some records, then writes an end of file,
1023 * rewinds the tape, moves to the end of the data and attepts
1024 * to append to the tape. This function is essential for
1025 * Bacula to be able to write multiple jobs to the tape.
1027 static int append_test()
1029 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1030 "This test is essential to Bacula.\n\n"
1031 "I'm going to write one record in file 0,\n"
1032 " two records in file 1,\n"
1033 " and three records in file 2\n\n"));
1037 weofcmd(); /* end file 0 */
1040 weofcmd(); /* end file 1 */
1044 weofcmd(); /* end file 2 */
1045 if (dev_cap(dev, CAP_TWOEOF)) {
1048 force_close_dev(dev); /* release device */
1049 if (!open_the_device()) {
1053 Pmsg0(0, _("Now moving to end of medium.\n"));
1055 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1056 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1058 if (dev->file != 3) {
1062 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1065 if (dev_cap(dev, CAP_TWOEOF)) {
1069 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1070 Pmsg0(-1, "Doing Bacula scan of blocks:\n");
1072 Pmsg0(-1, _("End scanning the tape.\n"));
1073 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1074 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1076 if (dev->file != 4) {
1084 * This test exercises the autochanger
1086 static int autochanger_test()
1088 POOLMEM *results, *changer;
1089 int slot, status, loaded;
1090 int timeout = jcr->device->max_changer_wait;
1093 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1094 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1097 if (!(jcr->device && jcr->device->changer_name && jcr->device->changer_command)) {
1098 Pmsg0(-1, "\nAutochanger enabled, but no name or no command device specified.\n");
1102 Pmsg0(-1, "\nAh, I see you have an autochanger configured.\n"
1103 "To test the autochanger you must have a blank tape\n"
1104 " that I can write on in Slot 1.\n");
1105 if (!get_cmd("\nDo you wish to continue with the Autochanger test? (y/n): ")) {
1108 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1112 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1114 results = get_pool_memory(PM_MESSAGE);
1115 changer = get_pool_memory(PM_FNAME);
1119 dcr->VolCatInfo.Slot = slot;
1120 /* Find out what is loaded, zero means device is unloaded */
1121 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1122 changer = edit_device_codes(jcr, changer, jcr->device->changer_command,
1124 status = run_program(changer, timeout, results);
1125 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1127 loaded = atoi(results);
1130 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1131 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1135 Pmsg1(-1, "Slot %d loaded. I am going to unload it.\n", loaded);
1137 Pmsg0(-1, "Nothing loaded in the drive. OK.\n");
1139 Dmsg1(100, "Results from loaded query=%s\n", results);
1141 dcr->VolCatInfo.Slot = loaded;
1142 offline_or_rewind_dev(dev);
1143 /* We are going to load a new tape, so close the device */
1144 force_close_dev(dev);
1145 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1146 loaded, dev->drive_index);
1147 changer = edit_device_codes(jcr, changer,
1148 jcr->device->changer_command, "unload");
1149 status = run_program(changer, timeout, results);
1150 Pmsg2(-1, "unload status=%s %d\n", status==0?"OK":"Bad", status);
1153 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1154 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1163 dcr->VolCatInfo.Slot = slot;
1164 Pmsg2(-1, _("3303 Issuing autochanger \"load slot %d %d\" command.\n"),
1165 slot, dev->drive_index);
1166 changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "load");
1167 Dmsg1(100, "Changer=%s\n", changer);
1168 force_close_dev(dev);
1169 status = run_program(changer, timeout, results);
1171 Pmsg2(-1, _("3303 Autochanger \"load slot %d %d\" status is OK.\n"),
1172 slot, dev->drive_index);
1175 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1176 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1180 if (!open_the_device()) {
1184 * Start with sleep_time 0 then increment by 30 seconds if we get
1187 bmicrosleep(sleep_time, 0);
1188 if (!rewind_dev(dev) || weof_dev(dev,1) < 0) {
1189 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
1190 clrerror_dev(dev, -1);
1191 Pmsg0(-1, "\nThe test failed, probably because you need to put\n"
1192 "a longer sleep time in the mtx-script in the load) case.\n"
1193 "Adding a 30 second sleep and trying again ...\n");
1197 Pmsg1(0, "Rewound %s\n", dev_name(dev));
1200 if ((status = weof_dev(dev, 1)) < 0) {
1201 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", status, strerror_dev(dev));
1204 Pmsg1(0, "Wrote EOF to %s\n", dev_name(dev));
1208 Pmsg1(-1, "\nThe test worked this time. Please add:\n\n"
1210 "to your mtx-changer script in the load) case.\n\n",
1213 Pmsg0(-1, "\nThe test autochanger worked!!\n\n");
1216 free_pool_memory(changer);
1217 free_pool_memory(results);
1222 free_pool_memory(changer);
1223 free_pool_memory(results);
1224 Pmsg0(-1, "You must correct this error or the Autochanger will not work.\n");
1228 static void autochangercmd()
1235 * This test assumes that the append test has been done,
1236 * then it tests the fsf function.
1238 static int fsf_test()
1240 bool set_off = false;
1242 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1243 "This test is essential to Bacula.\n\n"
1244 "I'm going to write five files then test forward spacing\n\n"));
1248 weofcmd(); /* end file 0 */
1251 weofcmd(); /* end file 1 */
1255 weofcmd(); /* end file 2 */
1258 weofcmd(); /* end file 3 */
1260 weofcmd(); /* end file 4 */
1261 if (dev_cap(dev, CAP_TWOEOF)) {
1267 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1268 if (!fsf_dev(dev, 1)) {
1269 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1272 Pmsg2(-1, _("We should be in file 1. I am at file %d. This is %s\n"),
1273 dev->file, dev->file == 1 ? "correct!" : "NOT correct!!!!");
1275 if (dev->file != 1) {
1279 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1280 if (!fsf_dev(dev, 2)) {
1281 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1284 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1285 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1287 if (dev->file != 3) {
1292 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1293 if (!fsf_dev(dev, 4)) {
1294 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1297 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1298 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1300 if (dev->file != 4) {
1304 Pmsg0(-1, "The test worked this time. Please add:\n\n"
1305 " Fast Forward Space File = no\n\n"
1306 "to your Device resource for this drive.\n");
1310 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1311 if (!fsf_dev(dev, 1)) {
1312 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1314 Pmsg2(-1, _("We should be in file 5. I am at file %d. This is %s\n"),
1315 dev->file, dev->file == 5 ? "correct!" : "NOT correct!!!!");
1316 if (dev->file != 5) {
1319 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1323 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1324 if (dev_cap(dev, CAP_FASTFSF)) {
1325 Pmsg0(-1, "You have Fast Forward Space File enabled.\n"
1326 "I am turning it off then retrying the test.\n");
1327 dev->capabilities &= ~CAP_FASTFSF;
1331 Pmsg0(-1, "You must correct this error or Bacula will not work.\n"
1332 "Some systems, e.g. OpenBSD, require you to set\n"
1333 " File Block Bookkeeping = no\n"
1334 "in your device resource. Use with caution.\n");
1343 * This is a general test of Bacula's functions
1344 * needed to read and write the tape.
1346 static void testcmd()
1350 if (!write_read_test()) {
1353 if (!position_test()) {
1357 stat = append_test();
1358 if (stat == 1) { /* OK get out */
1361 if (stat == -1) { /* first test failed */
1362 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1363 Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
1364 "Setting \"Hardware End of Medium = no\n"
1365 " and \"Fast Forward Space File = no\n"
1366 "and retrying append test.\n\n");
1367 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1368 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1369 stat = append_test();
1371 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1372 " Hardware End of Medium = No\n\n"
1373 " Fast Forward Space File = No\n"
1374 "to your Device resource in the Storage conf file.\n");
1378 Pmsg0(-1, "\n\nThat appears *NOT* to have corrected the problem.\n");
1381 /* Wrong count after append */
1383 Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
1384 "Setting \"BSF at EOM = yes\" and retrying append test.\n");
1385 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1386 stat = append_test();
1388 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1389 " Hardware End of Medium = No\n"
1390 " Fast Forward Space File = No\n"
1391 " BSF at EOM = yes\n\n"
1392 "to your Device resource in the Storage conf file.\n");
1399 Pmsg0(-1, "\nAppend test failed.\n\n");
1400 Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1401 "Unable to correct the problem. You MUST fix this\n"
1402 "problem before Bacula can use your tape drive correctly\n");
1403 Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
1404 "Do so by setting:\n\n"
1405 "Minimum Block Size = nnn\n"
1406 "Maximum Block Size = nnn\n\n"
1407 "in your Storage daemon's Device definition.\n"
1408 "nnn must match your tape driver's block size, which\n"
1409 "can be determined by reading your tape manufacturers\n"
1410 "information, and the information on your kernel dirver.\n"
1411 "Fixed block sizes, however, are not normally an ideal solution.\n"
1413 "Some systems, e.g. OpenBSD, require you to set\n"
1414 " File Block Bookkeeping = no\n"
1415 "in your device resource. Use with caution.\n");
1420 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1421 "Please double check it ...\n"
1422 "=== Sample correct output ===\n"
1423 "1 block of 64448 bytes in file 1\n"
1424 "End of File mark.\n"
1425 "2 blocks of 64448 bytes in file 2\n"
1426 "End of File mark.\n"
1427 "3 blocks of 64448 bytes in file 3\n"
1428 "End of File mark.\n"
1429 "1 block of 64448 bytes in file 4\n"
1430 "End of File mark.\n"
1431 "Total files=4, blocks=7, bytes = 451,136\n"
1432 "=== End sample correct output ===\n\n"));
1434 Pmsg0(-1, _("If the above scan output is not identical to the\n"
1435 "sample output, you MUST correct the problem\n"
1436 "or Bacula will not be able to write multiple Jobs to \n"
1440 re_read_block_test();
1443 fsf_test(); /* do fast forward space file test */
1445 autochanger_test(); /* do autochanger test */
1449 /* Forward space a file */
1450 static void fsfcmd()
1454 num = atoi(argk[1]);
1459 if (!fsf_dev(dev, num)) {
1460 Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
1463 Pmsg2(0, "Forward spaced %d file%s.\n", num, num==1?"":"s");
1466 /* Forward space a record */
1467 static void fsrcmd()
1471 num = atoi(argk[1]);
1476 if (!fsr_dev(dev, num)) {
1477 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1480 Pmsg2(0, "Forward spaced %d record%s.\n", num, num==1?"":"s");
1485 * Write a Bacula block to the tape
1489 DEV_BLOCK *block = dcr->block;
1490 DEV_RECORD *rec = dcr->rec;
1493 sm_check(__FILE__, __LINE__, false);
1496 dump_block(block, "test");
1499 i = block->buf_len - 100;
1501 rec->data = check_pool_memory_size(rec->data, i);
1502 memset(rec->data, i & 0xFF, i);
1504 sm_check(__FILE__, __LINE__, false);
1505 if (!write_record_to_block(block, rec)) {
1506 Pmsg0(0, _("Error writing record to block.\n"));
1509 if (!write_block_to_dev(dcr)) {
1510 Pmsg0(0, _("Error writing block to device.\n"));
1513 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1515 Pmsg0(0, _("Wrote block to device.\n"));
1518 sm_check(__FILE__, __LINE__, false);
1519 sm_check(__FILE__, __LINE__, false);
1523 * Read a record from the tape
1530 if (!get_cmd("Enter length to read: ")) {
1534 if (len < 0 || len > 1000000) {
1535 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1538 buf = (char *)malloc(len);
1539 stat = read(dev->fd, buf, len);
1540 if (stat > 0 && stat <= len) {
1544 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1545 len, stat, be.strerror());
1551 * Scan tape by reading block by block. Report what is
1552 * on the tape. Note, this command does raw reads, and as such
1553 * will not work with fixed block size devices.
1555 static void scancmd()
1558 int blocks, tot_blocks, tot_files;
1564 blocks = block_size = tot_blocks = 0;
1566 if (dev->state & ST_EOT) {
1567 Pmsg0(0, "End of tape\n");
1570 update_pos_dev(dev);
1571 tot_files = dev->file;
1572 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1574 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1576 clrerror_dev(dev, -1);
1577 Mmsg2(dev->errmsg, "read error on %s. ERR=%s.\n",
1578 dev->dev_name, be.strerror());
1579 Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
1581 printf("%d block%s of %d bytes in file %d\n",
1582 blocks, blocks>1?"s":"", block_size, dev->file);
1585 Dmsg1(200, "read status = %d\n", stat);
1587 if (stat != block_size) {
1588 update_pos_dev(dev);
1590 printf("%d block%s of %d bytes in file %d\n",
1591 blocks, blocks>1?"s":"", block_size, dev->file);
1596 if (stat == 0) { /* EOF */
1597 update_pos_dev(dev);
1598 printf("End of File mark.\n");
1599 /* Two reads of zero means end of tape */
1600 if (dev->state & ST_EOF)
1601 dev->state |= ST_EOT;
1603 dev->state |= ST_EOF;
1606 if (dev->state & ST_EOT) {
1607 printf("End of tape\n");
1610 } else { /* Got data */
1611 dev->state &= ~ST_EOF;
1617 update_pos_dev(dev);
1618 tot_files = dev->file - tot_files;
1619 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1620 edit_uint64_with_commas(bytes, ec1));
1625 * Scan tape by reading Bacula block by block. Report what is
1626 * on the tape. This function reads Bacula blocks, so if your
1627 * Device resource is correctly defined, it should work with
1628 * either variable or fixed block sizes.
1630 static void scan_blocks()
1632 int blocks, tot_blocks, tot_files;
1633 uint32_t block_size;
1635 DEV_BLOCK *block = dcr->block;
1638 blocks = block_size = tot_blocks = 0;
1642 update_pos_dev(dev);
1643 tot_files = dev->file;
1645 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1646 Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
1647 if (dev->state & ST_EOT) {
1649 printf("%d block%s of %d bytes in file %d\n",
1650 blocks, blocks>1?"s":"", block_size, dev->file);
1655 if (dev->state & ST_EOF) {
1657 printf("%d block%s of %d bytes in file %d\n",
1658 blocks, blocks>1?"s":"", block_size, dev->file);
1661 printf(_("End of File mark.\n"));
1664 if (dev->state & ST_SHORT) {
1666 printf("%d block%s of %d bytes in file %d\n",
1667 blocks, blocks>1?"s":"", block_size, dev->file);
1670 printf(_("Short block read.\n"));
1673 printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1676 if (block->block_len != block_size) {
1678 printf("%d block%s of %d bytes in file %d\n",
1679 blocks, blocks>1?"s":"", block_size, dev->file);
1682 block_size = block->block_len;
1686 bytes += block->block_len;
1687 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1688 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1689 block->VolSessionId, block->VolSessionTime);
1691 DEV_RECORD *rec = new_record();
1692 read_record_from_block(block, rec);
1693 Pmsg8(-1, "Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
1694 block->BlockNumber, dev->block_num, block->block_len,
1695 FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1696 stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
1699 } else if (verbose > 1) {
1700 dump_block(block, "");
1705 tot_files = dev->file - tot_files;
1706 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1707 edit_uint64_with_commas(bytes, ec1));
1711 static void statcmd()
1713 int debug = debug_level;
1715 Pmsg2(0, "Device status: %u. ERR=%s\n", status_dev(dev), strerror_dev(dev));
1717 dump_volume_label(dev);
1719 debug_level = debug;
1724 * First we label the tape, then we fill
1725 * it with data get a new tape and write a few blocks.
1727 static void fillcmd()
1730 DEV_BLOCK *block = dcr->block;
1734 uint32_t min_block_size;
1744 This command simulates Bacula writing to a tape.\n\
1745 It requires either one or two blank tapes, which it\n\
1746 will label and write.\n\n\
1747 If you have an autochanger configured, it will use\n\
1748 the tapes that are in slots 1 and 2, otherwise, you will\n\
1749 be prompted to insert the tapes when necessary.\n\n\
1750 It will print a status approximately\n\
1751 every 322 MB, and write an EOF every 3.2 GB. If you have\n\
1752 selected the simple test option, after writing the first tape\n\
1753 it will rewind it and re-read the last block written.\n\n\
1754 If you have selected the multiple tape test, when the first tape\n\
1755 fills, it will ask for a second, and after writing a few more \n\
1756 blocks, it will stop. Then it will begin re-reading the\n\
1758 This may take a long time -- hours! ...\n\n");
1760 get_cmd("Do you want to run the simplified test (s) with one tape\n"
1761 "or the complete multiple tape (m) test: (s/m) ");
1762 if (cmd[0] == 's') {
1763 Pmsg0(-1, "Simple test (single tape) selected.\n");
1765 } else if (cmd[0] == 'm') {
1766 Pmsg0(-1, "Multiple tape test selected.\n");
1769 Pmsg0(000, "Command aborted.\n");
1773 Dmsg1(20, "Begin append device=%s\n", dev_name(dev));
1774 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1776 /* Use fixed block size to simplify read back */
1777 min_block_size = dev->min_block_size;
1778 dev->min_block_size = dev->max_block_size;
1779 set_volume_name("TestVolume1", 1);
1784 dev->state &= ~ST_APPEND; /* force volume to be relabeled */
1787 * Acquire output device for writing. Note, after acquiring a
1788 * device, we MUST release it, which is done at the end of this
1791 Dmsg0(100, "just before acquire_device\n");
1792 if (!acquire_device_for_append(jcr)) {
1793 set_jcr_job_status(jcr, JS_ErrorTerminated);
1796 block = jcr->dcr->block;
1798 Dmsg0(100, "Just after acquire_device_for_append\n");
1800 * Write Begin Session Record
1802 if (!write_session_label(dcr, SOS_LABEL)) {
1803 set_jcr_job_status(jcr, JS_ErrorTerminated);
1804 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1808 Pmsg0(-1, "Wrote Start of Session label.\n");
1810 memset(&rec, 0, sizeof(rec));
1811 rec.data = get_memory(100000); /* max record size */
1813 #define REC_SIZE 32768
1814 rec.data_len = REC_SIZE;
1817 * Put some random data in the record
1819 fd = open("/dev/urandom", O_RDONLY);
1821 read(fd, rec.data, rec.data_len);
1824 uint32_t *p = (uint32_t *)rec.data;
1825 srandom(time(NULL));
1826 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1832 * Generate data as if from File daemon, write to device
1834 jcr->dcr->VolFirstIndex = 0;
1835 time(&jcr->run_time); /* start counting time for rates */
1837 Pmsg0(-1, "Begin writing Bacula records to tape ...\n");
1839 Pmsg0(-1, "Begin writing Bacula records to first tape ...\n");
1841 for (file_index = 0; ok && !job_canceled(jcr); ) {
1842 rec.VolSessionId = jcr->VolSessionId;
1843 rec.VolSessionTime = jcr->VolSessionTime;
1844 rec.FileIndex = ++file_index;
1845 rec.Stream = STREAM_FILE_DATA;
1847 /* Mix up the data just a bit */
1848 uint32_t *lp = (uint32_t *)rec.data;
1850 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1854 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1855 rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1858 while (!write_record_to_block(block, &rec)) {
1860 * When we get here we have just filled a block
1862 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1865 /* Write block to tape */
1866 if (!flush_block(block, 1)) {
1870 /* Every 5000 blocks (approx 322MB) report where we are.
1872 if ((block->BlockNumber % 5000) == 0) {
1874 now -= jcr->run_time;
1876 now = 1; /* prevent divide error */
1878 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1879 Pmsg4(-1, "Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n",
1880 block->BlockNumber, dev->block_num,
1881 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1883 /* Every 15000 blocks (approx 1GB) write an EOF.
1885 if ((block->BlockNumber % 15000) == 0) {
1886 Pmsg0(-1, "Flush block, write EOF\n");
1887 flush_block(block, 0);
1891 /* Get out after writing 10 blocks to the second tape */
1892 if (++BlockNumber > 10 && stop != 0) { /* get out */
1897 Pmsg0(000, _("Not OK\n"));
1900 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1901 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1902 FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1903 stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1905 /* Get out after writing 10 blocks to the second tape */
1906 if (BlockNumber > 10 && stop != 0) { /* get out */
1907 Pmsg0(-1, "Done writing ...\n");
1912 Dmsg0(100, "Write_end_session_label()\n");
1913 /* Create Job status for end of session label */
1914 if (!job_canceled(jcr) && ok) {
1915 set_jcr_job_status(jcr, JS_Terminated);
1917 set_jcr_job_status(jcr, JS_ErrorTerminated);
1919 if (!write_session_label(dcr, EOS_LABEL)) {
1920 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1923 /* Write out final block of this session */
1924 if (!write_block_to_device(dcr)) {
1925 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1928 Pmsg0(-1, _("Wrote End of Session label.\n"));
1930 /* Save last block info for second tape */
1931 last_block_num2 = last_block_num;
1932 last_file2 = last_file;
1934 free_block(last_block2);
1936 last_block2 = dup_block(last_block);
1939 sprintf(buf, "%s/btape.state", working_directory);
1940 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1942 write(fd, &btape_state_level, sizeof(btape_state_level));
1943 write(fd, &simple, sizeof(simple));
1944 write(fd, &last_block_num1, sizeof(last_block_num1));
1945 write(fd, &last_block_num2, sizeof(last_block_num2));
1946 write(fd, &last_file1, sizeof(last_file1));
1947 write(fd, &last_file2, sizeof(last_file2));
1948 write(fd, last_block1->buf, last_block1->buf_len);
1949 write(fd, last_block2->buf, last_block2->buf_len);
1950 write(fd, first_block->buf, first_block->buf_len);
1952 Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
1953 last_block_num1, last_block_num2);
1956 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
1960 Pmsg4(-1, _("\n\nDone filling tape%s at %d:%d. Now beginning re-read of %stape ...\n"),
1961 simple?"":"s", jcr->dcr->dev->file, jcr->dcr->dev->block_num, simple?"":"first ");
1963 jcr->dcr->block = block;
1964 /* Release the device if multiple tapes being used */
1965 // if (!simple && !release_device(jcr)) {
1966 // Pmsg0(-1, _("Error in release_device\n"));
1972 dev->min_block_size = min_block_size;
1973 free_memory(rec.data);
1977 * Read two tapes written by the "fill" command and ensure
1978 * that the data is valid. If stop==1 we simulate full read back
1979 * of two tapes. If stop==-1 we simply read the last block and
1980 * verify that it is correct.
1982 static void unfillcmd()
1986 last_block1 = new_block(dev);
1987 last_block2 = new_block(dev);
1988 first_block = new_block(dev);
1989 sprintf(buf, "%s/btape.state", working_directory);
1990 fd = open(buf, O_RDONLY);
1992 uint32_t state_level;
1993 read(fd, &state_level, sizeof(btape_state_level));
1994 read(fd, &simple, sizeof(simple));
1995 read(fd, &last_block_num1, sizeof(last_block_num1));
1996 read(fd, &last_block_num2, sizeof(last_block_num2));
1997 read(fd, &last_file1, sizeof(last_file1));
1998 read(fd, &last_file2, sizeof(last_file2));
1999 read(fd, last_block1->buf, last_block1->buf_len);
2000 read(fd, last_block2->buf, last_block2->buf_len);
2001 read(fd, first_block->buf, first_block->buf_len);
2003 if (state_level != btape_state_level) {
2004 Pmsg0(-1, "\nThe state file level has changed. You must redo\n"
2005 "the fill command.\n");
2010 Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
2011 "You must redo the fill command.\n", buf, be.strerror());
2018 static void do_unfill()
2020 DEV_BLOCK *block = dcr->block;
2027 Dmsg0(20, "Enter do_unfill\n");
2028 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2029 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2033 time(&jcr->run_time); /* start counting time for rates */
2037 free_block(last_block);
2039 last_block_num = last_block_num1;
2040 last_file = last_file1;
2041 last_block = last_block1;
2044 /* Multiple Volume tape */
2045 /* Close device so user can use autochanger if desired */
2046 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2049 autochanger = autoload_device(dcr, 1, NULL);
2051 force_close_dev(dev);
2052 get_cmd(_("Mount first tape. Press enter when ready: "));
2055 jcr->dcr = new_dcr(jcr, dev);
2056 set_volume_name("TestVolume1", 1);
2058 create_vol_list(jcr);
2060 dev->state &= ~(ST_READ|ST_APPEND);
2061 dev->num_writers = 0;
2062 if (!acquire_device_for_read(jcr)) {
2063 Pmsg1(-1, "%s", dev->errmsg);
2068 * We now have the first tape mounted.
2069 * Note, re-reading last block may have caused us to
2070 * loose track of where we are (block number unknown).
2072 if (!rewind_dev(dev)) { /* get to a known place on tape */
2075 /* Read the first 1000 records */
2076 Pmsg0(-1, _("Reading the first 1000 records.\n"));
2078 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2079 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2080 last_file, last_block_num);
2081 if (!reposition_dev(dev, last_file, last_block_num)) {
2082 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2085 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2086 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2087 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2090 if (compare_blocks(last_block, block)) {
2092 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2094 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2101 /* restore info for last block on second Volume */
2102 last_block_num = last_block_num2;
2103 last_file = last_file2;
2104 last_block = last_block2;
2106 /* Multiple Volume tape */
2107 /* Close device so user can use autochanger if desired */
2108 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2113 set_volume_name("TestVolume2", 2);
2115 create_vol_list(jcr);
2116 autochanger = autoload_device(dcr, 1, NULL);
2118 force_close_dev(dev);
2119 get_cmd(_("Mount second tape. Press enter when ready: "));
2122 dev->state &= ~ST_READ;
2123 if (!acquire_device_for_read(jcr)) {
2124 Pmsg1(-1, "%s", dev->errmsg);
2128 /* Space to "first" block which is last block not written
2129 * on the previous tape.
2131 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2132 if (!reposition_dev(dev, 0, 1)) {
2133 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2136 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2137 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2138 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2141 if (compare_blocks(first_block, block)) {
2142 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2145 /* Now find and compare the last block */
2146 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2147 last_file, last_block_num);
2148 if (!reposition_dev(dev, last_file, last_block_num)) {
2149 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2152 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2153 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2154 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2157 if (compare_blocks(last_block, block)) {
2158 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2162 free_block(last_block1);
2163 free_block(last_block2);
2164 free_block(first_block);
2167 /* Read 1000 records then stop */
2168 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2170 DEVICE *dev = dcr->dev;
2171 if (dev->file != 0) {
2172 Pmsg3(-1, "ERROR! device at %d:%d count=%d\n", dev->file, dev->block_num,
2177 if (quickie_count == 1000) {
2178 Pmsg2(-1, "1000 records read now at %d:%d\n", dev->file, dev->block_num);
2180 return quickie_count < 1000;
2183 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2186 uint32_t CheckSum, block_len;
2189 p = last_block->buf;
2191 unser_begin(q, BLKHDR2_LENGTH);
2192 unser_uint32(CheckSum);
2193 unser_uint32(block_len);
2194 while (q < (block->buf+block_len)) {
2201 dump_block(last_block, _("Last block written"));
2203 dump_block(block, _("Block read back"));
2204 Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf);
2205 Pmsg0(-1, "\n\n!!!! The last block written and the block\n"
2206 "that was read back differ. The test FAILED !!!!\n"
2207 "This must be corrected before you use Bacula\n"
2208 "to write multi-tape Volumes.!!!!\n");
2212 dump_block(last_block, _("Last block written"));
2213 dump_block(block, _("Block read back"));
2223 * Write current block to tape regardless of whether or
2224 * not it is full. If the tape fills, attempt to
2225 * acquire another tape.
2227 static int flush_block(DEV_BLOCK *block, int dump)
2231 uint32_t this_file, this_block_num;
2235 this_block = new_block(dev);
2238 last_block = new_block(dev);
2241 this_file = dev->file;
2242 this_block_num = dev->block_num;
2243 if (!write_block_to_dev(dcr)) {
2244 Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n",
2245 last_file, last_block_num, this_block_num);
2248 * This is 1st tape, so save first tape info separate
2249 * from second tape info
2251 last_block_num1 = last_block_num;
2252 last_file1 = last_file;
2253 last_block1 = dup_block(last_block);
2254 last_block2 = dup_block(last_block);
2255 first_block = dup_block(block); /* first block second tape */
2258 Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n",
2259 (unsigned)file_index, block->BlockNumber, block->block_len);
2260 dump_block(last_block, "Last block written");
2262 dump_block(block, "Block not written");
2265 eot_block = block->BlockNumber;
2266 eot_block_len = block->block_len;
2267 eot_FileIndex = file_index;
2271 now -= jcr->run_time;
2273 now = 1; /* don't divide by zero */
2275 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2276 vol_size = dev->VolCatInfo.VolCatBytes;
2277 Pmsg4(000, "End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
2278 dev->file, dev->block_num,
2279 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2282 stop = -1; /* stop, but do simplified test */
2284 /* Full test in progress */
2285 if (!fixup_device_block_write_error(jcr->dcr)) {
2286 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2291 BlockNumber = 0; /* start counting for second tape */
2294 return 1; /* end of tape reached */
2297 /* Save contents after write so that the header is serialized */
2298 memcpy(this_block->buf, block->buf, this_block->buf_len);
2301 * Note, we always read/write to block, but we toggle
2302 * copying it to one or another of two allocated blocks.
2303 * Switch blocks so that the block just successfully written is
2304 * always in last_block.
2306 tblock = last_block;
2307 last_block = this_block;
2308 this_block = tblock;
2309 last_file = this_file;
2310 last_block_num = this_block_num;
2318 * First we label the tape, then we fill
2319 * it with data get a new tape and write a few blocks.
2321 static void qfillcmd()
2323 DEV_BLOCK *block = dcr->block;
2324 DEV_RECORD *rec = dcr->rec;
2327 Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
2329 get_cmd("How many blocks do you want to write? (1000): ");
2336 sm_check(__FILE__, __LINE__, false);
2338 i = block->buf_len - 100;
2340 rec->data = check_pool_memory_size(rec->data, i);
2341 memset(rec->data, i & 0xFF, i);
2344 Pmsg1(0, "Begin writing %d Bacula blocks to tape ...\n", count);
2345 for (i=0; i < count; i++) {
2350 if (!write_record_to_block(block, rec)) {
2351 Pmsg0(0, _("Error writing record to block.\n"));
2354 if (!write_block_to_dev(dcr)) {
2355 Pmsg0(0, _("Error writing block to device.\n"));
2361 if (dev_cap(dev, CAP_TWOEOF)) {
2368 sm_check(__FILE__, __LINE__, false);
2372 * Fill a tape using raw write() command
2374 static void rawfill_cmd()
2376 DEV_BLOCK *block = dcr->block;
2379 uint32_t block_num = 0;
2384 fd = open("/dev/urandom", O_RDONLY);
2386 read(fd, block->buf, block->buf_len);
2389 uint32_t *p = (uint32_t *)block->buf;
2390 srandom(time(NULL));
2391 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2395 p = (uint32_t *)block->buf;
2396 Pmsg1(0, "Begin writing raw blocks of %u bytes.\n", block->buf_len);
2399 stat = write(dev->fd, block->buf, block->buf_len);
2400 if (stat == (int)block->buf_len) {
2401 if ((block_num++ % 100) == 0) {
2406 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2416 printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
2417 be.strerror(my_errno));
2423 * Fill a tape using raw write() command
2425 static void bfill_cmd()
2427 DEV_BLOCK *block = dcr->block;
2428 uint32_t block_num = 0;
2434 fd = open("/dev/urandom", O_RDONLY);
2436 read(fd, block->buf, block->buf_len);
2439 uint32_t *p = (uint32_t *)block->buf;
2440 srandom(time(NULL));
2441 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2445 p = (uint32_t *)block->buf;
2446 Pmsg1(0, "Begin writing Bacula blocks of %u bytes.\n", block->buf_len);
2449 block->binbuf = block->buf_len;
2450 block->bufp = block->buf + block->binbuf;
2451 if (!write_block_to_dev(dcr)) {
2454 if ((block_num++ % 100) == 0) {
2459 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2465 printf("Write failed at block %u.\n", block_num);
2470 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2471 static struct cmdstruct commands[] = {
2472 {"autochanger", autochangercmd, "test autochanger"},
2473 {"bsf", bsfcmd, "backspace file"},
2474 {"bsr", bsrcmd, "backspace record"},
2475 {"bfill", bfill_cmd, "fill tape using Bacula writes"},
2476 {"cap", capcmd, "list device capabilities"},
2477 {"clear", clearcmd, "clear tape errors"},
2478 {"eod", eodcmd, "go to end of Bacula data for append"},
2479 {"eom", eomcmd, "go to the physical end of medium"},
2480 {"fill", fillcmd, "fill tape, write onto second volume"},
2481 {"unfill", unfillcmd, "read filled tape"},
2482 {"fsf", fsfcmd, "forward space a file"},
2483 {"fsr", fsrcmd, "forward space a record"},
2484 {"help", helpcmd, "print this command"},
2485 {"label", labelcmd, "write a Bacula label to the tape"},
2486 {"load", loadcmd, "load a tape"},
2487 {"quit", quitcmd, "quit btape"},
2488 {"rawfill", rawfill_cmd, "use write() to fill tape"},
2489 {"readlabel", readlabelcmd, "read and print the Bacula tape label"},
2490 {"rectest", rectestcmd, "test record handling functions"},
2491 {"rewind", rewindcmd, "rewind the tape"},
2492 {"scan", scancmd, "read() tape block by block to EOT and report"},
2493 {"scanblocks", scan_blocks, "Bacula read block by block to EOT and report"},
2494 {"status", statcmd, "print tape status"},
2495 {"test", testcmd, "General test Bacula tape functions"},
2496 {"weof", weofcmd, "write an EOF on the tape"},
2497 {"wr", wrcmd, "write a single Bacula block"},
2498 {"rr", rrcmd, "read a single record"},
2499 {"qfill", qfillcmd, "quick fill command"},
2501 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2509 while (get_cmd("*")) {
2510 sm_check(__FILE__, __LINE__, false);
2512 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2513 for (i=0; i<comsize; i++) /* search for command */
2514 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2515 (*commands[i].func)(); /* go execute command */
2520 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2526 static void helpcmd()
2530 printf(_("Interactive commands:\n"));
2531 printf(_(" Command Description\n ======= ===========\n"));
2532 for (i=0; i<comsize; i++)
2533 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2540 "Copyright (C) 2000-2004 Kern Sibbald and John Walker.\n"
2541 "\nVersion: " VERSION " (" BDATE ")\n\n"
2542 "Usage: btape <options> <device_name>\n"
2543 " -b <file> specify bootstrap file\n"
2544 " -c <file> set configuration file to file\n"
2545 " -d <nn> set debug level to nn\n"
2546 " -p proceed inspite of I/O errors\n"
2547 " -s turn off signals\n"
2549 " -? print this message.\n"
2555 * Get next input command from terminal. This
2556 * routine is REALLY primitive, and should be enhanced
2557 * to have correct backspacing, etc.
2560 get_cmd(const char *prompt)
2564 fprintf(stdout, prompt);
2566 /* We really should turn off echoing and pretty this
2570 while ((ch = fgetc(stdin)) != EOF) {
2572 strip_trailing_junk(cmd);
2574 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2587 /* Dummies to replace askdir.c */
2588 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2589 bool dir_send_job_status(JCR *jcr) {return 1;}
2591 bool dir_update_volume_info(DCR *dcr, bool relabel)
2597 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2599 Dmsg0(20, "Enter dir_get_volume_info\n");
2600 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2604 bool dir_create_jobmedia_record(DCR *dcr)
2606 dcr->WroteVol = false;
2611 bool dir_find_next_appendable_volume(DCR *dcr)
2613 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2614 return dcr->VolumeName[0] != 0;
2617 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2619 DEVICE *dev = dcr->dev;
2620 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2621 if (dcr->VolumeName[0] == 0) {
2622 return dir_ask_sysop_to_create_appendable_volume(dcr);
2624 /* Close device so user can use autochanger if desired */
2625 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2628 force_close_dev(dev);
2629 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2630 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2631 fprintf(stderr, "Mount second Volume on device %s and press return when ready: ",
2634 fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
2635 dcr->VolumeName, dev_name(dev));
2641 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2644 DEVICE *dev = dcr->dev;
2645 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2647 set_volume_name("TestVolume1", 1);
2649 set_volume_name("TestVolume2", 2);
2651 /* Close device so user can use autochanger if desired */
2652 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2655 autochanger = autoload_device(dcr, 1, NULL);
2657 force_close_dev(dev);
2658 fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
2669 static bool my_mount_next_read_volume(DCR *dcr)
2672 JCR *jcr = dcr->jcr;
2673 DEV_BLOCK *block = dcr->block;
2675 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2676 Pmsg1(000, "End of Volume \"%s\"\n", dcr->VolumeName);
2678 if (LastBlock != block->BlockNumber) {
2679 VolBytes += block->block_len;
2681 LastBlock = block->BlockNumber;
2683 now -= jcr->run_time;
2687 kbs = (double)VolBytes / (1000.0 * (double)now);
2688 Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2689 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2691 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2697 set_volume_name("TestVolume2", 2);
2699 create_vol_list(jcr);
2701 dev->state &= ~ST_READ;
2702 if (!acquire_device_for_read(jcr)) {
2703 Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), dcr->VolumeName);
2706 return true; /* next volume mounted */
2709 static void set_volume_name(const char *VolName, int volnum)
2711 DCR *dcr = jcr->dcr;
2712 VolumeName = VolName;
2714 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2715 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2716 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2717 dcr->VolCatInfo.Slot = volnum;