2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2007 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 debug_level = atoi(optarg);
224 if (debug_level <= 0) {
251 cmd = get_pool_memory(PM_FNAME);
252 args = get_pool_memory(PM_FNAME);
255 init_signals(terminate_btape);
258 if (configfile == NULL) {
259 configfile = bstrdup(CONFIG_FILE);
262 daemon_start_time = time(NULL);
264 parse_config(configfile);
267 /* See if we can open a device */
269 Pmsg0(000, _("No archive name specified.\n"));
272 } else if (margc != 1) {
273 Pmsg0(000, _("Improper number of arguments specified.\n"));
278 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
287 Pmsg0(000, _("btape does not work with DVD storage.\n"));
291 if (!dev->is_tape()) {
292 Pmsg0(000, _("btape only works with tape storage.\n"));
297 if (!open_the_device()) {
301 Dmsg0(200, "Do tape commands\n");
309 static void terminate_btape(int stat)
312 sm_check(__FILE__, __LINE__, false);
316 free_config_resources();
318 free_pool_memory(args);
322 free_pool_memory(cmd);
339 if (debug_level > 10)
340 print_memory_pool_stats();
343 free_block(this_block);
348 close_memory_pool(); /* free memory in pool */
349 term_last_jobs_list();
355 static bool open_the_device()
360 block = new_block(dev);
362 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
363 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
364 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
368 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
369 dev->set_append(); /* put volume in append mode */
384 * Write a label to the tape
386 static void labelcmd()
389 pm_strcpy(cmd, VolumeName);
391 if (!get_cmd(_("Enter Volume Name: "))) {
396 if (!dev->is_open()) {
397 if (!first_open_device(dcr)) {
398 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
403 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
404 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
408 * Read the tape label
410 static void readlabelcmd()
412 int save_debug_level = debug_level;
415 stat = read_dev_volume_label(dcr);
418 Pmsg0(0, _("Volume has no label.\n"));
421 Pmsg0(0, _("Volume label read correctly.\n"));
424 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
427 Pmsg0(0, _("Volume name error\n"));
429 case VOL_CREATE_ERROR:
430 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
432 case VOL_VERSION_ERROR:
433 Pmsg0(0, _("Volume version error.\n"));
435 case VOL_LABEL_ERROR:
436 Pmsg0(0, _("Bad Volume label type.\n"));
439 Pmsg0(0, _("Unknown error.\n"));
444 dump_volume_label(dev);
445 debug_level = save_debug_level;
450 * Load the tape should have prevously been taken
451 * off line, otherwise this command is not necessary.
453 static void loadcmd()
456 if (!load_dev(dev)) {
457 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
459 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
465 static void rewindcmd()
467 if (!dev->rewind(dcr)) {
468 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
471 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
476 * Clear any tape error
478 static void clearcmd()
484 * Write and end of file on the tape
486 static void weofcmd()
496 if (!dev->weof(num)) {
497 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
501 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
504 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
510 /* Go to the end of the medium -- raw command
511 * The idea was orginally that the end of the Bacula
512 * medium would be flagged differently. This is not
513 * currently the case. So, this is identical to the
518 if (!dev->eod(dcr)) {
519 Pmsg1(0, "%s", dev->bstrerror());
522 Pmsg0(0, _("Moved to end of medium.\n"));
527 * Go to the end of the medium (either hardware determined
528 * or defined by two eofs.
548 if (!dev->bsf(num)) {
549 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
551 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
567 if (!dev->bsr(num)) {
568 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
570 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
575 * List device capabilities as defined in the
580 printf(_("Configured device capabilities:\n"));
581 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
582 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
583 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
584 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
585 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
586 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
587 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
588 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
589 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
590 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
591 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
592 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
593 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
594 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
595 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
598 printf(_("Device status:\n"));
599 printf("%sOPENED ", dev->is_open() ? "" : "!");
600 printf("%sTAPE ", dev->is_tape() ? "" : "!");
601 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
602 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
603 printf("%sAPPEND ", dev->can_append() ? "" : "!");
604 printf("%sREAD ", dev->can_read() ? "" : "!");
605 printf("%sEOT ", dev->at_eot() ? "" : "!");
606 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
607 printf("%sEOF ", dev->at_eof() ? "" : "!");
608 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
609 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
612 printf(_("Device parameters:\n"));
613 printf("Device name: %s\n", dev->dev_name);
614 printf("File=%u block=%u\n", dev->file, dev->block_num);
615 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
617 printf(_("Status:\n"));
623 * Test writting larger and larger records.
624 * This is a torture test for records.
626 static void rectestcmd()
632 Pmsg0(0, _("Test writting larger and larger records.\n"
633 "This is a torture test for records.\nI am going to write\n"
634 "larger and larger records. It will stop when the record size\n"
635 "plus the header exceeds the block size (by default about 64K)\n"));
638 get_cmd(_("Do you want to continue? (y/n): "));
640 Pmsg0(000, _("Command aborted.\n"));
644 sm_check(__FILE__, __LINE__, false);
645 block = new_block(dev);
648 for (i=1; i<500000; i++) {
649 rec->data = check_pool_memory_size(rec->data, i);
650 memset(rec->data, i & 0xFF, i);
652 sm_check(__FILE__, __LINE__, false);
653 if (write_record_to_block(block, rec)) {
656 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
660 sm_check(__FILE__, __LINE__, false);
664 sm_check(__FILE__, __LINE__, false);
668 * This test attempts to re-read a block written by Bacula
669 * normally at the end of the tape. Bacula will then back up
670 * over the two eof marks, backup over the record and reread
671 * it to make sure it is valid. Bacula can skip this validation
672 * if you set "Backward space record = no"
674 static int re_read_block_test()
676 DEV_BLOCK *block = dcr->block;
681 if (!(dev->capabilities & CAP_BSR)) {
682 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
686 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
687 "I'm going to write three records and an EOF\n"
688 "then backup over the EOF and re-read the last record.\n"
689 "Bacula does this after writing the last block on the\n"
690 "tape to verify that the block was written correctly.\n\n"
691 "This is not an *essential* feature ...\n\n"));
695 rec->data = check_pool_memory_size(rec->data, block->buf_len);
696 len = rec->data_len = block->buf_len-100;
697 memset(rec->data, 1, rec->data_len);
698 if (!write_record_to_block(block, rec)) {
699 Pmsg0(0, _("Error writing record to block.\n"));
702 if (!write_block_to_dev(dcr)) {
703 Pmsg0(0, _("Error writing block to device.\n"));
706 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
708 memset(rec->data, 2, rec->data_len);
709 if (!write_record_to_block(block, rec)) {
710 Pmsg0(0, _("Error writing record to block.\n"));
713 if (!write_block_to_dev(dcr)) {
714 Pmsg0(0, _("Error writing block to device.\n"));
717 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
719 memset(rec->data, 3, rec->data_len);
720 if (!write_record_to_block(block, rec)) {
721 Pmsg0(0, _("Error writing record to block.\n"));
724 if (!write_block_to_dev(dcr)) {
725 Pmsg0(0, _("Error writing block to device.\n"));
728 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
731 if (dev->has_cap(CAP_TWOEOF)) {
735 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
738 if (dev->has_cap(CAP_TWOEOF)) {
740 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
744 Pmsg0(0, _("Backspaced over EOF OK.\n"));
746 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
749 Pmsg0(0, _("Backspace record OK.\n"));
750 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
752 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
755 memset(rec->data, 0, rec->data_len);
756 if (!read_record_from_block(dcr, block, rec)) {
758 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
761 for (int i=0; i<len; i++) {
762 if (rec->data[i] != 3) {
763 Pmsg0(0, _("Bad data in record. Test failed!\n"));
767 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
768 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
775 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
776 "this function to verify the last block written to the\n"
777 "tape. Bacula will skip the last block verification\n"
779 "Backward Space Record = No\n\n"
780 "to your Storage daemon's Device resource definition.\n"));
787 * This test writes Bacula blocks to the tape in
788 * several files. It then rewinds the tape and attepts
789 * to read these blocks back checking the data.
791 static int write_read_test()
799 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
800 "I'm going to write 1000 records and an EOF\n"
801 "then write 1000 records and an EOF, then rewind,\n"
802 "and re-read the data to verify that it is correct.\n\n"
803 "This is an *essential* feature ...\n\n"));
806 if (!dev->rewind(dcr)) {
807 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
810 rec->data = check_pool_memory_size(rec->data, block->buf_len);
811 rec->data_len = block->buf_len-100;
812 len = rec->data_len/sizeof(i);
813 for (i=1; i<=1000; i++) {
814 p = (int *)rec->data;
815 for (j=0; j<len; j++) {
818 if (!write_record_to_block(block, rec)) {
819 Pmsg0(0, _("Error writing record to block.\n"));
822 if (!write_block_to_dev(dcr)) {
823 Pmsg0(0, _("Error writing block to device.\n"));
827 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
829 for (i=1001; i<=2000; i++) {
830 p = (int *)rec->data;
831 for (j=0; j<len; j++) {
834 if (!write_record_to_block(block, rec)) {
835 Pmsg0(0, _("Error writing record to block.\n"));
838 if (!write_block_to_dev(dcr)) {
839 Pmsg0(0, _("Error writing block to device.\n"));
843 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
845 if (dev->has_cap(CAP_TWOEOF)) {
848 if (!dev->rewind(dcr)) {
849 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
852 Pmsg0(0, _("Rewind OK.\n"));
854 for (i=1; i<=2000; i++) {
856 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
858 if (dev_state(dev, ST_EOF)) {
859 Pmsg0(-1, _("Got EOF on tape.\n"));
864 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
867 memset(rec->data, 0, rec->data_len);
868 if (!read_record_from_block(dcr, block, rec)) {
870 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
873 p = (int *)rec->data;
874 for (j=0; j<len; j++) {
876 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
882 if (i == 1000 || i == 2000) {
883 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
886 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
895 * This test writes Bacula blocks to the tape in
896 * several files. It then rewinds the tape and attepts
897 * to read these blocks back checking the data.
899 static int position_test()
901 DEV_BLOCK *block = dcr->block;
907 int file = 0, blk = 0;
909 bool got_eof = false;
911 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
912 "I'm going to write 1000 records and an EOF\n"
913 "then write 1000 records and an EOF, then rewind,\n"
914 "and position to a few blocks and verify that it is correct.\n\n"
915 "This is an *essential* feature ...\n\n"));
918 if (!dev->rewind(dcr)) {
919 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
922 rec->data = check_pool_memory_size(rec->data, block->buf_len);
923 rec->data_len = block->buf_len-100;
924 len = rec->data_len/sizeof(i);
925 for (i=1; i<=1000; i++) {
926 p = (int *)rec->data;
927 for (j=0; j<len; j++) {
930 if (!write_record_to_block(block, rec)) {
931 Pmsg0(0, _("Error writing record to block.\n"));
934 if (!write_block_to_dev(dcr)) {
935 Pmsg0(0, _("Error writing block to device.\n"));
939 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
941 for (i=1001; i<=2000; i++) {
942 p = (int *)rec->data;
943 for (j=0; j<len; j++) {
946 if (!write_record_to_block(block, rec)) {
947 Pmsg0(0, _("Error writing record to block.\n"));
950 if (!write_block_to_dev(dcr)) {
951 Pmsg0(0, _("Error writing block to device.\n"));
955 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
957 if (dev->has_cap(CAP_TWOEOF)) {
960 if (!dev->rewind(dcr)) {
961 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
964 Pmsg0(0, _("Rewind OK.\n"));
968 /* Set up next item to read based on where we are */
1004 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1005 if (!dev->reposition(dcr, file, blk)) {
1006 Pmsg0(0, _("Reposition error.\n"));
1010 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1012 if (dev_state(dev, ST_EOF)) {
1013 Pmsg0(-1, _("Got EOF on tape.\n"));
1019 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1020 recno, file, blk, be.bstrerror(dev->dev_errno));
1021 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1022 " set to variable blocking as normally used by Bacula.\n"
1023 " Please see the Tape Testing chapter in the manual and \n"
1024 " look for using mt with defblksize and setoptions\n"
1025 "If your tape drive block size is correct, then perhaps\n"
1026 " your SCSI driver is *really* stupid and does not\n"
1027 " correctly report the file:block after a FSF. In this\n"
1028 " case try setting:\n"
1029 " Fast Forward Space File = no\n"
1030 " in your Device resource.\n"));
1034 memset(rec->data, 0, rec->data_len);
1035 if (!read_record_from_block(dcr, block, rec)) {
1037 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1040 p = (int *)rec->data;
1041 for (j=0; j<len; j++) {
1042 if (p[j] != recno) {
1043 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1048 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1050 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1062 * This test writes some records, then writes an end of file,
1063 * rewinds the tape, moves to the end of the data and attepts
1064 * to append to the tape. This function is essential for
1065 * Bacula to be able to write multiple jobs to the tape.
1067 static int append_test()
1069 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1070 "This test is essential to Bacula.\n\n"
1071 "I'm going to write one record in file 0,\n"
1072 " two records in file 1,\n"
1073 " and three records in file 2\n\n"));
1077 weofcmd(); /* end file 0 */
1080 weofcmd(); /* end file 1 */
1084 weofcmd(); /* end file 2 */
1085 if (dev->has_cap(CAP_TWOEOF)) {
1088 dev->close(); /* release device */
1089 if (!open_the_device()) {
1093 Pmsg0(0, _("Now moving to end of medium.\n"));
1095 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1096 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1098 if (dev->file != 3) {
1102 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1105 if (dev->has_cap(CAP_TWOEOF)) {
1109 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1110 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1112 Pmsg0(-1, _("End scanning the tape.\n"));
1113 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1114 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1116 if (dev->file != 4) {
1124 * This test exercises the autochanger
1126 static int autochanger_test()
1128 POOLMEM *results, *changer;
1129 int slot, status, loaded;
1130 int timeout = dcr->device->max_changer_wait;
1133 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1134 if (!dev->has_cap(CAP_AUTOCHANGER)) {
1137 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1138 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1142 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1143 "To test the autochanger you must have a blank tape\n"
1144 " that I can write on in Slot 1.\n"));
1145 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1148 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1152 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1154 results = get_pool_memory(PM_MESSAGE);
1155 changer = get_pool_memory(PM_FNAME);
1159 dcr->VolCatInfo.Slot = slot;
1160 /* Find out what is loaded, zero means device is unloaded */
1161 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1162 changer = edit_device_codes(dcr, changer,
1163 dcr->device->changer_command, "loaded");
1164 status = run_program(changer, timeout, results);
1165 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1167 loaded = atoi(results);
1170 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1171 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1175 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1177 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1179 Dmsg1(100, "Results from loaded query=%s\n", results);
1181 dcr->VolCatInfo.Slot = loaded;
1182 /* We are going to load a new tape, so close the device */
1184 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1185 loaded, dev->drive_index);
1186 changer = edit_device_codes(dcr, changer,
1187 dcr->device->changer_command, "unload");
1188 status = run_program(changer, timeout, results);
1189 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1192 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1193 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1202 dcr->VolCatInfo.Slot = slot;
1203 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1204 slot, dev->drive_index);
1205 changer = edit_device_codes(dcr, changer,
1206 dcr->device->changer_command, "load");
1207 Dmsg1(100, "Changer=%s\n", changer);
1209 status = run_program(changer, timeout, results);
1211 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1212 slot, dev->drive_index);
1215 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1216 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1220 if (!open_the_device()) {
1224 * Start with sleep_time 0 then increment by 30 seconds if we get
1227 bmicrosleep(sleep_time, 0);
1228 if (!dev->rewind(dcr) || !dev->weof(1)) {
1229 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1231 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1232 "a longer sleep time in the mtx-script in the load) case.\n"
1233 "Adding a 30 second sleep and trying again ...\n"));
1237 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1240 if (!dev->weof(1)) {
1241 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1244 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1248 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1250 "to your mtx-changer script in the load) case.\n\n"),
1253 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1256 free_pool_memory(changer);
1257 free_pool_memory(results);
1262 free_pool_memory(changer);
1263 free_pool_memory(results);
1264 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1268 static void autochangercmd()
1275 * This test assumes that the append test has been done,
1276 * then it tests the fsf function.
1278 static int fsf_test()
1280 bool set_off = false;
1282 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1283 "This test is essential to Bacula.\n\n"
1284 "I'm going to write five files then test forward spacing\n\n"));
1288 weofcmd(); /* end file 0 */
1291 weofcmd(); /* end file 1 */
1295 weofcmd(); /* end file 2 */
1298 weofcmd(); /* end file 3 */
1300 weofcmd(); /* end file 4 */
1301 if (dev->has_cap(CAP_TWOEOF)) {
1307 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1309 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1312 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1313 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1315 if (dev->file != 1) {
1319 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1321 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1324 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1325 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1327 if (dev->file != 3) {
1332 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1334 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1337 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1338 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1340 if (dev->file != 4) {
1344 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1345 " Fast Forward Space File = no\n\n"
1346 "to your Device resource for this drive.\n"));
1350 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1352 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1354 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1355 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1356 if (dev->file != 5) {
1359 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1363 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1364 if (dev->has_cap(CAP_FASTFSF)) {
1365 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1366 "I am turning it off then retrying the test.\n"));
1367 dev->clear_cap(CAP_FASTFSF);
1371 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1372 "Some systems, e.g. OpenBSD, require you to set\n"
1373 " Use MTIOCGET= no\n"
1374 "in your device resource. Use with caution.\n"));
1383 * This is a general test of Bacula's functions
1384 * needed to read and write the tape.
1386 static void testcmd()
1390 if (!write_read_test()) {
1393 if (!position_test()) {
1397 stat = append_test();
1398 if (stat == 1) { /* OK get out */
1401 if (stat == -1) { /* first test failed */
1402 if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1403 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1404 "Setting \"Hardware End of Medium = no\n"
1405 " and \"Fast Forward Space File = no\n"
1406 "and retrying append test.\n\n"));
1407 dev->clear_cap(CAP_EOM); /* turn off eom */
1408 dev->clear_cap(CAP_FASTFSF); /* turn off fast fsf */
1409 stat = append_test();
1411 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1412 " Hardware End of Medium = No\n\n"
1413 " Fast Forward Space File = No\n"
1414 "to your Device resource in the Storage conf file.\n"));
1418 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1421 /* Wrong count after append */
1423 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1424 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1425 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1426 stat = append_test();
1428 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1429 " Hardware End of Medium = No\n"
1430 " Fast Forward Space File = No\n"
1431 " BSF at EOM = yes\n\n"
1432 "to your Device resource in the Storage conf file.\n"));
1439 Pmsg0(-1, _("\nAppend test failed.\n\n"
1440 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1441 "Unable to correct the problem. You MUST fix this\n"
1442 "problem before Bacula can use your tape drive correctly\n"
1443 "\nPerhaps running Bacula in fixed block mode will work.\n"
1444 "Do so by setting:\n\n"
1445 "Minimum Block Size = nnn\n"
1446 "Maximum Block Size = nnn\n\n"
1447 "in your Storage daemon's Device definition.\n"
1448 "nnn must match your tape driver's block size, which\n"
1449 "can be determined by reading your tape manufacturers\n"
1450 "information, and the information on your kernel dirver.\n"
1451 "Fixed block sizes, however, are not normally an ideal solution.\n"
1453 "Some systems, e.g. OpenBSD, require you to set\n"
1454 " Use MTIOCGET= no\n"
1455 "in your device resource. Use with caution.\n"));
1460 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1461 "Please double check it ...\n"
1462 "=== Sample correct output ===\n"
1463 "1 block of 64448 bytes in file 1\n"
1464 "End of File mark.\n"
1465 "2 blocks of 64448 bytes in file 2\n"
1466 "End of File mark.\n"
1467 "3 blocks of 64448 bytes in file 3\n"
1468 "End of File mark.\n"
1469 "1 block of 64448 bytes in file 4\n"
1470 "End of File mark.\n"
1471 "Total files=4, blocks=7, bytes = 451,136\n"
1472 "=== End sample correct output ===\n\n"
1473 "If the above scan output is not identical to the\n"
1474 "sample output, you MUST correct the problem\n"
1475 "or Bacula will not be able to write multiple Jobs to \n"
1479 re_read_block_test();
1482 fsf_test(); /* do fast forward space file test */
1484 autochanger_test(); /* do autochanger test */
1488 /* Forward space a file */
1489 static void fsfcmd()
1493 num = atoi(argk[1]);
1498 if (!dev->fsf(num)) {
1499 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1503 Pmsg0(0, _("Forward spaced 1 file.\n"));
1506 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1510 /* Forward space a record */
1511 static void fsrcmd()
1515 num = atoi(argk[1]);
1520 if (!dev->fsr(num)) {
1521 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1525 Pmsg0(0, _("Forward spaced 1 record.\n"));
1528 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1533 * Read a Bacula block from the tape
1537 dev->open(dcr, OPEN_READ_ONLY);
1538 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1542 * Write a Bacula block to the tape
1546 DEV_BLOCK *block = dcr->block;
1547 DEV_RECORD *rec = dcr->rec;
1550 if (!dev->is_open()) {
1553 sm_check(__FILE__, __LINE__, false);
1556 dump_block(block, "test");
1559 i = block->buf_len - 100;
1561 rec->data = check_pool_memory_size(rec->data, i);
1562 memset(rec->data, i & 0xFF, i);
1564 sm_check(__FILE__, __LINE__, false);
1565 if (!write_record_to_block(block, rec)) {
1566 Pmsg0(0, _("Error writing record to block.\n"));
1569 if (!write_block_to_dev(dcr)) {
1570 Pmsg0(0, _("Error writing block to device.\n"));
1573 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1575 Pmsg0(0, _("Wrote block to device.\n"));
1578 sm_check(__FILE__, __LINE__, false);
1579 sm_check(__FILE__, __LINE__, false);
1583 * Read a record from the tape
1590 if (!get_cmd(_("Enter length to read: "))) {
1594 if (len < 0 || len > 1000000) {
1595 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1598 buf = (char *)malloc(len);
1599 stat = read(dev->fd(), buf, len);
1600 if (stat > 0 && stat <= len) {
1604 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1605 len, stat, be.bstrerror());
1611 * Scan tape by reading block by block. Report what is
1612 * on the tape. Note, this command does raw reads, and as such
1613 * will not work with fixed block size devices.
1615 static void scancmd()
1618 int blocks, tot_blocks, tot_files;
1624 blocks = block_size = tot_blocks = 0;
1626 if (dev->state & ST_EOT) {
1627 Pmsg0(0, _("End of tape\n"));
1630 dev->update_pos(dcr);
1631 tot_files = dev->file;
1632 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1634 if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1637 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1638 dev->dev_name, be.bstrerror());
1639 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1642 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1645 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1650 Dmsg1(200, "read status = %d\n", stat);
1652 if (stat != block_size) {
1653 dev->update_pos(dcr);
1656 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1659 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1665 if (stat == 0) { /* EOF */
1666 dev->update_pos(dcr);
1667 printf(_("End of File mark.\n"));
1668 /* Two reads of zero means end of tape */
1669 if (dev->state & ST_EOF)
1670 dev->state |= ST_EOT;
1672 dev->state |= ST_EOF;
1675 if (dev->state & ST_EOT) {
1676 printf(_("End of tape\n"));
1679 } else { /* Got data */
1680 dev->state &= ~ST_EOF;
1686 dev->update_pos(dcr);
1687 tot_files = dev->file - tot_files;
1688 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1689 edit_uint64_with_commas(bytes, ec1));
1694 * Scan tape by reading Bacula block by block. Report what is
1695 * on the tape. This function reads Bacula blocks, so if your
1696 * Device resource is correctly defined, it should work with
1697 * either variable or fixed block sizes.
1699 static void scan_blocks()
1701 int blocks, tot_blocks, tot_files;
1702 uint32_t block_size;
1704 DEV_BLOCK *block = dcr->block;
1706 char buf1[100], buf2[100];
1708 blocks = block_size = tot_blocks = 0;
1712 dev->update_pos(dcr);
1713 tot_files = dev->file;
1715 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1716 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1717 if (dev->state & ST_EOT) {
1720 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1723 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1729 if (dev->state & ST_EOF) {
1732 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1735 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1739 printf(_("End of File mark.\n"));
1742 if (dev->state & ST_SHORT) {
1745 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1748 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1752 printf(_("Short block read.\n"));
1755 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1758 if (block->block_len != block_size) {
1761 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1764 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1768 block_size = block->block_len;
1772 bytes += block->block_len;
1773 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1774 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1775 block->VolSessionId, block->VolSessionTime);
1777 DEV_RECORD *rec = new_record();
1778 read_record_from_block(dcr, block, rec);
1779 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1780 block->BlockNumber, dev->block_num, block->block_len,
1781 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1782 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1785 } else if (verbose > 1) {
1786 dump_block(block, "");
1791 tot_files = dev->file - tot_files;
1792 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1793 edit_uint64_with_commas(bytes, ec1));
1797 static void statcmd()
1799 int debug = debug_level;
1801 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1803 dump_volume_label(dev);
1805 debug_level = debug;
1810 * First we label the tape, then we fill
1811 * it with data get a new tape and write a few blocks.
1813 static void fillcmd()
1816 DEV_BLOCK *block = dcr->block;
1818 char buf1[100], buf2[100];
1821 uint32_t min_block_size;
1832 "This command simulates Bacula writing to a tape.\n"
1833 "It requires either one or two blank tapes, which it\n"
1834 "will label and write.\n\n"
1835 "If you have an autochanger configured, it will use\n"
1836 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1837 "be prompted to insert the tapes when necessary.\n\n"
1838 "It will print a status approximately\n"
1839 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1840 "selected the simple test option, after writing the first tape\n"
1841 "it will rewind it and re-read the last block written.\n\n"
1842 "If you have selected the multiple tape test, when the first tape\n"
1843 "fills, it will ask for a second, and after writing a few more \n"
1844 "blocks, it will stop. Then it will begin re-reading the\n"
1846 "This may take a long time -- hours! ...\n\n"));
1848 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1849 "or the complete multiple tape (m) test: (s/m) "));
1850 if (cmd[0] == 's') {
1851 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1853 } else if (cmd[0] == 'm') {
1854 Pmsg0(-1, _("Multiple tape test selected.\n"));
1857 Pmsg0(000, _("Command aborted.\n"));
1861 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1862 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1864 /* Use fixed block size to simplify read back */
1865 min_block_size = dev->min_block_size;
1866 dev->min_block_size = dev->max_block_size;
1867 set_volume_name("TestVolume1", 1);
1868 dir_ask_sysop_to_create_appendable_volume(dcr);
1869 dev->set_append(); /* force volume to be relabeled */
1872 * Acquire output device for writing. Note, after acquiring a
1873 * device, we MUST release it, which is done at the end of this
1876 Dmsg0(100, "just before acquire_device\n");
1877 if (!acquire_device_for_append(dcr)) {
1878 set_jcr_job_status(jcr, JS_ErrorTerminated);
1881 block = jcr->dcr->block;
1883 Dmsg0(100, "Just after acquire_device_for_append\n");
1885 * Write Begin Session Record
1887 if (!write_session_label(dcr, SOS_LABEL)) {
1888 set_jcr_job_status(jcr, JS_ErrorTerminated);
1889 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1893 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1895 memset(&rec, 0, sizeof(rec));
1896 rec.data = get_memory(100000); /* max record size */
1898 #define REC_SIZE 32768
1899 rec.data_len = REC_SIZE;
1902 * Put some random data in the record
1904 fd = open("/dev/urandom", O_RDONLY);
1906 read(fd, rec.data, rec.data_len);
1909 uint32_t *p = (uint32_t *)rec.data;
1910 srandom(time(NULL));
1911 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1917 * Generate data as if from File daemon, write to device
1919 jcr->dcr->VolFirstIndex = 0;
1920 time(&jcr->run_time); /* start counting time for rates */
1921 (void)localtime_r(&jcr->run_time, &tm);
1922 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1924 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1926 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1928 for (file_index = 0; ok && !job_canceled(jcr); ) {
1929 rec.VolSessionId = jcr->VolSessionId;
1930 rec.VolSessionTime = jcr->VolSessionTime;
1931 rec.FileIndex = ++file_index;
1932 rec.Stream = STREAM_FILE_DATA;
1934 /* Mix up the data just a bit */
1935 uint32_t *lp = (uint32_t *)rec.data;
1937 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1941 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1942 rec.FileIndex, rec.VolSessionId,
1943 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1946 while (!write_record_to_block(block, &rec)) {
1948 * When we get here we have just filled a block
1950 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1953 /* Write block to tape */
1954 if (!flush_block(block, 1)) {
1958 /* Every 5000 blocks (approx 322MB) report where we are.
1960 if ((block->BlockNumber % 5000) == 0) {
1962 now -= jcr->run_time;
1964 now = 1; /* prevent divide error */
1966 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1967 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1968 block->BlockNumber, dev->block_num,
1969 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1971 /* Every 32000 blocks (approx 2GB) write an EOF.
1973 if ((block->BlockNumber % 32000) == 0) {
1975 (void)localtime_r(&now, &tm);
1976 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1977 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1978 flush_block(block, 0);
1982 /* Get out after writing 10 blocks to the second tape */
1983 if (++BlockNumber > 10 && stop != 0) { /* get out */
1988 Pmsg0(000, _("Not OK\n"));
1991 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1992 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1993 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1994 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1996 /* Get out after writing 10 blocks to the second tape */
1997 if (BlockNumber > 10 && stop != 0) { /* get out */
1999 Pmsg1(-1, "Done writing %s records ...\n",
2000 edit_uint64_with_commas(write_count, ed1));
2005 Dmsg0(100, "Write_end_session_label()\n");
2006 /* Create Job status for end of session label */
2007 if (!job_canceled(jcr) && ok) {
2008 set_jcr_job_status(jcr, JS_Terminated);
2010 set_jcr_job_status(jcr, JS_ErrorTerminated);
2012 if (!write_session_label(dcr, EOS_LABEL)) {
2013 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2016 /* Write out final block of this session */
2017 if (!write_block_to_device(dcr)) {
2018 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2021 Pmsg0(-1, _("Wrote End of Session label.\n"));
2023 /* Save last block info for second tape */
2024 last_block_num2 = last_block_num;
2025 last_file2 = last_file;
2027 free_block(last_block2);
2029 last_block2 = dup_block(last_block);
2032 sprintf(buf, "%s/btape.state", working_directory);
2033 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2035 write(fd, &btape_state_level, sizeof(btape_state_level));
2036 write(fd, &simple, sizeof(simple));
2037 write(fd, &last_block_num1, sizeof(last_block_num1));
2038 write(fd, &last_block_num2, sizeof(last_block_num2));
2039 write(fd, &last_file1, sizeof(last_file1));
2040 write(fd, &last_file2, sizeof(last_file2));
2041 write(fd, last_block1->buf, last_block1->buf_len);
2042 write(fd, last_block2->buf, last_block2->buf_len);
2043 write(fd, first_block->buf, first_block->buf_len);
2045 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2046 last_block_num1, last_block_num2);
2049 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2054 (void)localtime_r(&now, &tm);
2055 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2057 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2058 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2061 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2062 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2065 jcr->dcr->block = block;
2068 dev->min_block_size = min_block_size;
2069 free_memory(rec.data);
2073 * Read two tapes written by the "fill" command and ensure
2074 * that the data is valid. If stop==1 we simulate full read back
2075 * of two tapes. If stop==-1 we simply read the last block and
2076 * verify that it is correct.
2078 static void unfillcmd()
2082 last_block1 = new_block(dev);
2083 last_block2 = new_block(dev);
2084 first_block = new_block(dev);
2085 sprintf(buf, "%s/btape.state", working_directory);
2086 fd = open(buf, O_RDONLY);
2088 uint32_t state_level;
2089 read(fd, &state_level, sizeof(btape_state_level));
2090 read(fd, &simple, sizeof(simple));
2091 read(fd, &last_block_num1, sizeof(last_block_num1));
2092 read(fd, &last_block_num2, sizeof(last_block_num2));
2093 read(fd, &last_file1, sizeof(last_file1));
2094 read(fd, &last_file2, sizeof(last_file2));
2095 read(fd, last_block1->buf, last_block1->buf_len);
2096 read(fd, last_block2->buf, last_block2->buf_len);
2097 read(fd, first_block->buf, first_block->buf_len);
2099 if (state_level != btape_state_level) {
2100 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2101 "the fill command.\n"));
2106 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2107 "You must redo the fill command.\n"), buf, be.bstrerror());
2114 static void do_unfill()
2116 DEV_BLOCK *block = dcr->block;
2123 Dmsg0(20, "Enter do_unfill\n");
2124 dev->set_cap(CAP_ANONVOLS); /* allow reading any volume */
2125 dev->clear_cap(CAP_LABEL); /* don't label anything here */
2129 time(&jcr->run_time); /* start counting time for rates */
2133 free_block(last_block);
2136 last_block_num = last_block_num1;
2137 last_file = last_file1;
2138 last_block = last_block1;
2140 free_restore_volume_list(jcr);
2142 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2143 create_restore_volume_list(jcr);
2144 if (jcr->VolList != NULL) {
2145 jcr->VolList->Slot = 1;
2146 if (jcr->VolList->next != NULL) {
2147 jcr->VolList->next->Slot = 2;
2151 set_volume_name("TestVolume1", 1);
2154 /* Multiple Volume tape */
2155 /* Close device so user can use autochanger if desired */
2156 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2159 autochanger = autoload_device(dcr, 1, NULL);
2160 if (autochanger != 1) {
2162 get_cmd(_("Mount first tape. Press enter when ready: "));
2167 dev->num_writers = 0;
2168 if (!acquire_device_for_read(dcr)) {
2169 Pmsg1(-1, "%s", dev->errmsg);
2173 * We now have the first tape mounted.
2174 * Note, re-reading last block may have caused us to
2175 * loose track of where we are (block number unknown).
2177 Pmsg0(-1, _("Rewinding.\n"));
2178 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2181 /* Read the first 10000 records */
2182 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2183 dev->file, dev->block_num);
2185 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2186 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2187 last_file, last_block_num);
2188 if (!dev->reposition(dcr, last_file, last_block_num)) {
2189 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2192 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2193 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2194 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2197 if (compare_blocks(last_block, block)) {
2199 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2201 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2208 /* restore info for last block on second Volume */
2209 last_block_num = last_block_num2;
2210 last_file = last_file2;
2211 last_block = last_block2;
2213 /* Multiple Volume tape */
2214 /* Close device so user can use autochanger if desired */
2215 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2219 set_volume_name("TestVolume2", 2);
2221 autochanger = autoload_device(dcr, 1, NULL);
2222 if (autochanger != 1) {
2224 get_cmd(_("Mount second tape. Press enter when ready: "));
2228 if (!acquire_device_for_read(dcr)) {
2229 Pmsg1(-1, "%s", dev->errmsg);
2233 /* Space to "first" block which is last block not written
2234 * on the previous tape.
2236 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2237 if (!dev->reposition(dcr, 0, 1)) {
2238 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2241 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2242 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2243 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2246 if (compare_blocks(first_block, block)) {
2247 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2250 /* Now find and compare the last block */
2251 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2252 last_file, last_block_num);
2253 if (!dev->reposition(dcr, last_file, last_block_num)) {
2254 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2257 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2258 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2259 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2262 if (compare_blocks(last_block, block)) {
2263 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2267 free_block(last_block1);
2268 free_block(last_block2);
2269 free_block(first_block);
2272 /* Read 10000 records then stop */
2273 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2275 DEVICE *dev = dcr->dev;
2277 if (quickie_count == 10000) {
2278 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2280 return quickie_count < 10000;
2283 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2286 uint32_t CheckSum, block_len;
2289 p = last_block->buf;
2291 unser_begin(q, BLKHDR2_LENGTH);
2292 unser_uint32(CheckSum);
2293 unser_uint32(block_len);
2294 while (q < (block->buf+block_len)) {
2301 dump_block(last_block, _("Last block written"));
2303 dump_block(block, _("Block read back"));
2304 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2305 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2306 "that was read back differ. The test FAILED !!!!\n"
2307 "This must be corrected before you use Bacula\n"
2308 "to write multi-tape Volumes.!!!!\n"));
2312 dump_block(last_block, _("Last block written"));
2313 dump_block(block, _("Block read back"));
2323 * Write current block to tape regardless of whether or
2324 * not it is full. If the tape fills, attempt to
2325 * acquire another tape.
2327 static int flush_block(DEV_BLOCK *block, int dump)
2331 uint32_t this_file, this_block_num;
2335 this_block = new_block(dev);
2338 last_block = new_block(dev);
2341 this_file = dev->file;
2342 this_block_num = dev->block_num;
2343 if (!write_block_to_dev(dcr)) {
2344 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2345 last_file, last_block_num, this_block_num);
2348 * This is 1st tape, so save first tape info separate
2349 * from second tape info
2351 last_block_num1 = last_block_num;
2352 last_file1 = last_file;
2353 last_block1 = dup_block(last_block);
2354 last_block2 = dup_block(last_block);
2355 first_block = dup_block(block); /* first block second tape */
2358 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2359 (unsigned)file_index, block->BlockNumber, block->block_len);
2360 dump_block(last_block, _("Last block written"));
2362 dump_block(block, _("Block not written"));
2365 eot_block = block->BlockNumber;
2366 eot_block_len = block->block_len;
2367 eot_FileIndex = file_index;
2371 now -= jcr->run_time;
2373 now = 1; /* don't divide by zero */
2375 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2376 vol_size = dev->VolCatInfo.VolCatBytes;
2377 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2378 dev->file, dev->block_num,
2379 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2382 stop = -1; /* stop, but do simplified test */
2384 /* Full test in progress */
2385 if (!fixup_device_block_write_error(jcr->dcr)) {
2386 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2391 BlockNumber = 0; /* start counting for second tape */
2394 return 1; /* end of tape reached */
2397 /* Save contents after write so that the header is serialized */
2398 memcpy(this_block->buf, block->buf, this_block->buf_len);
2401 * Note, we always read/write to block, but we toggle
2402 * copying it to one or another of two allocated blocks.
2403 * Switch blocks so that the block just successfully written is
2404 * always in last_block.
2406 tblock = last_block;
2407 last_block = this_block;
2408 this_block = tblock;
2409 last_file = this_file;
2410 last_block_num = this_block_num;
2418 * First we label the tape, then we fill
2419 * it with data get a new tape and write a few blocks.
2421 static void qfillcmd()
2423 DEV_BLOCK *block = dcr->block;
2424 DEV_RECORD *rec = dcr->rec;
2427 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2429 get_cmd(_("How many blocks do you want to write? (1000): "));
2436 sm_check(__FILE__, __LINE__, false);
2438 i = block->buf_len - 100;
2440 rec->data = check_pool_memory_size(rec->data, i);
2441 memset(rec->data, i & 0xFF, i);
2444 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2445 for (i=0; i < count; i++) {
2450 if (!write_record_to_block(block, rec)) {
2451 Pmsg0(0, _("Error writing record to block.\n"));
2454 if (!write_block_to_dev(dcr)) {
2455 Pmsg0(0, _("Error writing block to device.\n"));
2461 if (dev->has_cap(CAP_TWOEOF)) {
2468 sm_check(__FILE__, __LINE__, false);
2472 * Fill a tape using raw write() command
2474 static void rawfill_cmd()
2476 DEV_BLOCK *block = dcr->block;
2479 uint32_t block_num = 0;
2484 fd = open("/dev/urandom", O_RDONLY);
2486 read(fd, block->buf, block->buf_len);
2489 uint32_t *p = (uint32_t *)block->buf;
2490 srandom(time(NULL));
2491 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2495 p = (uint32_t *)block->buf;
2496 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2499 if (dev->is_tape()) {
2500 stat = tape_write(dev->fd(), block->buf, block->buf_len);
2502 stat = write(dev->fd(), block->buf, block->buf_len);
2504 if (stat == (int)block->buf_len) {
2505 if ((block_num++ % 100) == 0) {
2510 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2520 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2521 be.bstrerror(my_errno));
2527 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2528 static struct cmdstruct commands[] = {
2529 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2530 {NT_("bsf"), bsfcmd, _("backspace file")},
2531 {NT_("bsr"), bsrcmd, _("backspace record")},
2532 {NT_("cap"), capcmd, _("list device capabilities")},
2533 {NT_("clear"), clearcmd, _("clear tape errors")},
2534 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2535 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2536 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2537 {NT_("unfill"), unfillcmd, _("read filled tape")},
2538 {NT_("fsf"), fsfcmd, _("forward space a file")},
2539 {NT_("fsr"), fsrcmd, _("forward space a record")},
2540 {NT_("help"), helpcmd, _("print this command")},
2541 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2542 {NT_("load"), loadcmd, _("load a tape")},
2543 {NT_("quit"), quitcmd, _("quit btape")},
2544 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2545 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2546 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2547 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2548 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2549 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2550 {NT_("status"), statcmd, _("print tape status")},
2551 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2552 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2553 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2554 {NT_("rr"), rrcmd, _("read a single record")},
2555 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2556 {NT_("qfill"), qfillcmd, _("quick fill command")}
2558 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2566 while (!quit && get_cmd("*")) {
2567 sm_check(__FILE__, __LINE__, false);
2569 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2570 for (i=0; i<comsize; i++) /* search for command */
2571 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2572 (*commands[i].func)(); /* go execute command */
2577 Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2582 static void helpcmd()
2586 printf(_("Interactive commands:\n"));
2587 printf(_(" Command Description\n ======= ===========\n"));
2588 for (i=0; i<comsize; i++)
2589 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2597 "\nVersion: %s (%s)\n\n"
2598 "Usage: btape <options> <device_name>\n"
2599 " -b <file> specify bootstrap file\n"
2600 " -c <file> set configuration file to file\n"
2601 " -d <nn> set debug level to nn\n"
2602 " -p proceed inspite of I/O errors\n"
2603 " -s turn off signals\n"
2605 " -? print this message.\n"
2606 "\n"), 2000, VERSION, BDATE);
2611 * Get next input command from terminal. This
2612 * routine is REALLY primitive, and should be enhanced
2613 * to have correct backspacing, etc.
2616 get_cmd(const char *prompt)
2620 fprintf(stdout, prompt);
2622 /* We really should turn off echoing and pretty this
2626 while ((ch = fgetc(stdin)) != EOF) {
2628 strip_trailing_junk(cmd);
2630 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2643 /* Dummies to replace askdir.c */
2644 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2645 bool dir_send_job_status(JCR *jcr) {return 1;}
2647 bool dir_update_volume_info(DCR *dcr, bool relabel)
2653 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2655 Dmsg0(20, "Enter dir_get_volume_info\n");
2656 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2660 bool dir_create_jobmedia_record(DCR *dcr)
2662 dcr->WroteVol = false;
2667 bool dir_find_next_appendable_volume(DCR *dcr)
2669 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2670 return dcr->VolumeName[0] != 0;
2673 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2675 DEVICE *dev = dcr->dev;
2676 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2677 if (dcr->VolumeName[0] == 0) {
2678 return dir_ask_sysop_to_create_appendable_volume(dcr);
2680 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2681 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2682 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2685 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2686 dcr->VolumeName, dev->print_name());
2693 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2696 DEVICE *dev = dcr->dev;
2697 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2699 set_volume_name("TestVolume1", 1);
2701 set_volume_name("TestVolume2", 2);
2703 /* Close device so user can use autochanger if desired */
2704 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2707 autochanger = autoload_device(dcr, 1, NULL);
2708 if (autochanger != 1) {
2709 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2720 static bool my_mount_next_read_volume(DCR *dcr)
2723 JCR *jcr = dcr->jcr;
2724 DEV_BLOCK *block = dcr->block;
2726 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2727 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2730 if (LastBlock != block->BlockNumber) {
2731 VolBytes += block->block_len;
2733 LastBlock = block->BlockNumber;
2735 now -= jcr->run_time;
2739 kbs = (double)VolBytes / (1000.0 * (double)now);
2740 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2741 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2743 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2748 set_volume_name("TestVolume2", 2);
2751 if (!acquire_device_for_read(dcr)) {
2752 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2755 return true; /* next volume mounted */
2758 static void set_volume_name(const char *VolName, int volnum)
2760 DCR *dcr = jcr->dcr;
2761 VolumeName = VolName;
2763 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2764 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2765 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2766 dcr->VolCatInfo.Slot = volnum;
2767 dcr->VolCatInfo.InChanger = true;