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.
48 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
50 /* External subroutines */
51 extern void free_config_resources();
53 /* Exported variables */
56 int bsize = TAPE_BSIZE;
57 char VolName[MAX_NAME_LENGTH];
58 STORES *me = NULL; /* our Global resource */
59 bool forge_on = false; /* proceed inspite of I/O errors */
60 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
61 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
64 * If you change the format of the state file,
65 * increment this value
67 static uint32_t btape_state_level = 2;
71 DEVRES *device = NULL;
74 /* Forward referenced subroutines */
75 static void do_tape_cmds();
76 static void helpcmd();
77 static void scancmd();
78 static void rewindcmd();
79 static void clearcmd();
84 static void fillcmd();
85 static void qfillcmd();
86 static void statcmd();
87 static void unfillcmd();
88 static int flush_block(DEV_BLOCK *block, int dump);
89 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
90 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
91 static bool my_mount_next_read_volume(DCR *dcr);
92 static void scan_blocks();
93 static void set_volume_name(const char *VolName, int volnum);
94 static void rawfill_cmd();
95 static bool open_the_device();
96 static void autochangercmd();
97 static void do_unfill();
100 /* Static variables */
101 #define CONFIG_FILE "bacula-sd.conf"
102 char *configfile = NULL;
104 #define MAX_CMD_ARGS 30
106 static POOLMEM *args;
107 static char *argk[MAX_CMD_ARGS];
108 static char *argv[MAX_CMD_ARGS];
111 static int quickie_count = 0;
112 static uint64_t write_count = 0;
113 static BSR *bsr = NULL;
114 static int signals = TRUE;
117 static uint64_t vol_size;
118 static uint64_t VolBytes;
121 static int32_t file_index;
122 static int end_of_tape = 0;
123 static uint32_t LastBlock = 0;
124 static uint32_t eot_block;
125 static uint32_t eot_block_len;
126 static uint32_t eot_FileIndex;
127 static int dumped = 0;
128 static DEV_BLOCK *last_block1 = NULL;
129 static DEV_BLOCK *last_block2 = NULL;
130 static DEV_BLOCK *last_block = NULL;
131 static DEV_BLOCK *this_block = NULL;
132 static DEV_BLOCK *first_block = NULL;
133 static uint32_t last_file1 = 0;
134 static uint32_t last_file2 = 0;
135 static uint32_t last_file = 0;
136 static uint32_t last_block_num1 = 0;
137 static uint32_t last_block_num2 = 0;
138 static uint32_t last_block_num = 0;
139 static uint32_t BlockNumber = 0;
140 static bool simple = true;
142 static const char *VolumeName = NULL;
143 static int vol_num = 0;
145 static JCR *jcr = NULL;
149 static void terminate_btape(int sig);
150 int get_cmd(const char *prompt);
153 /*********************************************************************
155 * Bacula tape testing program
158 int main(int margc, char *margv[])
165 setlocale(LC_ALL, "");
166 bindtextdomain("bacula", LOCALEDIR);
167 textdomain("bacula");
171 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
172 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
173 TAPE_BSIZE, B_DEV_BSIZE);
175 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
176 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
178 if (sizeof(boffset_t) < 8) {
179 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. boffset_t=%d should be 8 or more !!!!!\n\n\n"),
183 bsnprintf(buf, sizeof(buf), "%u", x32);
184 i = bsscanf(buf, "%lu", &y32);
185 if (i != 1 || x32 != y32) {
186 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
192 bsnprintf(buf, sizeof(buf), "%" llu, x64);
193 i = bsscanf(buf, "%llu", &y64);
194 if (i != 1 || x64 != y64) {
195 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
200 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
202 working_directory = "/tmp";
203 my_name_is(margc, margv, "btape");
204 init_msg(NULL, NULL);
208 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
210 case 'b': /* bootstrap file */
211 bsr = parse_bsr(NULL, optarg);
212 // dump_bsr(bsr, true);
215 case 'c': /* specify config file */
216 if (configfile != NULL) {
219 configfile = bstrdup(optarg);
222 case 'd': /* set debug level */
223 if (*optarg == 't') {
224 dbg_timestamp = true;
226 debug_level = atoi(optarg);
227 if (debug_level <= 0) {
255 cmd = get_pool_memory(PM_FNAME);
256 args = get_pool_memory(PM_FNAME);
259 init_signals(terminate_btape);
262 if (configfile == NULL) {
263 configfile = bstrdup(CONFIG_FILE);
266 daemon_start_time = time(NULL);
268 parse_config(configfile);
271 /* See if we can open a device */
273 Pmsg0(000, _("No archive name specified.\n"));
276 } else if (margc != 1) {
277 Pmsg0(000, _("Improper number of arguments specified.\n"));
282 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
291 Pmsg0(000, _("btape does not work with DVD storage.\n"));
295 if (!dev->is_tape()) {
296 Pmsg0(000, _("btape only works with tape storage.\n"));
301 if (!open_the_device()) {
305 Dmsg0(200, "Do tape commands\n");
313 static void terminate_btape(int stat)
316 sm_check(__FILE__, __LINE__, false);
320 free_config_resources();
322 free_pool_memory(args);
326 free_pool_memory(cmd);
343 if (debug_level > 10)
344 print_memory_pool_stats();
347 free_block(this_block);
352 close_memory_pool(); /* free memory in pool */
353 term_last_jobs_list();
359 static bool open_the_device()
364 block = new_block(dev);
366 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
367 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
368 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
372 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
373 dev->set_append(); /* put volume in append mode */
388 * Write a label to the tape
390 static void labelcmd()
393 pm_strcpy(cmd, VolumeName);
395 if (!get_cmd(_("Enter Volume Name: "))) {
400 if (!dev->is_open()) {
401 if (!first_open_device(dcr)) {
402 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
407 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
408 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
412 * Read the tape label
414 static void readlabelcmd()
416 int save_debug_level = debug_level;
419 stat = read_dev_volume_label(dcr);
422 Pmsg0(0, _("Volume has no label.\n"));
425 Pmsg0(0, _("Volume label read correctly.\n"));
428 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
431 Pmsg0(0, _("Volume name error\n"));
433 case VOL_CREATE_ERROR:
434 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
436 case VOL_VERSION_ERROR:
437 Pmsg0(0, _("Volume version error.\n"));
439 case VOL_LABEL_ERROR:
440 Pmsg0(0, _("Bad Volume label type.\n"));
443 Pmsg0(0, _("Unknown error.\n"));
448 dump_volume_label(dev);
449 debug_level = save_debug_level;
454 * Load the tape should have prevously been taken
455 * off line, otherwise this command is not necessary.
457 static void loadcmd()
460 if (!load_dev(dev)) {
461 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
463 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
469 static void rewindcmd()
471 if (!dev->rewind(dcr)) {
472 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
475 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
480 * Clear any tape error
482 static void clearcmd()
488 * Write and end of file on the tape
490 static void weofcmd()
500 if (!dev->weof(num)) {
501 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
505 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
508 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
514 /* Go to the end of the medium -- raw command
515 * The idea was orginally that the end of the Bacula
516 * medium would be flagged differently. This is not
517 * currently the case. So, this is identical to the
522 if (!dev->eod(dcr)) {
523 Pmsg1(0, "%s", dev->bstrerror());
526 Pmsg0(0, _("Moved to end of medium.\n"));
531 * Go to the end of the medium (either hardware determined
532 * or defined by two eofs.
552 if (!dev->bsf(num)) {
553 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
555 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
571 if (!dev->bsr(num)) {
572 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
574 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
579 * List device capabilities as defined in the
584 printf(_("Configured device capabilities:\n"));
585 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
586 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
587 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
588 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
589 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
590 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
591 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
592 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
593 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
594 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
595 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
596 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
597 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
598 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
599 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
602 printf(_("Device status:\n"));
603 printf("%sOPENED ", dev->is_open() ? "" : "!");
604 printf("%sTAPE ", dev->is_tape() ? "" : "!");
605 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
606 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
607 printf("%sAPPEND ", dev->can_append() ? "" : "!");
608 printf("%sREAD ", dev->can_read() ? "" : "!");
609 printf("%sEOT ", dev->at_eot() ? "" : "!");
610 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
611 printf("%sEOF ", dev->at_eof() ? "" : "!");
612 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
613 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
616 printf(_("Device parameters:\n"));
617 printf("Device name: %s\n", dev->dev_name);
618 printf("File=%u block=%u\n", dev->file, dev->block_num);
619 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
621 printf(_("Status:\n"));
627 * Test writting larger and larger records.
628 * This is a torture test for records.
630 static void rectestcmd()
636 Pmsg0(0, _("Test writting larger and larger records.\n"
637 "This is a torture test for records.\nI am going to write\n"
638 "larger and larger records. It will stop when the record size\n"
639 "plus the header exceeds the block size (by default about 64K)\n"));
642 get_cmd(_("Do you want to continue? (y/n): "));
644 Pmsg0(000, _("Command aborted.\n"));
648 sm_check(__FILE__, __LINE__, false);
649 block = new_block(dev);
652 for (i=1; i<500000; i++) {
653 rec->data = check_pool_memory_size(rec->data, i);
654 memset(rec->data, i & 0xFF, i);
656 sm_check(__FILE__, __LINE__, false);
657 if (write_record_to_block(block, rec)) {
660 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
664 sm_check(__FILE__, __LINE__, false);
668 sm_check(__FILE__, __LINE__, false);
672 * This test attempts to re-read a block written by Bacula
673 * normally at the end of the tape. Bacula will then back up
674 * over the two eof marks, backup over the record and reread
675 * it to make sure it is valid. Bacula can skip this validation
676 * if you set "Backward space record = no"
678 static int re_read_block_test()
680 DEV_BLOCK *block = dcr->block;
685 if (!(dev->capabilities & CAP_BSR)) {
686 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
690 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
691 "I'm going to write three records and an EOF\n"
692 "then backup over the EOF and re-read the last record.\n"
693 "Bacula does this after writing the last block on the\n"
694 "tape to verify that the block was written correctly.\n\n"
695 "This is not an *essential* feature ...\n\n"));
699 rec->data = check_pool_memory_size(rec->data, block->buf_len);
700 len = rec->data_len = block->buf_len-100;
701 memset(rec->data, 1, rec->data_len);
702 if (!write_record_to_block(block, rec)) {
703 Pmsg0(0, _("Error writing record to block.\n"));
706 if (!write_block_to_dev(dcr)) {
707 Pmsg0(0, _("Error writing block to device.\n"));
710 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
712 memset(rec->data, 2, rec->data_len);
713 if (!write_record_to_block(block, rec)) {
714 Pmsg0(0, _("Error writing record to block.\n"));
717 if (!write_block_to_dev(dcr)) {
718 Pmsg0(0, _("Error writing block to device.\n"));
721 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
723 memset(rec->data, 3, rec->data_len);
724 if (!write_record_to_block(block, rec)) {
725 Pmsg0(0, _("Error writing record to block.\n"));
728 if (!write_block_to_dev(dcr)) {
729 Pmsg0(0, _("Error writing block to device.\n"));
732 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
735 if (dev->has_cap(CAP_TWOEOF)) {
739 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
742 if (dev->has_cap(CAP_TWOEOF)) {
744 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
748 Pmsg0(0, _("Backspaced over EOF OK.\n"));
750 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
753 Pmsg0(0, _("Backspace record OK.\n"));
754 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
756 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
759 memset(rec->data, 0, rec->data_len);
760 if (!read_record_from_block(dcr, block, rec)) {
762 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
765 for (int i=0; i<len; i++) {
766 if (rec->data[i] != 3) {
767 Pmsg0(0, _("Bad data in record. Test failed!\n"));
771 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
772 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
779 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
780 "this function to verify the last block written to the\n"
781 "tape. Bacula will skip the last block verification\n"
783 "Backward Space Record = No\n\n"
784 "to your Storage daemon's Device resource definition.\n"));
791 * This test writes Bacula blocks to the tape in
792 * several files. It then rewinds the tape and attepts
793 * to read these blocks back checking the data.
795 static int write_read_test()
803 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
804 "I'm going to write 1000 records and an EOF\n"
805 "then write 1000 records and an EOF, then rewind,\n"
806 "and re-read the data to verify that it is correct.\n\n"
807 "This is an *essential* feature ...\n\n"));
810 if (!dev->rewind(dcr)) {
811 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
814 rec->data = check_pool_memory_size(rec->data, block->buf_len);
815 rec->data_len = block->buf_len-100;
816 len = rec->data_len/sizeof(i);
817 for (i=1; i<=1000; i++) {
818 p = (int *)rec->data;
819 for (j=0; j<len; j++) {
822 if (!write_record_to_block(block, rec)) {
823 Pmsg0(0, _("Error writing record to block.\n"));
826 if (!write_block_to_dev(dcr)) {
827 Pmsg0(0, _("Error writing block to device.\n"));
831 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
833 for (i=1001; i<=2000; i++) {
834 p = (int *)rec->data;
835 for (j=0; j<len; j++) {
838 if (!write_record_to_block(block, rec)) {
839 Pmsg0(0, _("Error writing record to block.\n"));
842 if (!write_block_to_dev(dcr)) {
843 Pmsg0(0, _("Error writing block to device.\n"));
847 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
849 if (dev->has_cap(CAP_TWOEOF)) {
852 if (!dev->rewind(dcr)) {
853 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
856 Pmsg0(0, _("Rewind OK.\n"));
858 for (i=1; i<=2000; i++) {
860 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
862 if (dev_state(dev, ST_EOF)) {
863 Pmsg0(-1, _("Got EOF on tape.\n"));
868 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
871 memset(rec->data, 0, rec->data_len);
872 if (!read_record_from_block(dcr, block, rec)) {
874 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
877 p = (int *)rec->data;
878 for (j=0; j<len; j++) {
880 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
886 if (i == 1000 || i == 2000) {
887 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
890 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
899 * This test writes Bacula blocks to the tape in
900 * several files. It then rewinds the tape and attepts
901 * to read these blocks back checking the data.
903 static int position_test()
905 DEV_BLOCK *block = dcr->block;
911 int file = 0, blk = 0;
913 bool got_eof = false;
915 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
916 "I'm going to write 1000 records and an EOF\n"
917 "then write 1000 records and an EOF, then rewind,\n"
918 "and position to a few blocks and verify that it is correct.\n\n"
919 "This is an *essential* feature ...\n\n"));
922 if (!dev->rewind(dcr)) {
923 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
926 rec->data = check_pool_memory_size(rec->data, block->buf_len);
927 rec->data_len = block->buf_len-100;
928 len = rec->data_len/sizeof(i);
929 for (i=1; i<=1000; i++) {
930 p = (int *)rec->data;
931 for (j=0; j<len; j++) {
934 if (!write_record_to_block(block, rec)) {
935 Pmsg0(0, _("Error writing record to block.\n"));
938 if (!write_block_to_dev(dcr)) {
939 Pmsg0(0, _("Error writing block to device.\n"));
943 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
945 for (i=1001; i<=2000; i++) {
946 p = (int *)rec->data;
947 for (j=0; j<len; j++) {
950 if (!write_record_to_block(block, rec)) {
951 Pmsg0(0, _("Error writing record to block.\n"));
954 if (!write_block_to_dev(dcr)) {
955 Pmsg0(0, _("Error writing block to device.\n"));
959 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
961 if (dev->has_cap(CAP_TWOEOF)) {
964 if (!dev->rewind(dcr)) {
965 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
968 Pmsg0(0, _("Rewind OK.\n"));
972 /* Set up next item to read based on where we are */
1008 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1009 if (!dev->reposition(dcr, file, blk)) {
1010 Pmsg0(0, _("Reposition error.\n"));
1014 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1016 if (dev_state(dev, ST_EOF)) {
1017 Pmsg0(-1, _("Got EOF on tape.\n"));
1023 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1024 recno, file, blk, be.bstrerror(dev->dev_errno));
1025 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1026 " set to variable blocking as normally used by Bacula.\n"
1027 " Please see the Tape Testing chapter in the manual and \n"
1028 " look for using mt with defblksize and setoptions\n"
1029 "If your tape drive block size is correct, then perhaps\n"
1030 " your SCSI driver is *really* stupid and does not\n"
1031 " correctly report the file:block after a FSF. In this\n"
1032 " case try setting:\n"
1033 " Fast Forward Space File = no\n"
1034 " in your Device resource.\n"));
1038 memset(rec->data, 0, rec->data_len);
1039 if (!read_record_from_block(dcr, block, rec)) {
1041 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1044 p = (int *)rec->data;
1045 for (j=0; j<len; j++) {
1046 if (p[j] != recno) {
1047 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1052 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1054 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1066 * This test writes some records, then writes an end of file,
1067 * rewinds the tape, moves to the end of the data and attepts
1068 * to append to the tape. This function is essential for
1069 * Bacula to be able to write multiple jobs to the tape.
1071 static int append_test()
1073 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1074 "This test is essential to Bacula.\n\n"
1075 "I'm going to write one record in file 0,\n"
1076 " two records in file 1,\n"
1077 " and three records in file 2\n\n"));
1081 weofcmd(); /* end file 0 */
1084 weofcmd(); /* end file 1 */
1088 weofcmd(); /* end file 2 */
1089 if (dev->has_cap(CAP_TWOEOF)) {
1092 dev->close(); /* release device */
1093 if (!open_the_device()) {
1097 Pmsg0(0, _("Now moving to end of medium.\n"));
1099 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1100 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1102 if (dev->file != 3) {
1106 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1109 if (dev->has_cap(CAP_TWOEOF)) {
1113 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1114 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1116 Pmsg0(-1, _("End scanning the tape.\n"));
1117 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1118 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1120 if (dev->file != 4) {
1128 * This test exercises the autochanger
1130 static int autochanger_test()
1132 POOLMEM *results, *changer;
1133 int slot, status, loaded;
1134 int timeout = dcr->device->max_changer_wait;
1137 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1138 if (!dev->has_cap(CAP_AUTOCHANGER)) {
1141 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1142 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1146 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1147 "To test the autochanger you must have a blank tape\n"
1148 " that I can write on in Slot 1.\n"));
1149 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1152 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1156 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1158 results = get_pool_memory(PM_MESSAGE);
1159 changer = get_pool_memory(PM_FNAME);
1163 dcr->VolCatInfo.Slot = slot;
1164 /* Find out what is loaded, zero means device is unloaded */
1165 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1166 changer = edit_device_codes(dcr, changer,
1167 dcr->device->changer_command, "loaded");
1168 status = run_program(changer, timeout, results);
1169 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1171 loaded = atoi(results);
1174 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1175 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1179 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1181 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1183 Dmsg1(100, "Results from loaded query=%s\n", results);
1185 dcr->VolCatInfo.Slot = loaded;
1186 /* We are going to load a new tape, so close the device */
1188 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1189 loaded, dev->drive_index);
1190 changer = edit_device_codes(dcr, changer,
1191 dcr->device->changer_command, "unload");
1192 status = run_program(changer, timeout, results);
1193 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1196 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1197 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1206 dcr->VolCatInfo.Slot = slot;
1207 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1208 slot, dev->drive_index);
1209 changer = edit_device_codes(dcr, changer,
1210 dcr->device->changer_command, "load");
1211 Dmsg1(100, "Changer=%s\n", changer);
1213 status = run_program(changer, timeout, results);
1215 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1216 slot, dev->drive_index);
1219 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1220 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1224 if (!open_the_device()) {
1228 * Start with sleep_time 0 then increment by 30 seconds if we get
1231 bmicrosleep(sleep_time, 0);
1232 if (!dev->rewind(dcr) || !dev->weof(1)) {
1233 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1235 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1236 "a longer sleep time in the mtx-script in the load) case.\n"
1237 "Adding a 30 second sleep and trying again ...\n"));
1241 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1244 if (!dev->weof(1)) {
1245 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1248 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1252 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1254 "to your mtx-changer script in the load) case.\n\n"),
1257 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1260 free_pool_memory(changer);
1261 free_pool_memory(results);
1266 free_pool_memory(changer);
1267 free_pool_memory(results);
1268 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1272 static void autochangercmd()
1279 * This test assumes that the append test has been done,
1280 * then it tests the fsf function.
1282 static int fsf_test()
1284 bool set_off = false;
1286 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1287 "This test is essential to Bacula.\n\n"
1288 "I'm going to write five files then test forward spacing\n\n"));
1292 weofcmd(); /* end file 0 */
1295 weofcmd(); /* end file 1 */
1299 weofcmd(); /* end file 2 */
1302 weofcmd(); /* end file 3 */
1304 weofcmd(); /* end file 4 */
1305 if (dev->has_cap(CAP_TWOEOF)) {
1311 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1313 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1316 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1317 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1319 if (dev->file != 1) {
1323 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1325 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1328 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1329 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1331 if (dev->file != 3) {
1336 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1338 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1341 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1342 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1344 if (dev->file != 4) {
1348 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1349 " Fast Forward Space File = no\n\n"
1350 "to your Device resource for this drive.\n"));
1354 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1356 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1358 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1359 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1360 if (dev->file != 5) {
1363 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1367 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1368 if (dev->has_cap(CAP_FASTFSF)) {
1369 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1370 "I am turning it off then retrying the test.\n"));
1371 dev->clear_cap(CAP_FASTFSF);
1375 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1376 "Some systems, e.g. OpenBSD, require you to set\n"
1377 " Use MTIOCGET= no\n"
1378 "in your device resource. Use with caution.\n"));
1387 * This is a general test of Bacula's functions
1388 * needed to read and write the tape.
1390 static void testcmd()
1394 if (!write_read_test()) {
1397 if (!position_test()) {
1401 stat = append_test();
1402 if (stat == 1) { /* OK get out */
1405 if (stat == -1) { /* first test failed */
1406 if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1407 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1408 "Setting \"Hardware End of Medium = no\n"
1409 " and \"Fast Forward Space File = no\n"
1410 "and retrying append test.\n\n"));
1411 dev->clear_cap(CAP_EOM); /* turn off eom */
1412 dev->clear_cap(CAP_FASTFSF); /* turn off fast fsf */
1413 stat = append_test();
1415 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1416 " Hardware End of Medium = No\n\n"
1417 " Fast Forward Space File = No\n"
1418 "to your Device resource in the Storage conf file.\n"));
1422 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1425 /* Wrong count after append */
1427 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1428 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1429 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1430 stat = append_test();
1432 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1433 " Hardware End of Medium = No\n"
1434 " Fast Forward Space File = No\n"
1435 " BSF at EOM = yes\n\n"
1436 "to your Device resource in the Storage conf file.\n"));
1443 Pmsg0(-1, _("\nAppend test failed.\n\n"
1444 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1445 "Unable to correct the problem. You MUST fix this\n"
1446 "problem before Bacula can use your tape drive correctly\n"
1447 "\nPerhaps running Bacula in fixed block mode will work.\n"
1448 "Do so by setting:\n\n"
1449 "Minimum Block Size = nnn\n"
1450 "Maximum Block Size = nnn\n\n"
1451 "in your Storage daemon's Device definition.\n"
1452 "nnn must match your tape driver's block size, which\n"
1453 "can be determined by reading your tape manufacturers\n"
1454 "information, and the information on your kernel dirver.\n"
1455 "Fixed block sizes, however, are not normally an ideal solution.\n"
1457 "Some systems, e.g. OpenBSD, require you to set\n"
1458 " Use MTIOCGET= no\n"
1459 "in your device resource. Use with caution.\n"));
1464 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1465 "Please double check it ...\n"
1466 "=== Sample correct output ===\n"
1467 "1 block of 64448 bytes in file 1\n"
1468 "End of File mark.\n"
1469 "2 blocks of 64448 bytes in file 2\n"
1470 "End of File mark.\n"
1471 "3 blocks of 64448 bytes in file 3\n"
1472 "End of File mark.\n"
1473 "1 block of 64448 bytes in file 4\n"
1474 "End of File mark.\n"
1475 "Total files=4, blocks=7, bytes = 451,136\n"
1476 "=== End sample correct output ===\n\n"
1477 "If the above scan output is not identical to the\n"
1478 "sample output, you MUST correct the problem\n"
1479 "or Bacula will not be able to write multiple Jobs to \n"
1483 re_read_block_test();
1486 fsf_test(); /* do fast forward space file test */
1488 autochanger_test(); /* do autochanger test */
1492 /* Forward space a file */
1493 static void fsfcmd()
1497 num = atoi(argk[1]);
1502 if (!dev->fsf(num)) {
1503 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1507 Pmsg0(0, _("Forward spaced 1 file.\n"));
1510 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1514 /* Forward space a record */
1515 static void fsrcmd()
1519 num = atoi(argk[1]);
1524 if (!dev->fsr(num)) {
1525 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1529 Pmsg0(0, _("Forward spaced 1 record.\n"));
1532 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1537 * Read a Bacula block from the tape
1541 dev->open(dcr, OPEN_READ_ONLY);
1542 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1546 * Write a Bacula block to the tape
1550 DEV_BLOCK *block = dcr->block;
1551 DEV_RECORD *rec = dcr->rec;
1554 if (!dev->is_open()) {
1557 sm_check(__FILE__, __LINE__, false);
1560 dump_block(block, "test");
1563 i = block->buf_len - 100;
1565 rec->data = check_pool_memory_size(rec->data, i);
1566 memset(rec->data, i & 0xFF, i);
1568 sm_check(__FILE__, __LINE__, false);
1569 if (!write_record_to_block(block, rec)) {
1570 Pmsg0(0, _("Error writing record to block.\n"));
1573 if (!write_block_to_dev(dcr)) {
1574 Pmsg0(0, _("Error writing block to device.\n"));
1577 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1579 Pmsg0(0, _("Wrote block to device.\n"));
1582 sm_check(__FILE__, __LINE__, false);
1583 sm_check(__FILE__, __LINE__, false);
1587 * Read a record from the tape
1594 if (!get_cmd(_("Enter length to read: "))) {
1598 if (len < 0 || len > 1000000) {
1599 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1602 buf = (char *)malloc(len);
1603 stat = read(dev->fd(), buf, len);
1604 if (stat > 0 && stat <= len) {
1608 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1609 len, stat, be.bstrerror());
1615 * Scan tape by reading block by block. Report what is
1616 * on the tape. Note, this command does raw reads, and as such
1617 * will not work with fixed block size devices.
1619 static void scancmd()
1622 int blocks, tot_blocks, tot_files;
1628 blocks = block_size = tot_blocks = 0;
1630 if (dev->state & ST_EOT) {
1631 Pmsg0(0, _("End of tape\n"));
1634 dev->update_pos(dcr);
1635 tot_files = dev->file;
1636 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1638 if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1641 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1642 dev->dev_name, be.bstrerror());
1643 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1646 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1649 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1654 Dmsg1(200, "read status = %d\n", stat);
1656 if (stat != block_size) {
1657 dev->update_pos(dcr);
1660 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1663 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1669 if (stat == 0) { /* EOF */
1670 dev->update_pos(dcr);
1671 printf(_("End of File mark.\n"));
1672 /* Two reads of zero means end of tape */
1673 if (dev->state & ST_EOF)
1674 dev->state |= ST_EOT;
1676 dev->state |= ST_EOF;
1679 if (dev->state & ST_EOT) {
1680 printf(_("End of tape\n"));
1683 } else { /* Got data */
1684 dev->state &= ~ST_EOF;
1690 dev->update_pos(dcr);
1691 tot_files = dev->file - tot_files;
1692 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1693 edit_uint64_with_commas(bytes, ec1));
1698 * Scan tape by reading Bacula block by block. Report what is
1699 * on the tape. This function reads Bacula blocks, so if your
1700 * Device resource is correctly defined, it should work with
1701 * either variable or fixed block sizes.
1703 static void scan_blocks()
1705 int blocks, tot_blocks, tot_files;
1706 uint32_t block_size;
1708 DEV_BLOCK *block = dcr->block;
1710 char buf1[100], buf2[100];
1712 blocks = block_size = tot_blocks = 0;
1716 dev->update_pos(dcr);
1717 tot_files = dev->file;
1719 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1720 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1721 if (dev->state & ST_EOT) {
1724 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1727 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1733 if (dev->state & ST_EOF) {
1736 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1739 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1743 printf(_("End of File mark.\n"));
1746 if (dev->state & ST_SHORT) {
1749 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1752 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1756 printf(_("Short block read.\n"));
1759 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1762 if (block->block_len != block_size) {
1765 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1768 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1772 block_size = block->block_len;
1776 bytes += block->block_len;
1777 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1778 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1779 block->VolSessionId, block->VolSessionTime);
1781 DEV_RECORD *rec = new_record();
1782 read_record_from_block(dcr, block, rec);
1783 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1784 block->BlockNumber, dev->block_num, block->block_len,
1785 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1786 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1789 } else if (verbose > 1) {
1790 dump_block(block, "");
1795 tot_files = dev->file - tot_files;
1796 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1797 edit_uint64_with_commas(bytes, ec1));
1801 static void statcmd()
1803 int debug = debug_level;
1805 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1807 dump_volume_label(dev);
1809 debug_level = debug;
1814 * First we label the tape, then we fill
1815 * it with data get a new tape and write a few blocks.
1817 static void fillcmd()
1820 DEV_BLOCK *block = dcr->block;
1822 char buf1[100], buf2[100];
1825 uint32_t min_block_size;
1836 "This command simulates Bacula writing to a tape.\n"
1837 "It requires either one or two blank tapes, which it\n"
1838 "will label and write.\n\n"
1839 "If you have an autochanger configured, it will use\n"
1840 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1841 "be prompted to insert the tapes when necessary.\n\n"
1842 "It will print a status approximately\n"
1843 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1844 "selected the simple test option, after writing the first tape\n"
1845 "it will rewind it and re-read the last block written.\n\n"
1846 "If you have selected the multiple tape test, when the first tape\n"
1847 "fills, it will ask for a second, and after writing a few more \n"
1848 "blocks, it will stop. Then it will begin re-reading the\n"
1850 "This may take a long time -- hours! ...\n\n"));
1852 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1853 "or the complete multiple tape (m) test: (s/m) "));
1854 if (cmd[0] == 's') {
1855 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1857 } else if (cmd[0] == 'm') {
1858 Pmsg0(-1, _("Multiple tape test selected.\n"));
1861 Pmsg0(000, _("Command aborted.\n"));
1865 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1866 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1868 /* Use fixed block size to simplify read back */
1869 min_block_size = dev->min_block_size;
1870 dev->min_block_size = dev->max_block_size;
1871 set_volume_name("TestVolume1", 1);
1872 dir_ask_sysop_to_create_appendable_volume(dcr);
1873 dev->set_append(); /* force volume to be relabeled */
1876 * Acquire output device for writing. Note, after acquiring a
1877 * device, we MUST release it, which is done at the end of this
1880 Dmsg0(100, "just before acquire_device\n");
1881 if (!acquire_device_for_append(dcr)) {
1882 set_jcr_job_status(jcr, JS_ErrorTerminated);
1885 block = jcr->dcr->block;
1887 Dmsg0(100, "Just after acquire_device_for_append\n");
1889 * Write Begin Session Record
1891 if (!write_session_label(dcr, SOS_LABEL)) {
1892 set_jcr_job_status(jcr, JS_ErrorTerminated);
1893 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1897 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1899 memset(&rec, 0, sizeof(rec));
1900 rec.data = get_memory(100000); /* max record size */
1902 #define REC_SIZE 32768
1903 rec.data_len = REC_SIZE;
1906 * Put some random data in the record
1908 fd = open("/dev/urandom", O_RDONLY);
1910 read(fd, rec.data, rec.data_len);
1913 uint32_t *p = (uint32_t *)rec.data;
1914 srandom(time(NULL));
1915 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1921 * Generate data as if from File daemon, write to device
1923 jcr->dcr->VolFirstIndex = 0;
1924 time(&jcr->run_time); /* start counting time for rates */
1925 (void)localtime_r(&jcr->run_time, &tm);
1926 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1928 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1930 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1932 for (file_index = 0; ok && !job_canceled(jcr); ) {
1933 rec.VolSessionId = jcr->VolSessionId;
1934 rec.VolSessionTime = jcr->VolSessionTime;
1935 rec.FileIndex = ++file_index;
1936 rec.Stream = STREAM_FILE_DATA;
1938 /* Mix up the data just a bit */
1939 uint32_t *lp = (uint32_t *)rec.data;
1941 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1945 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1946 rec.FileIndex, rec.VolSessionId,
1947 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1950 while (!write_record_to_block(block, &rec)) {
1952 * When we get here we have just filled a block
1954 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1957 /* Write block to tape */
1958 if (!flush_block(block, 1)) {
1962 /* Every 5000 blocks (approx 322MB) report where we are.
1964 if ((block->BlockNumber % 5000) == 0) {
1966 now -= jcr->run_time;
1968 now = 1; /* prevent divide error */
1970 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1971 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1972 block->BlockNumber, dev->block_num,
1973 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1975 /* Every 32000 blocks (approx 2GB) write an EOF.
1977 if ((block->BlockNumber % 32000) == 0) {
1979 (void)localtime_r(&now, &tm);
1980 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1981 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1982 flush_block(block, 0);
1986 /* Get out after writing 10 blocks to the second tape */
1987 if (++BlockNumber > 10 && stop != 0) { /* get out */
1992 Pmsg0(000, _("Not OK\n"));
1995 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1996 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1997 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1998 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
2000 /* Get out after writing 10 blocks to the second tape */
2001 if (BlockNumber > 10 && stop != 0) { /* get out */
2003 Pmsg1(-1, "Done writing %s records ...\n",
2004 edit_uint64_with_commas(write_count, ed1));
2009 Dmsg0(100, "Write_end_session_label()\n");
2010 /* Create Job status for end of session label */
2011 if (!job_canceled(jcr) && ok) {
2012 set_jcr_job_status(jcr, JS_Terminated);
2014 set_jcr_job_status(jcr, JS_ErrorTerminated);
2016 if (!write_session_label(dcr, EOS_LABEL)) {
2017 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2020 /* Write out final block of this session */
2021 if (!write_block_to_device(dcr)) {
2022 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2025 Pmsg0(-1, _("Wrote End of Session label.\n"));
2027 /* Save last block info for second tape */
2028 last_block_num2 = last_block_num;
2029 last_file2 = last_file;
2031 free_block(last_block2);
2033 last_block2 = dup_block(last_block);
2036 sprintf(buf, "%s/btape.state", working_directory);
2037 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2039 write(fd, &btape_state_level, sizeof(btape_state_level));
2040 write(fd, &simple, sizeof(simple));
2041 write(fd, &last_block_num1, sizeof(last_block_num1));
2042 write(fd, &last_block_num2, sizeof(last_block_num2));
2043 write(fd, &last_file1, sizeof(last_file1));
2044 write(fd, &last_file2, sizeof(last_file2));
2045 write(fd, last_block1->buf, last_block1->buf_len);
2046 write(fd, last_block2->buf, last_block2->buf_len);
2047 write(fd, first_block->buf, first_block->buf_len);
2049 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2050 last_block_num1, last_block_num2);
2053 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2058 (void)localtime_r(&now, &tm);
2059 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2061 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2062 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2065 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2066 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2069 jcr->dcr->block = block;
2072 dev->min_block_size = min_block_size;
2073 free_memory(rec.data);
2077 * Read two tapes written by the "fill" command and ensure
2078 * that the data is valid. If stop==1 we simulate full read back
2079 * of two tapes. If stop==-1 we simply read the last block and
2080 * verify that it is correct.
2082 static void unfillcmd()
2086 last_block1 = new_block(dev);
2087 last_block2 = new_block(dev);
2088 first_block = new_block(dev);
2089 sprintf(buf, "%s/btape.state", working_directory);
2090 fd = open(buf, O_RDONLY);
2092 uint32_t state_level;
2093 read(fd, &state_level, sizeof(btape_state_level));
2094 read(fd, &simple, sizeof(simple));
2095 read(fd, &last_block_num1, sizeof(last_block_num1));
2096 read(fd, &last_block_num2, sizeof(last_block_num2));
2097 read(fd, &last_file1, sizeof(last_file1));
2098 read(fd, &last_file2, sizeof(last_file2));
2099 read(fd, last_block1->buf, last_block1->buf_len);
2100 read(fd, last_block2->buf, last_block2->buf_len);
2101 read(fd, first_block->buf, first_block->buf_len);
2103 if (state_level != btape_state_level) {
2104 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2105 "the fill command.\n"));
2110 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2111 "You must redo the fill command.\n"), buf, be.bstrerror());
2118 static void do_unfill()
2120 DEV_BLOCK *block = dcr->block;
2127 Dmsg0(20, "Enter do_unfill\n");
2128 dev->set_cap(CAP_ANONVOLS); /* allow reading any volume */
2129 dev->clear_cap(CAP_LABEL); /* don't label anything here */
2133 time(&jcr->run_time); /* start counting time for rates */
2137 free_block(last_block);
2140 last_block_num = last_block_num1;
2141 last_file = last_file1;
2142 last_block = last_block1;
2144 free_restore_volume_list(jcr);
2146 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2147 create_restore_volume_list(jcr);
2148 if (jcr->VolList != NULL) {
2149 jcr->VolList->Slot = 1;
2150 if (jcr->VolList->next != NULL) {
2151 jcr->VolList->next->Slot = 2;
2155 set_volume_name("TestVolume1", 1);
2158 /* Multiple Volume tape */
2159 /* Close device so user can use autochanger if desired */
2160 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2163 autochanger = autoload_device(dcr, 1, NULL);
2164 if (autochanger != 1) {
2166 get_cmd(_("Mount first tape. Press enter when ready: "));
2171 dev->num_writers = 0;
2172 if (!acquire_device_for_read(dcr)) {
2173 Pmsg1(-1, "%s", dev->errmsg);
2177 * We now have the first tape mounted.
2178 * Note, re-reading last block may have caused us to
2179 * loose track of where we are (block number unknown).
2181 Pmsg0(-1, _("Rewinding.\n"));
2182 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2185 /* Read the first 10000 records */
2186 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2187 dev->file, dev->block_num);
2189 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2190 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2191 last_file, last_block_num);
2192 if (!dev->reposition(dcr, last_file, last_block_num)) {
2193 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2196 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2197 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2198 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2201 if (compare_blocks(last_block, block)) {
2203 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2205 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2212 /* restore info for last block on second Volume */
2213 last_block_num = last_block_num2;
2214 last_file = last_file2;
2215 last_block = last_block2;
2217 /* Multiple Volume tape */
2218 /* Close device so user can use autochanger if desired */
2219 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2223 set_volume_name("TestVolume2", 2);
2225 autochanger = autoload_device(dcr, 1, NULL);
2226 if (autochanger != 1) {
2228 get_cmd(_("Mount second tape. Press enter when ready: "));
2232 if (!acquire_device_for_read(dcr)) {
2233 Pmsg1(-1, "%s", dev->errmsg);
2237 /* Space to "first" block which is last block not written
2238 * on the previous tape.
2240 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2241 if (!dev->reposition(dcr, 0, 1)) {
2242 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2245 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2246 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2247 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2250 if (compare_blocks(first_block, block)) {
2251 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2254 /* Now find and compare the last block */
2255 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2256 last_file, last_block_num);
2257 if (!dev->reposition(dcr, last_file, last_block_num)) {
2258 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2261 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2262 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2263 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2266 if (compare_blocks(last_block, block)) {
2267 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2271 free_block(last_block1);
2272 free_block(last_block2);
2273 free_block(first_block);
2276 /* Read 10000 records then stop */
2277 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2279 DEVICE *dev = dcr->dev;
2281 if (quickie_count == 10000) {
2282 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2284 return quickie_count < 10000;
2287 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2290 uint32_t CheckSum, block_len;
2293 p = last_block->buf;
2295 unser_begin(q, BLKHDR2_LENGTH);
2296 unser_uint32(CheckSum);
2297 unser_uint32(block_len);
2298 while (q < (block->buf+block_len)) {
2305 dump_block(last_block, _("Last block written"));
2307 dump_block(block, _("Block read back"));
2308 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2309 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2310 "that was read back differ. The test FAILED !!!!\n"
2311 "This must be corrected before you use Bacula\n"
2312 "to write multi-tape Volumes.!!!!\n"));
2316 dump_block(last_block, _("Last block written"));
2317 dump_block(block, _("Block read back"));
2327 * Write current block to tape regardless of whether or
2328 * not it is full. If the tape fills, attempt to
2329 * acquire another tape.
2331 static int flush_block(DEV_BLOCK *block, int dump)
2335 uint32_t this_file, this_block_num;
2339 this_block = new_block(dev);
2342 last_block = new_block(dev);
2345 this_file = dev->file;
2346 this_block_num = dev->block_num;
2347 if (!write_block_to_dev(dcr)) {
2348 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2349 last_file, last_block_num, this_block_num);
2352 * This is 1st tape, so save first tape info separate
2353 * from second tape info
2355 last_block_num1 = last_block_num;
2356 last_file1 = last_file;
2357 last_block1 = dup_block(last_block);
2358 last_block2 = dup_block(last_block);
2359 first_block = dup_block(block); /* first block second tape */
2362 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2363 (unsigned)file_index, block->BlockNumber, block->block_len);
2364 dump_block(last_block, _("Last block written"));
2366 dump_block(block, _("Block not written"));
2369 eot_block = block->BlockNumber;
2370 eot_block_len = block->block_len;
2371 eot_FileIndex = file_index;
2375 now -= jcr->run_time;
2377 now = 1; /* don't divide by zero */
2379 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2380 vol_size = dev->VolCatInfo.VolCatBytes;
2381 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2382 dev->file, dev->block_num,
2383 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2386 stop = -1; /* stop, but do simplified test */
2388 /* Full test in progress */
2389 if (!fixup_device_block_write_error(jcr->dcr)) {
2390 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2395 BlockNumber = 0; /* start counting for second tape */
2398 return 1; /* end of tape reached */
2401 /* Save contents after write so that the header is serialized */
2402 memcpy(this_block->buf, block->buf, this_block->buf_len);
2405 * Note, we always read/write to block, but we toggle
2406 * copying it to one or another of two allocated blocks.
2407 * Switch blocks so that the block just successfully written is
2408 * always in last_block.
2410 tblock = last_block;
2411 last_block = this_block;
2412 this_block = tblock;
2413 last_file = this_file;
2414 last_block_num = this_block_num;
2422 * First we label the tape, then we fill
2423 * it with data get a new tape and write a few blocks.
2425 static void qfillcmd()
2427 DEV_BLOCK *block = dcr->block;
2428 DEV_RECORD *rec = dcr->rec;
2431 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2433 get_cmd(_("How many blocks do you want to write? (1000): "));
2440 sm_check(__FILE__, __LINE__, false);
2442 i = block->buf_len - 100;
2444 rec->data = check_pool_memory_size(rec->data, i);
2445 memset(rec->data, i & 0xFF, i);
2448 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2449 for (i=0; i < count; i++) {
2454 if (!write_record_to_block(block, rec)) {
2455 Pmsg0(0, _("Error writing record to block.\n"));
2458 if (!write_block_to_dev(dcr)) {
2459 Pmsg0(0, _("Error writing block to device.\n"));
2465 if (dev->has_cap(CAP_TWOEOF)) {
2472 sm_check(__FILE__, __LINE__, false);
2476 * Fill a tape using raw write() command
2478 static void rawfill_cmd()
2480 DEV_BLOCK *block = dcr->block;
2483 uint32_t block_num = 0;
2488 fd = open("/dev/urandom", O_RDONLY);
2490 read(fd, block->buf, block->buf_len);
2493 uint32_t *p = (uint32_t *)block->buf;
2494 srandom(time(NULL));
2495 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2499 p = (uint32_t *)block->buf;
2500 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2503 if (dev->is_tape()) {
2504 stat = tape_write(dev->fd(), block->buf, block->buf_len);
2506 stat = write(dev->fd(), block->buf, block->buf_len);
2508 if (stat == (int)block->buf_len) {
2509 if ((block_num++ % 100) == 0) {
2514 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2524 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2525 be.bstrerror(my_errno));
2531 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2532 static struct cmdstruct commands[] = {
2533 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2534 {NT_("bsf"), bsfcmd, _("backspace file")},
2535 {NT_("bsr"), bsrcmd, _("backspace record")},
2536 {NT_("cap"), capcmd, _("list device capabilities")},
2537 {NT_("clear"), clearcmd, _("clear tape errors")},
2538 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2539 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2540 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2541 {NT_("unfill"), unfillcmd, _("read filled tape")},
2542 {NT_("fsf"), fsfcmd, _("forward space a file")},
2543 {NT_("fsr"), fsrcmd, _("forward space a record")},
2544 {NT_("help"), helpcmd, _("print this command")},
2545 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2546 {NT_("load"), loadcmd, _("load a tape")},
2547 {NT_("quit"), quitcmd, _("quit btape")},
2548 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2549 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2550 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2551 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2552 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2553 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2554 {NT_("status"), statcmd, _("print tape status")},
2555 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2556 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2557 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2558 {NT_("rr"), rrcmd, _("read a single record")},
2559 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2560 {NT_("qfill"), qfillcmd, _("quick fill command")}
2562 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2570 while (!quit && get_cmd("*")) {
2571 sm_check(__FILE__, __LINE__, false);
2573 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2574 for (i=0; i<comsize; i++) /* search for command */
2575 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2576 (*commands[i].func)(); /* go execute command */
2581 Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2586 static void helpcmd()
2590 printf(_("Interactive commands:\n"));
2591 printf(_(" Command Description\n ======= ===========\n"));
2592 for (i=0; i<comsize; i++)
2593 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2601 "\nVersion: %s (%s)\n\n"
2602 "Usage: btape <options> <device_name>\n"
2603 " -b <file> specify bootstrap file\n"
2604 " -c <file> set configuration file to file\n"
2605 " -d <nn> set debug level to <nn>\n"
2606 " -dt print timestamp in debug output\n"
2607 " -p proceed inspite of I/O errors\n"
2608 " -s turn off signals\n"
2610 " -? print this message.\n"
2611 "\n"), 2000, VERSION, BDATE);
2616 * Get next input command from terminal. This
2617 * routine is REALLY primitive, and should be enhanced
2618 * to have correct backspacing, etc.
2621 get_cmd(const char *prompt)
2625 fprintf(stdout, prompt);
2627 /* We really should turn off echoing and pretty this
2631 while ((ch = fgetc(stdin)) != EOF) {
2633 strip_trailing_junk(cmd);
2635 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2648 /* Dummies to replace askdir.c */
2649 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2650 bool dir_send_job_status(JCR *jcr) {return 1;}
2652 bool dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten)
2658 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2660 Dmsg0(20, "Enter dir_get_volume_info\n");
2661 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2665 bool dir_create_jobmedia_record(DCR *dcr)
2667 dcr->WroteVol = false;
2672 bool dir_find_next_appendable_volume(DCR *dcr)
2674 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2675 return dcr->VolumeName[0] != 0;
2678 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2680 DEVICE *dev = dcr->dev;
2681 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2682 if (dcr->VolumeName[0] == 0) {
2683 return dir_ask_sysop_to_create_appendable_volume(dcr);
2685 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2686 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2687 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2690 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2691 dcr->VolumeName, dev->print_name());
2698 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2701 DEVICE *dev = dcr->dev;
2702 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2704 set_volume_name("TestVolume1", 1);
2706 set_volume_name("TestVolume2", 2);
2708 /* Close device so user can use autochanger if desired */
2709 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2712 autochanger = autoload_device(dcr, 1, NULL);
2713 if (autochanger != 1) {
2714 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2725 static bool my_mount_next_read_volume(DCR *dcr)
2728 JCR *jcr = dcr->jcr;
2729 DEV_BLOCK *block = dcr->block;
2731 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2732 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2735 volume_unused(dcr); /* mark volume no longer needed */
2736 if (LastBlock != block->BlockNumber) {
2737 VolBytes += block->block_len;
2739 LastBlock = block->BlockNumber;
2741 now -= jcr->run_time;
2745 kbs = (double)VolBytes / (1000.0 * (double)now);
2746 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2747 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2749 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2754 set_volume_name("TestVolume2", 2);
2757 if (!acquire_device_for_read(dcr)) {
2758 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2761 return true; /* next volume mounted */
2764 static void set_volume_name(const char *VolName, int volnum)
2766 DCR *dcr = jcr->dcr;
2767 VolumeName = VolName;
2769 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2770 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2771 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2772 dcr->VolCatInfo.Slot = volnum;
2773 dcr->VolCatInfo.InChanger = true;