2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of John Walker.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * Bacula Tape manipulation program
32 * Has various tape manipulation commands -- mostly for
33 * use in determining how tapes really work.
35 * Kern Sibbald, April MM
37 * Note, this program reads stored.conf, and will only
38 * talk to devices that are configured.
52 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
54 /* External subroutines */
55 extern void free_config_resources();
57 /* Exported variables */
60 int bsize = TAPE_BSIZE;
61 char VolName[MAX_NAME_LENGTH];
62 STORES *me = NULL; /* our Global resource */
63 bool forge_on = false; /* proceed inspite of I/O errors */
64 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
65 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
68 * If you change the format of the state file,
69 * increment this value
71 static uint32_t btape_state_level = 2;
75 DEVRES *device = NULL;
78 /* Forward referenced subroutines */
79 static void do_tape_cmds();
80 static void helpcmd();
81 static void scancmd();
82 static void rewindcmd();
83 static void clearcmd();
88 static void fillcmd();
89 static void qfillcmd();
90 static void statcmd();
91 static void unfillcmd();
92 static int flush_block(DEV_BLOCK *block, int dump);
93 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
94 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
95 static bool my_mount_next_read_volume(DCR *dcr);
96 static void scan_blocks();
97 static void set_volume_name(const char *VolName, int volnum);
98 static void rawfill_cmd();
99 static bool open_the_device();
100 static void autochangercmd();
101 static void do_unfill();
104 /* Static variables */
105 #define CONFIG_FILE "bacula-sd.conf"
106 char *configfile = NULL;
108 #define MAX_CMD_ARGS 30
110 static POOLMEM *args;
111 static char *argk[MAX_CMD_ARGS];
112 static char *argv[MAX_CMD_ARGS];
115 static int quickie_count = 0;
116 static uint64_t write_count = 0;
117 static BSR *bsr = NULL;
118 static int signals = TRUE;
121 static uint64_t vol_size;
122 static uint64_t VolBytes;
125 static int32_t file_index;
126 static int end_of_tape = 0;
127 static uint32_t LastBlock = 0;
128 static uint32_t eot_block;
129 static uint32_t eot_block_len;
130 static uint32_t eot_FileIndex;
131 static int dumped = 0;
132 static DEV_BLOCK *last_block1 = NULL;
133 static DEV_BLOCK *last_block2 = NULL;
134 static DEV_BLOCK *last_block = NULL;
135 static DEV_BLOCK *this_block = NULL;
136 static DEV_BLOCK *first_block = NULL;
137 static uint32_t last_file1 = 0;
138 static uint32_t last_file2 = 0;
139 static uint32_t last_file = 0;
140 static uint32_t last_block_num1 = 0;
141 static uint32_t last_block_num2 = 0;
142 static uint32_t last_block_num = 0;
143 static uint32_t BlockNumber = 0;
144 static bool simple = true;
146 static const char *VolumeName = NULL;
147 static int vol_num = 0;
149 static JCR *jcr = NULL;
153 static void terminate_btape(int sig);
154 int get_cmd(const char *prompt);
157 /*********************************************************************
159 * Bacula tape testing program
162 int main(int margc, char *margv[])
169 setlocale(LC_ALL, "");
170 bindtextdomain("bacula", LOCALEDIR);
171 textdomain("bacula");
175 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
176 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
177 TAPE_BSIZE, B_DEV_BSIZE);
179 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
180 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
182 if (sizeof(boffset_t) < 8) {
183 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. boffset_t=%d should be 8 or more !!!!!\n\n\n"),
187 bsnprintf(buf, sizeof(buf), "%u", x32);
188 i = bsscanf(buf, "%lu", &y32);
189 if (i != 1 || x32 != y32) {
190 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
196 bsnprintf(buf, sizeof(buf), "%" llu, x64);
197 i = bsscanf(buf, "%llu", &y64);
198 if (i != 1 || x64 != y64) {
199 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
204 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
206 working_directory = "/tmp";
207 my_name_is(margc, margv, "btape");
208 init_msg(NULL, NULL);
212 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
214 case 'b': /* bootstrap file */
215 bsr = parse_bsr(NULL, optarg);
216 // dump_bsr(bsr, true);
219 case 'c': /* specify config file */
220 if (configfile != NULL) {
223 configfile = bstrdup(optarg);
226 case 'd': /* set debug level */
227 if (*optarg == 't') {
228 dbg_timestamp = true;
230 debug_level = atoi(optarg);
231 if (debug_level <= 0) {
259 cmd = get_pool_memory(PM_FNAME);
260 args = get_pool_memory(PM_FNAME);
263 init_signals(terminate_btape);
266 if (configfile == NULL) {
267 configfile = bstrdup(CONFIG_FILE);
270 daemon_start_time = time(NULL);
272 parse_config(configfile);
275 /* See if we can open a device */
277 Pmsg0(000, _("No archive name specified.\n"));
280 } else if (margc != 1) {
281 Pmsg0(000, _("Improper number of arguments specified.\n"));
286 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
295 Pmsg0(000, _("btape does not work with DVD storage.\n"));
299 if (!dev->is_tape()) {
300 Pmsg0(000, _("btape only works with tape storage.\n"));
305 if (!open_the_device()) {
309 Dmsg0(200, "Do tape commands\n");
317 static void terminate_btape(int stat)
320 sm_check(__FILE__, __LINE__, false);
324 free_config_resources();
326 free_pool_memory(args);
330 free_pool_memory(cmd);
347 if (debug_level > 10)
348 print_memory_pool_stats();
351 free_block(this_block);
356 close_memory_pool(); /* free memory in pool */
357 term_last_jobs_list();
363 static bool open_the_device()
368 block = new_block(dev);
370 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
371 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
372 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
376 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
377 dev->set_append(); /* put volume in append mode */
392 * Write a label to the tape
394 static void labelcmd()
397 pm_strcpy(cmd, VolumeName);
399 if (!get_cmd(_("Enter Volume Name: "))) {
404 if (!dev->is_open()) {
405 if (!first_open_device(dcr)) {
406 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
411 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
412 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
416 * Read the tape label
418 static void readlabelcmd()
420 int save_debug_level = debug_level;
423 stat = read_dev_volume_label(dcr);
426 Pmsg0(0, _("Volume has no label.\n"));
429 Pmsg0(0, _("Volume label read correctly.\n"));
432 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
435 Pmsg0(0, _("Volume name error\n"));
437 case VOL_CREATE_ERROR:
438 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
440 case VOL_VERSION_ERROR:
441 Pmsg0(0, _("Volume version error.\n"));
443 case VOL_LABEL_ERROR:
444 Pmsg0(0, _("Bad Volume label type.\n"));
447 Pmsg0(0, _("Unknown error.\n"));
452 dump_volume_label(dev);
453 debug_level = save_debug_level;
458 * Load the tape should have prevously been taken
459 * off line, otherwise this command is not necessary.
461 static void loadcmd()
464 if (!load_dev(dev)) {
465 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
467 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
473 static void rewindcmd()
475 if (!dev->rewind(dcr)) {
476 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
479 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
484 * Clear any tape error
486 static void clearcmd()
492 * Write and end of file on the tape
494 static void weofcmd()
504 if (!dev->weof(num)) {
505 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
509 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
512 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
518 /* Go to the end of the medium -- raw command
519 * The idea was orginally that the end of the Bacula
520 * medium would be flagged differently. This is not
521 * currently the case. So, this is identical to the
526 if (!dev->eod(dcr)) {
527 Pmsg1(0, "%s", dev->bstrerror());
530 Pmsg0(0, _("Moved to end of medium.\n"));
535 * Go to the end of the medium (either hardware determined
536 * or defined by two eofs.
556 if (!dev->bsf(num)) {
557 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
559 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
575 if (!dev->bsr(num)) {
576 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
578 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
583 * List device capabilities as defined in the
588 printf(_("Configured device capabilities:\n"));
589 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
590 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
591 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
592 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
593 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
594 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
595 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
596 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
597 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
598 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
599 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
600 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
601 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
602 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
603 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
606 printf(_("Device status:\n"));
607 printf("%sOPENED ", dev->is_open() ? "" : "!");
608 printf("%sTAPE ", dev->is_tape() ? "" : "!");
609 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
610 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
611 printf("%sAPPEND ", dev->can_append() ? "" : "!");
612 printf("%sREAD ", dev->can_read() ? "" : "!");
613 printf("%sEOT ", dev->at_eot() ? "" : "!");
614 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
615 printf("%sEOF ", dev->at_eof() ? "" : "!");
616 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
617 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
620 printf(_("Device parameters:\n"));
621 printf("Device name: %s\n", dev->dev_name);
622 printf("File=%u block=%u\n", dev->file, dev->block_num);
623 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
625 printf(_("Status:\n"));
631 * Test writting larger and larger records.
632 * This is a torture test for records.
634 static void rectestcmd()
640 Pmsg0(0, _("Test writting larger and larger records.\n"
641 "This is a torture test for records.\nI am going to write\n"
642 "larger and larger records. It will stop when the record size\n"
643 "plus the header exceeds the block size (by default about 64K)\n"));
646 get_cmd(_("Do you want to continue? (y/n): "));
648 Pmsg0(000, _("Command aborted.\n"));
652 sm_check(__FILE__, __LINE__, false);
653 block = new_block(dev);
656 for (i=1; i<500000; i++) {
657 rec->data = check_pool_memory_size(rec->data, i);
658 memset(rec->data, i & 0xFF, i);
660 sm_check(__FILE__, __LINE__, false);
661 if (write_record_to_block(block, rec)) {
664 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
668 sm_check(__FILE__, __LINE__, false);
672 sm_check(__FILE__, __LINE__, false);
676 * This test attempts to re-read a block written by Bacula
677 * normally at the end of the tape. Bacula will then back up
678 * over the two eof marks, backup over the record and reread
679 * it to make sure it is valid. Bacula can skip this validation
680 * if you set "Backward space record = no"
682 static int re_read_block_test()
684 DEV_BLOCK *block = dcr->block;
689 if (!(dev->capabilities & CAP_BSR)) {
690 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
694 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
695 "I'm going to write three records and an EOF\n"
696 "then backup over the EOF and re-read the last record.\n"
697 "Bacula does this after writing the last block on the\n"
698 "tape to verify that the block was written correctly.\n\n"
699 "This is not an *essential* feature ...\n\n"));
703 rec->data = check_pool_memory_size(rec->data, block->buf_len);
704 len = rec->data_len = block->buf_len-100;
705 memset(rec->data, 1, rec->data_len);
706 if (!write_record_to_block(block, rec)) {
707 Pmsg0(0, _("Error writing record to block.\n"));
710 if (!write_block_to_dev(dcr)) {
711 Pmsg0(0, _("Error writing block to device.\n"));
714 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
716 memset(rec->data, 2, rec->data_len);
717 if (!write_record_to_block(block, rec)) {
718 Pmsg0(0, _("Error writing record to block.\n"));
721 if (!write_block_to_dev(dcr)) {
722 Pmsg0(0, _("Error writing block to device.\n"));
725 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
727 memset(rec->data, 3, rec->data_len);
728 if (!write_record_to_block(block, rec)) {
729 Pmsg0(0, _("Error writing record to block.\n"));
732 if (!write_block_to_dev(dcr)) {
733 Pmsg0(0, _("Error writing block to device.\n"));
736 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
739 if (dev->has_cap(CAP_TWOEOF)) {
743 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
746 if (dev->has_cap(CAP_TWOEOF)) {
748 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
752 Pmsg0(0, _("Backspaced over EOF OK.\n"));
754 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
757 Pmsg0(0, _("Backspace record OK.\n"));
758 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
760 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
763 memset(rec->data, 0, rec->data_len);
764 if (!read_record_from_block(dcr, block, rec)) {
766 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
769 for (int i=0; i<len; i++) {
770 if (rec->data[i] != 3) {
771 Pmsg0(0, _("Bad data in record. Test failed!\n"));
775 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
776 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
783 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
784 "this function to verify the last block written to the\n"
785 "tape. Bacula will skip the last block verification\n"
787 "Backward Space Record = No\n\n"
788 "to your Storage daemon's Device resource definition.\n"));
795 * This test writes Bacula blocks to the tape in
796 * several files. It then rewinds the tape and attepts
797 * to read these blocks back checking the data.
799 static int write_read_test()
807 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
808 "I'm going to write 1000 records and an EOF\n"
809 "then write 1000 records and an EOF, then rewind,\n"
810 "and re-read the data to verify that it is correct.\n\n"
811 "This is an *essential* feature ...\n\n"));
814 if (!dev->rewind(dcr)) {
815 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
818 rec->data = check_pool_memory_size(rec->data, block->buf_len);
819 rec->data_len = block->buf_len-100;
820 len = rec->data_len/sizeof(i);
821 for (i=1; i<=1000; i++) {
822 p = (int *)rec->data;
823 for (j=0; j<len; j++) {
826 if (!write_record_to_block(block, rec)) {
827 Pmsg0(0, _("Error writing record to block.\n"));
830 if (!write_block_to_dev(dcr)) {
831 Pmsg0(0, _("Error writing block to device.\n"));
835 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
837 for (i=1001; i<=2000; i++) {
838 p = (int *)rec->data;
839 for (j=0; j<len; j++) {
842 if (!write_record_to_block(block, rec)) {
843 Pmsg0(0, _("Error writing record to block.\n"));
846 if (!write_block_to_dev(dcr)) {
847 Pmsg0(0, _("Error writing block to device.\n"));
851 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
853 if (dev->has_cap(CAP_TWOEOF)) {
856 if (!dev->rewind(dcr)) {
857 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
860 Pmsg0(0, _("Rewind OK.\n"));
862 for (i=1; i<=2000; i++) {
864 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
866 if (dev_state(dev, ST_EOF)) {
867 Pmsg0(-1, _("Got EOF on tape.\n"));
872 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
875 memset(rec->data, 0, rec->data_len);
876 if (!read_record_from_block(dcr, block, rec)) {
878 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
881 p = (int *)rec->data;
882 for (j=0; j<len; j++) {
884 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
890 if (i == 1000 || i == 2000) {
891 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
894 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
903 * This test writes Bacula blocks to the tape in
904 * several files. It then rewinds the tape and attepts
905 * to read these blocks back checking the data.
907 static int position_test()
909 DEV_BLOCK *block = dcr->block;
915 int file = 0, blk = 0;
917 bool got_eof = false;
919 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
920 "I'm going to write 1000 records and an EOF\n"
921 "then write 1000 records and an EOF, then rewind,\n"
922 "and position to a few blocks and verify that it is correct.\n\n"
923 "This is an *essential* feature ...\n\n"));
926 if (!dev->rewind(dcr)) {
927 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
930 rec->data = check_pool_memory_size(rec->data, block->buf_len);
931 rec->data_len = block->buf_len-100;
932 len = rec->data_len/sizeof(i);
933 for (i=1; i<=1000; i++) {
934 p = (int *)rec->data;
935 for (j=0; j<len; j++) {
938 if (!write_record_to_block(block, rec)) {
939 Pmsg0(0, _("Error writing record to block.\n"));
942 if (!write_block_to_dev(dcr)) {
943 Pmsg0(0, _("Error writing block to device.\n"));
947 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
949 for (i=1001; i<=2000; i++) {
950 p = (int *)rec->data;
951 for (j=0; j<len; j++) {
954 if (!write_record_to_block(block, rec)) {
955 Pmsg0(0, _("Error writing record to block.\n"));
958 if (!write_block_to_dev(dcr)) {
959 Pmsg0(0, _("Error writing block to device.\n"));
963 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
965 if (dev->has_cap(CAP_TWOEOF)) {
968 if (!dev->rewind(dcr)) {
969 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
972 Pmsg0(0, _("Rewind OK.\n"));
976 /* Set up next item to read based on where we are */
1012 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1013 if (!dev->reposition(dcr, file, blk)) {
1014 Pmsg0(0, _("Reposition error.\n"));
1018 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1020 if (dev_state(dev, ST_EOF)) {
1021 Pmsg0(-1, _("Got EOF on tape.\n"));
1027 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1028 recno, file, blk, be.bstrerror(dev->dev_errno));
1029 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1030 " set to variable blocking as normally used by Bacula.\n"
1031 " Please see the Tape Testing chapter in the manual and \n"
1032 " look for using mt with defblksize and setoptions\n"
1033 "If your tape drive block size is correct, then perhaps\n"
1034 " your SCSI driver is *really* stupid and does not\n"
1035 " correctly report the file:block after a FSF. In this\n"
1036 " case try setting:\n"
1037 " Fast Forward Space File = no\n"
1038 " in your Device resource.\n"));
1042 memset(rec->data, 0, rec->data_len);
1043 if (!read_record_from_block(dcr, block, rec)) {
1045 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1048 p = (int *)rec->data;
1049 for (j=0; j<len; j++) {
1050 if (p[j] != recno) {
1051 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1056 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1058 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1070 * This test writes some records, then writes an end of file,
1071 * rewinds the tape, moves to the end of the data and attepts
1072 * to append to the tape. This function is essential for
1073 * Bacula to be able to write multiple jobs to the tape.
1075 static int append_test()
1077 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1078 "This test is essential to Bacula.\n\n"
1079 "I'm going to write one record in file 0,\n"
1080 " two records in file 1,\n"
1081 " and three records in file 2\n\n"));
1085 weofcmd(); /* end file 0 */
1088 weofcmd(); /* end file 1 */
1092 weofcmd(); /* end file 2 */
1093 if (dev->has_cap(CAP_TWOEOF)) {
1096 dev->close(); /* release device */
1097 if (!open_the_device()) {
1101 Pmsg0(0, _("Now moving to end of medium.\n"));
1103 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1104 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1106 if (dev->file != 3) {
1110 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1113 if (dev->has_cap(CAP_TWOEOF)) {
1117 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1118 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1120 Pmsg0(-1, _("End scanning the tape.\n"));
1121 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1122 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1124 if (dev->file != 4) {
1132 * This test exercises the autochanger
1134 static int autochanger_test()
1136 POOLMEM *results, *changer;
1137 int slot, status, loaded;
1138 int timeout = dcr->device->max_changer_wait;
1141 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1142 if (!dev->has_cap(CAP_AUTOCHANGER)) {
1145 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1146 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1150 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1151 "To test the autochanger you must have a blank tape\n"
1152 " that I can write on in Slot 1.\n"));
1153 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1156 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1160 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1162 results = get_pool_memory(PM_MESSAGE);
1163 changer = get_pool_memory(PM_FNAME);
1167 dcr->VolCatInfo.Slot = slot;
1168 /* Find out what is loaded, zero means device is unloaded */
1169 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1170 changer = edit_device_codes(dcr, changer,
1171 dcr->device->changer_command, "loaded");
1172 status = run_program(changer, timeout, results);
1173 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1175 loaded = atoi(results);
1178 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1179 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1183 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1185 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1187 Dmsg1(100, "Results from loaded query=%s\n", results);
1189 dcr->VolCatInfo.Slot = loaded;
1190 /* We are going to load a new tape, so close the device */
1192 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1193 loaded, dev->drive_index);
1194 changer = edit_device_codes(dcr, changer,
1195 dcr->device->changer_command, "unload");
1196 status = run_program(changer, timeout, results);
1197 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1200 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1201 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1210 dcr->VolCatInfo.Slot = slot;
1211 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1212 slot, dev->drive_index);
1213 changer = edit_device_codes(dcr, changer,
1214 dcr->device->changer_command, "load");
1215 Dmsg1(100, "Changer=%s\n", changer);
1217 status = run_program(changer, timeout, results);
1219 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1220 slot, dev->drive_index);
1223 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1224 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1228 if (!open_the_device()) {
1232 * Start with sleep_time 0 then increment by 30 seconds if we get
1235 bmicrosleep(sleep_time, 0);
1236 if (!dev->rewind(dcr) || !dev->weof(1)) {
1237 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1239 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1240 "a longer sleep time in the mtx-script in the load) case.\n"
1241 "Adding a 30 second sleep and trying again ...\n"));
1245 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1248 if (!dev->weof(1)) {
1249 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1252 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1256 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1258 "to your mtx-changer script in the load) case.\n\n"),
1261 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1264 free_pool_memory(changer);
1265 free_pool_memory(results);
1270 free_pool_memory(changer);
1271 free_pool_memory(results);
1272 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1276 static void autochangercmd()
1283 * This test assumes that the append test has been done,
1284 * then it tests the fsf function.
1286 static int fsf_test()
1288 bool set_off = false;
1290 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1291 "This test is essential to Bacula.\n\n"
1292 "I'm going to write five files then test forward spacing\n\n"));
1296 weofcmd(); /* end file 0 */
1299 weofcmd(); /* end file 1 */
1303 weofcmd(); /* end file 2 */
1306 weofcmd(); /* end file 3 */
1308 weofcmd(); /* end file 4 */
1309 if (dev->has_cap(CAP_TWOEOF)) {
1315 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1317 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1320 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1321 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1323 if (dev->file != 1) {
1327 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1329 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1332 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1333 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1335 if (dev->file != 3) {
1340 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1342 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1345 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1346 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1348 if (dev->file != 4) {
1352 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1353 " Fast Forward Space File = no\n\n"
1354 "to your Device resource for this drive.\n"));
1358 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1360 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1362 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1363 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1364 if (dev->file != 5) {
1367 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1371 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1372 if (dev->has_cap(CAP_FASTFSF)) {
1373 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1374 "I am turning it off then retrying the test.\n"));
1375 dev->clear_cap(CAP_FASTFSF);
1379 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1380 "Some systems, e.g. OpenBSD, require you to set\n"
1381 " Use MTIOCGET= no\n"
1382 "in your device resource. Use with caution.\n"));
1391 * This is a general test of Bacula's functions
1392 * needed to read and write the tape.
1394 static void testcmd()
1398 if (!write_read_test()) {
1401 if (!position_test()) {
1405 stat = append_test();
1406 if (stat == 1) { /* OK get out */
1409 if (stat == -1) { /* first test failed */
1410 if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1411 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1412 "Setting \"Hardware End of Medium = no\n"
1413 " and \"Fast Forward Space File = no\n"
1414 "and retrying append test.\n\n"));
1415 dev->clear_cap(CAP_EOM); /* turn off eom */
1416 dev->clear_cap(CAP_FASTFSF); /* turn off fast fsf */
1417 stat = append_test();
1419 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1420 " Hardware End of Medium = No\n\n"
1421 " Fast Forward Space File = No\n"
1422 "to your Device resource in the Storage conf file.\n"));
1426 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1429 /* Wrong count after append */
1431 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1432 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1433 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1434 stat = append_test();
1436 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1437 " Hardware End of Medium = No\n"
1438 " Fast Forward Space File = No\n"
1439 " BSF at EOM = yes\n\n"
1440 "to your Device resource in the Storage conf file.\n"));
1447 Pmsg0(-1, _("\nAppend test failed.\n\n"
1448 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1449 "Unable to correct the problem. You MUST fix this\n"
1450 "problem before Bacula can use your tape drive correctly\n"
1451 "\nPerhaps running Bacula in fixed block mode will work.\n"
1452 "Do so by setting:\n\n"
1453 "Minimum Block Size = nnn\n"
1454 "Maximum Block Size = nnn\n\n"
1455 "in your Storage daemon's Device definition.\n"
1456 "nnn must match your tape driver's block size, which\n"
1457 "can be determined by reading your tape manufacturers\n"
1458 "information, and the information on your kernel dirver.\n"
1459 "Fixed block sizes, however, are not normally an ideal solution.\n"
1461 "Some systems, e.g. OpenBSD, require you to set\n"
1462 " Use MTIOCGET= no\n"
1463 "in your device resource. Use with caution.\n"));
1468 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1469 "Please double check it ...\n"
1470 "=== Sample correct output ===\n"
1471 "1 block of 64448 bytes in file 1\n"
1472 "End of File mark.\n"
1473 "2 blocks of 64448 bytes in file 2\n"
1474 "End of File mark.\n"
1475 "3 blocks of 64448 bytes in file 3\n"
1476 "End of File mark.\n"
1477 "1 block of 64448 bytes in file 4\n"
1478 "End of File mark.\n"
1479 "Total files=4, blocks=7, bytes = 451,136\n"
1480 "=== End sample correct output ===\n\n"
1481 "If the above scan output is not identical to the\n"
1482 "sample output, you MUST correct the problem\n"
1483 "or Bacula will not be able to write multiple Jobs to \n"
1487 re_read_block_test();
1490 fsf_test(); /* do fast forward space file test */
1492 autochanger_test(); /* do autochanger test */
1496 /* Forward space a file */
1497 static void fsfcmd()
1501 num = atoi(argk[1]);
1506 if (!dev->fsf(num)) {
1507 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1511 Pmsg0(0, _("Forward spaced 1 file.\n"));
1514 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1518 /* Forward space a record */
1519 static void fsrcmd()
1523 num = atoi(argk[1]);
1528 if (!dev->fsr(num)) {
1529 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1533 Pmsg0(0, _("Forward spaced 1 record.\n"));
1536 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1541 * Read a Bacula block from the tape
1545 dev->open(dcr, OPEN_READ_ONLY);
1546 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1550 * Write a Bacula block to the tape
1554 DEV_BLOCK *block = dcr->block;
1555 DEV_RECORD *rec = dcr->rec;
1558 if (!dev->is_open()) {
1561 sm_check(__FILE__, __LINE__, false);
1564 dump_block(block, "test");
1567 i = block->buf_len - 100;
1569 rec->data = check_pool_memory_size(rec->data, i);
1570 memset(rec->data, i & 0xFF, i);
1572 sm_check(__FILE__, __LINE__, false);
1573 if (!write_record_to_block(block, rec)) {
1574 Pmsg0(0, _("Error writing record to block.\n"));
1577 if (!write_block_to_dev(dcr)) {
1578 Pmsg0(0, _("Error writing block to device.\n"));
1581 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1583 Pmsg0(0, _("Wrote block to device.\n"));
1586 sm_check(__FILE__, __LINE__, false);
1587 sm_check(__FILE__, __LINE__, false);
1591 * Read a record from the tape
1598 if (!get_cmd(_("Enter length to read: "))) {
1602 if (len < 0 || len > 1000000) {
1603 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1606 buf = (char *)malloc(len);
1607 stat = read(dev->fd(), buf, len);
1608 if (stat > 0 && stat <= len) {
1612 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1613 len, stat, be.bstrerror());
1619 * Scan tape by reading block by block. Report what is
1620 * on the tape. Note, this command does raw reads, and as such
1621 * will not work with fixed block size devices.
1623 static void scancmd()
1626 int blocks, tot_blocks, tot_files;
1632 blocks = block_size = tot_blocks = 0;
1634 if (dev->state & ST_EOT) {
1635 Pmsg0(0, _("End of tape\n"));
1638 dev->update_pos(dcr);
1639 tot_files = dev->file;
1640 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1642 if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1645 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1646 dev->dev_name, be.bstrerror());
1647 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1650 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1653 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1658 Dmsg1(200, "read status = %d\n", stat);
1660 if (stat != block_size) {
1661 dev->update_pos(dcr);
1664 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1667 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1673 if (stat == 0) { /* EOF */
1674 dev->update_pos(dcr);
1675 printf(_("End of File mark.\n"));
1676 /* Two reads of zero means end of tape */
1677 if (dev->state & ST_EOF)
1678 dev->state |= ST_EOT;
1680 dev->state |= ST_EOF;
1683 if (dev->state & ST_EOT) {
1684 printf(_("End of tape\n"));
1687 } else { /* Got data */
1688 dev->state &= ~ST_EOF;
1694 dev->update_pos(dcr);
1695 tot_files = dev->file - tot_files;
1696 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1697 edit_uint64_with_commas(bytes, ec1));
1702 * Scan tape by reading Bacula block by block. Report what is
1703 * on the tape. This function reads Bacula blocks, so if your
1704 * Device resource is correctly defined, it should work with
1705 * either variable or fixed block sizes.
1707 static void scan_blocks()
1709 int blocks, tot_blocks, tot_files;
1710 uint32_t block_size;
1712 DEV_BLOCK *block = dcr->block;
1714 char buf1[100], buf2[100];
1716 blocks = block_size = tot_blocks = 0;
1720 dev->update_pos(dcr);
1721 tot_files = dev->file;
1723 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1724 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1725 if (dev->state & ST_EOT) {
1728 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1731 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1737 if (dev->state & ST_EOF) {
1740 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1743 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1747 printf(_("End of File mark.\n"));
1750 if (dev->state & ST_SHORT) {
1753 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1756 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1760 printf(_("Short block read.\n"));
1763 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1766 if (block->block_len != block_size) {
1769 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1772 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1776 block_size = block->block_len;
1780 bytes += block->block_len;
1781 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1782 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1783 block->VolSessionId, block->VolSessionTime);
1785 DEV_RECORD *rec = new_record();
1786 read_record_from_block(dcr, block, rec);
1787 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1788 block->BlockNumber, dev->block_num, block->block_len,
1789 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1790 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1793 } else if (verbose > 1) {
1794 dump_block(block, "");
1799 tot_files = dev->file - tot_files;
1800 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1801 edit_uint64_with_commas(bytes, ec1));
1805 static void statcmd()
1807 int debug = debug_level;
1809 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1811 dump_volume_label(dev);
1813 debug_level = debug;
1818 * First we label the tape, then we fill
1819 * it with data get a new tape and write a few blocks.
1821 static void fillcmd()
1824 DEV_BLOCK *block = dcr->block;
1826 char buf1[100], buf2[100];
1829 uint32_t min_block_size;
1840 "This command simulates Bacula writing to a tape.\n"
1841 "It requires either one or two blank tapes, which it\n"
1842 "will label and write.\n\n"
1843 "If you have an autochanger configured, it will use\n"
1844 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1845 "be prompted to insert the tapes when necessary.\n\n"
1846 "It will print a status approximately\n"
1847 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1848 "selected the simple test option, after writing the first tape\n"
1849 "it will rewind it and re-read the last block written.\n\n"
1850 "If you have selected the multiple tape test, when the first tape\n"
1851 "fills, it will ask for a second, and after writing a few more \n"
1852 "blocks, it will stop. Then it will begin re-reading the\n"
1854 "This may take a long time -- hours! ...\n\n"));
1856 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1857 "or the complete multiple tape (m) test: (s/m) "));
1858 if (cmd[0] == 's') {
1859 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1861 } else if (cmd[0] == 'm') {
1862 Pmsg0(-1, _("Multiple tape test selected.\n"));
1865 Pmsg0(000, _("Command aborted.\n"));
1869 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1870 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1872 /* Use fixed block size to simplify read back */
1873 min_block_size = dev->min_block_size;
1874 dev->min_block_size = dev->max_block_size;
1875 set_volume_name("TestVolume1", 1);
1876 dir_ask_sysop_to_create_appendable_volume(dcr);
1877 dev->set_append(); /* force volume to be relabeled */
1880 * Acquire output device for writing. Note, after acquiring a
1881 * device, we MUST release it, which is done at the end of this
1884 Dmsg0(100, "just before acquire_device\n");
1885 if (!acquire_device_for_append(dcr)) {
1886 set_jcr_job_status(jcr, JS_ErrorTerminated);
1889 block = jcr->dcr->block;
1891 Dmsg0(100, "Just after acquire_device_for_append\n");
1893 * Write Begin Session Record
1895 if (!write_session_label(dcr, SOS_LABEL)) {
1896 set_jcr_job_status(jcr, JS_ErrorTerminated);
1897 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1901 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1903 memset(&rec, 0, sizeof(rec));
1904 rec.data = get_memory(100000); /* max record size */
1906 #define REC_SIZE 32768
1907 rec.data_len = REC_SIZE;
1910 * Put some random data in the record
1912 fd = open("/dev/urandom", O_RDONLY);
1914 read(fd, rec.data, rec.data_len);
1917 uint32_t *p = (uint32_t *)rec.data;
1918 srandom(time(NULL));
1919 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1925 * Generate data as if from File daemon, write to device
1927 jcr->dcr->VolFirstIndex = 0;
1928 time(&jcr->run_time); /* start counting time for rates */
1929 (void)localtime_r(&jcr->run_time, &tm);
1930 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1932 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1934 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1936 for (file_index = 0; ok && !job_canceled(jcr); ) {
1937 rec.VolSessionId = jcr->VolSessionId;
1938 rec.VolSessionTime = jcr->VolSessionTime;
1939 rec.FileIndex = ++file_index;
1940 rec.Stream = STREAM_FILE_DATA;
1942 /* Mix up the data just a bit */
1943 uint32_t *lp = (uint32_t *)rec.data;
1945 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1949 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1950 rec.FileIndex, rec.VolSessionId,
1951 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1954 while (!write_record_to_block(block, &rec)) {
1956 * When we get here we have just filled a block
1958 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1961 /* Write block to tape */
1962 if (!flush_block(block, 1)) {
1966 /* Every 5000 blocks (approx 322MB) report where we are.
1968 if ((block->BlockNumber % 5000) == 0) {
1970 now -= jcr->run_time;
1972 now = 1; /* prevent divide error */
1974 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1975 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1976 block->BlockNumber, dev->block_num,
1977 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1979 /* Every 32000 blocks (approx 2GB) write an EOF.
1981 if ((block->BlockNumber % 32000) == 0) {
1983 (void)localtime_r(&now, &tm);
1984 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1985 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1986 flush_block(block, 0);
1990 /* Get out after writing 10 blocks to the second tape */
1991 if (++BlockNumber > 10 && stop != 0) { /* get out */
1996 Pmsg0(000, _("Not OK\n"));
1999 jcr->JobBytes += rec.data_len; /* increment bytes this job */
2000 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
2001 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
2002 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
2004 /* Get out after writing 10 blocks to the second tape */
2005 if (BlockNumber > 10 && stop != 0) { /* get out */
2007 Pmsg1(-1, "Done writing %s records ...\n",
2008 edit_uint64_with_commas(write_count, ed1));
2013 Dmsg0(100, "Write_end_session_label()\n");
2014 /* Create Job status for end of session label */
2015 if (!job_canceled(jcr) && ok) {
2016 set_jcr_job_status(jcr, JS_Terminated);
2018 set_jcr_job_status(jcr, JS_ErrorTerminated);
2020 if (!write_session_label(dcr, EOS_LABEL)) {
2021 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2024 /* Write out final block of this session */
2025 if (!write_block_to_device(dcr)) {
2026 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2029 Pmsg0(-1, _("Wrote End of Session label.\n"));
2031 /* Save last block info for second tape */
2032 last_block_num2 = last_block_num;
2033 last_file2 = last_file;
2035 free_block(last_block2);
2037 last_block2 = dup_block(last_block);
2040 sprintf(buf, "%s/btape.state", working_directory);
2041 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2043 write(fd, &btape_state_level, sizeof(btape_state_level));
2044 write(fd, &simple, sizeof(simple));
2045 write(fd, &last_block_num1, sizeof(last_block_num1));
2046 write(fd, &last_block_num2, sizeof(last_block_num2));
2047 write(fd, &last_file1, sizeof(last_file1));
2048 write(fd, &last_file2, sizeof(last_file2));
2049 write(fd, last_block1->buf, last_block1->buf_len);
2050 write(fd, last_block2->buf, last_block2->buf_len);
2051 write(fd, first_block->buf, first_block->buf_len);
2053 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2054 last_block_num1, last_block_num2);
2057 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2062 (void)localtime_r(&now, &tm);
2063 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2065 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2066 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2069 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2070 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2073 jcr->dcr->block = block;
2076 dev->min_block_size = min_block_size;
2077 free_memory(rec.data);
2081 * Read two tapes written by the "fill" command and ensure
2082 * that the data is valid. If stop==1 we simulate full read back
2083 * of two tapes. If stop==-1 we simply read the last block and
2084 * verify that it is correct.
2086 static void unfillcmd()
2090 last_block1 = new_block(dev);
2091 last_block2 = new_block(dev);
2092 first_block = new_block(dev);
2093 sprintf(buf, "%s/btape.state", working_directory);
2094 fd = open(buf, O_RDONLY);
2096 uint32_t state_level;
2097 read(fd, &state_level, sizeof(btape_state_level));
2098 read(fd, &simple, sizeof(simple));
2099 read(fd, &last_block_num1, sizeof(last_block_num1));
2100 read(fd, &last_block_num2, sizeof(last_block_num2));
2101 read(fd, &last_file1, sizeof(last_file1));
2102 read(fd, &last_file2, sizeof(last_file2));
2103 read(fd, last_block1->buf, last_block1->buf_len);
2104 read(fd, last_block2->buf, last_block2->buf_len);
2105 read(fd, first_block->buf, first_block->buf_len);
2107 if (state_level != btape_state_level) {
2108 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2109 "the fill command.\n"));
2114 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2115 "You must redo the fill command.\n"), buf, be.bstrerror());
2122 static void do_unfill()
2124 DEV_BLOCK *block = dcr->block;
2131 Dmsg0(20, "Enter do_unfill\n");
2132 dev->set_cap(CAP_ANONVOLS); /* allow reading any volume */
2133 dev->clear_cap(CAP_LABEL); /* don't label anything here */
2137 time(&jcr->run_time); /* start counting time for rates */
2141 free_block(last_block);
2144 last_block_num = last_block_num1;
2145 last_file = last_file1;
2146 last_block = last_block1;
2148 free_restore_volume_list(jcr);
2150 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2151 create_restore_volume_list(jcr);
2152 if (jcr->VolList != NULL) {
2153 jcr->VolList->Slot = 1;
2154 if (jcr->VolList->next != NULL) {
2155 jcr->VolList->next->Slot = 2;
2159 set_volume_name("TestVolume1", 1);
2162 /* Multiple Volume tape */
2163 /* Close device so user can use autochanger if desired */
2164 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2167 autochanger = autoload_device(dcr, 1, NULL);
2168 if (autochanger != 1) {
2170 get_cmd(_("Mount first tape. Press enter when ready: "));
2175 dev->num_writers = 0;
2176 if (!acquire_device_for_read(dcr)) {
2177 Pmsg1(-1, "%s", dev->errmsg);
2181 * We now have the first tape mounted.
2182 * Note, re-reading last block may have caused us to
2183 * loose track of where we are (block number unknown).
2185 Pmsg0(-1, _("Rewinding.\n"));
2186 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2189 /* Read the first 10000 records */
2190 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2191 dev->file, dev->block_num);
2193 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2194 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2195 last_file, last_block_num);
2196 if (!dev->reposition(dcr, last_file, last_block_num)) {
2197 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2200 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2201 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2202 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2205 if (compare_blocks(last_block, block)) {
2207 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2209 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2216 /* restore info for last block on second Volume */
2217 last_block_num = last_block_num2;
2218 last_file = last_file2;
2219 last_block = last_block2;
2221 /* Multiple Volume tape */
2222 /* Close device so user can use autochanger if desired */
2223 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2227 set_volume_name("TestVolume2", 2);
2229 autochanger = autoload_device(dcr, 1, NULL);
2230 if (autochanger != 1) {
2232 get_cmd(_("Mount second tape. Press enter when ready: "));
2236 if (!acquire_device_for_read(dcr)) {
2237 Pmsg1(-1, "%s", dev->errmsg);
2241 /* Space to "first" block which is last block not written
2242 * on the previous tape.
2244 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2245 if (!dev->reposition(dcr, 0, 1)) {
2246 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2249 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2250 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2251 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2254 if (compare_blocks(first_block, block)) {
2255 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2258 /* Now find and compare the last block */
2259 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2260 last_file, last_block_num);
2261 if (!dev->reposition(dcr, last_file, last_block_num)) {
2262 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2265 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2266 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2267 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2270 if (compare_blocks(last_block, block)) {
2271 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2275 free_block(last_block1);
2276 free_block(last_block2);
2277 free_block(first_block);
2280 /* Read 10000 records then stop */
2281 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2283 DEVICE *dev = dcr->dev;
2285 if (quickie_count == 10000) {
2286 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2288 return quickie_count < 10000;
2291 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2294 uint32_t CheckSum, block_len;
2297 p = last_block->buf;
2299 unser_begin(q, BLKHDR2_LENGTH);
2300 unser_uint32(CheckSum);
2301 unser_uint32(block_len);
2302 while (q < (block->buf+block_len)) {
2309 dump_block(last_block, _("Last block written"));
2311 dump_block(block, _("Block read back"));
2312 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2313 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2314 "that was read back differ. The test FAILED !!!!\n"
2315 "This must be corrected before you use Bacula\n"
2316 "to write multi-tape Volumes.!!!!\n"));
2320 dump_block(last_block, _("Last block written"));
2321 dump_block(block, _("Block read back"));
2331 * Write current block to tape regardless of whether or
2332 * not it is full. If the tape fills, attempt to
2333 * acquire another tape.
2335 static int flush_block(DEV_BLOCK *block, int dump)
2339 uint32_t this_file, this_block_num;
2343 this_block = new_block(dev);
2346 last_block = new_block(dev);
2349 this_file = dev->file;
2350 this_block_num = dev->block_num;
2351 if (!write_block_to_dev(dcr)) {
2352 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2353 last_file, last_block_num, this_block_num);
2356 * This is 1st tape, so save first tape info separate
2357 * from second tape info
2359 last_block_num1 = last_block_num;
2360 last_file1 = last_file;
2361 last_block1 = dup_block(last_block);
2362 last_block2 = dup_block(last_block);
2363 first_block = dup_block(block); /* first block second tape */
2366 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2367 (unsigned)file_index, block->BlockNumber, block->block_len);
2368 dump_block(last_block, _("Last block written"));
2370 dump_block(block, _("Block not written"));
2373 eot_block = block->BlockNumber;
2374 eot_block_len = block->block_len;
2375 eot_FileIndex = file_index;
2379 now -= jcr->run_time;
2381 now = 1; /* don't divide by zero */
2383 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2384 vol_size = dev->VolCatInfo.VolCatBytes;
2385 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2386 dev->file, dev->block_num,
2387 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2390 stop = -1; /* stop, but do simplified test */
2392 /* Full test in progress */
2393 if (!fixup_device_block_write_error(jcr->dcr)) {
2394 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2399 BlockNumber = 0; /* start counting for second tape */
2402 return 1; /* end of tape reached */
2405 /* Save contents after write so that the header is serialized */
2406 memcpy(this_block->buf, block->buf, this_block->buf_len);
2409 * Note, we always read/write to block, but we toggle
2410 * copying it to one or another of two allocated blocks.
2411 * Switch blocks so that the block just successfully written is
2412 * always in last_block.
2414 tblock = last_block;
2415 last_block = this_block;
2416 this_block = tblock;
2417 last_file = this_file;
2418 last_block_num = this_block_num;
2426 * First we label the tape, then we fill
2427 * it with data get a new tape and write a few blocks.
2429 static void qfillcmd()
2431 DEV_BLOCK *block = dcr->block;
2432 DEV_RECORD *rec = dcr->rec;
2435 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2437 get_cmd(_("How many blocks do you want to write? (1000): "));
2444 sm_check(__FILE__, __LINE__, false);
2446 i = block->buf_len - 100;
2448 rec->data = check_pool_memory_size(rec->data, i);
2449 memset(rec->data, i & 0xFF, i);
2452 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2453 for (i=0; i < count; i++) {
2458 if (!write_record_to_block(block, rec)) {
2459 Pmsg0(0, _("Error writing record to block.\n"));
2462 if (!write_block_to_dev(dcr)) {
2463 Pmsg0(0, _("Error writing block to device.\n"));
2469 if (dev->has_cap(CAP_TWOEOF)) {
2476 sm_check(__FILE__, __LINE__, false);
2480 * Fill a tape using raw write() command
2482 static void rawfill_cmd()
2484 DEV_BLOCK *block = dcr->block;
2487 uint32_t block_num = 0;
2492 fd = open("/dev/urandom", O_RDONLY);
2494 read(fd, block->buf, block->buf_len);
2497 uint32_t *p = (uint32_t *)block->buf;
2498 srandom(time(NULL));
2499 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2503 p = (uint32_t *)block->buf;
2504 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2507 if (dev->is_tape()) {
2508 stat = tape_write(dev->fd(), block->buf, block->buf_len);
2510 stat = write(dev->fd(), block->buf, block->buf_len);
2512 if (stat == (int)block->buf_len) {
2513 if ((block_num++ % 100) == 0) {
2518 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2528 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2529 be.bstrerror(my_errno));
2535 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2536 static struct cmdstruct commands[] = {
2537 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2538 {NT_("bsf"), bsfcmd, _("backspace file")},
2539 {NT_("bsr"), bsrcmd, _("backspace record")},
2540 {NT_("cap"), capcmd, _("list device capabilities")},
2541 {NT_("clear"), clearcmd, _("clear tape errors")},
2542 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2543 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2544 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2545 {NT_("unfill"), unfillcmd, _("read filled tape")},
2546 {NT_("fsf"), fsfcmd, _("forward space a file")},
2547 {NT_("fsr"), fsrcmd, _("forward space a record")},
2548 {NT_("help"), helpcmd, _("print this command")},
2549 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2550 {NT_("load"), loadcmd, _("load a tape")},
2551 {NT_("quit"), quitcmd, _("quit btape")},
2552 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2553 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2554 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2555 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2556 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2557 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2558 {NT_("status"), statcmd, _("print tape status")},
2559 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2560 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2561 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2562 {NT_("rr"), rrcmd, _("read a single record")},
2563 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2564 {NT_("qfill"), qfillcmd, _("quick fill command")}
2566 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2574 while (!quit && get_cmd("*")) {
2575 sm_check(__FILE__, __LINE__, false);
2577 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2578 for (i=0; i<comsize; i++) /* search for command */
2579 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2580 (*commands[i].func)(); /* go execute command */
2585 Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2590 static void helpcmd()
2594 printf(_("Interactive commands:\n"));
2595 printf(_(" Command Description\n ======= ===========\n"));
2596 for (i=0; i<comsize; i++)
2597 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2605 "\nVersion: %s (%s)\n\n"
2606 "Usage: btape <options> <device_name>\n"
2607 " -b <file> specify bootstrap file\n"
2608 " -c <file> set configuration file to file\n"
2609 " -d <nn> set debug level to <nn>\n"
2610 " -dt print timestamp in debug output\n"
2611 " -p proceed inspite of I/O errors\n"
2612 " -s turn off signals\n"
2614 " -? print this message.\n"
2615 "\n"), 2000, VERSION, BDATE);
2620 * Get next input command from terminal. This
2621 * routine is REALLY primitive, and should be enhanced
2622 * to have correct backspacing, etc.
2625 get_cmd(const char *prompt)
2629 fprintf(stdout, prompt);
2631 /* We really should turn off echoing and pretty this
2635 while ((ch = fgetc(stdin)) != EOF) {
2637 strip_trailing_junk(cmd);
2639 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2652 /* Dummies to replace askdir.c */
2653 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2654 bool dir_send_job_status(JCR *jcr) {return 1;}
2656 bool dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten)
2662 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2664 Dmsg0(20, "Enter dir_get_volume_info\n");
2665 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2669 bool dir_create_jobmedia_record(DCR *dcr)
2671 dcr->WroteVol = false;
2676 bool dir_find_next_appendable_volume(DCR *dcr)
2678 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2679 return dcr->VolumeName[0] != 0;
2682 bool dir_ask_sysop_to_mount_volume(DCR *dcr, int /* mode */)
2684 DEVICE *dev = dcr->dev;
2685 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2686 if (dcr->VolumeName[0] == 0) {
2687 return dir_ask_sysop_to_create_appendable_volume(dcr);
2689 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2690 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2691 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2694 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2695 dcr->VolumeName, dev->print_name());
2702 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2705 DEVICE *dev = dcr->dev;
2706 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2708 set_volume_name("TestVolume1", 1);
2710 set_volume_name("TestVolume2", 2);
2712 /* Close device so user can use autochanger if desired */
2713 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2716 autochanger = autoload_device(dcr, 1, NULL);
2717 if (autochanger != 1) {
2718 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2729 static bool my_mount_next_read_volume(DCR *dcr)
2732 JCR *jcr = dcr->jcr;
2733 DEV_BLOCK *block = dcr->block;
2735 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2736 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2739 volume_unused(dcr); /* release current volume */
2740 if (LastBlock != block->BlockNumber) {
2741 VolBytes += block->block_len;
2743 LastBlock = block->BlockNumber;
2745 now -= jcr->run_time;
2749 kbs = (double)VolBytes / (1000.0 * (double)now);
2750 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2751 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2753 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2758 set_volume_name("TestVolume2", 2);
2761 if (!acquire_device_for_read(dcr)) {
2762 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2765 return true; /* next volume mounted */
2768 static void set_volume_name(const char *VolName, int volnum)
2770 DCR *dcr = jcr->dcr;
2771 VolumeName = VolName;
2773 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2774 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2775 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2776 dcr->VolCatInfo.Slot = volnum;
2777 dcr->VolCatInfo.InChanger = true;