2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2009 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 Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * Bacula Tape manipulation program
32 * Has various tape manipulation commands -- mostly for
33 * use in determining how tapes really work.
35 * Kern Sibbald, April MM
37 * Note, this program reads stored.conf, and will only
38 * talk to devices that are configured.
52 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
53 extern bool parse_sd_config(CONFIG *config, const char *configfile, int exit_code);
55 /* External subroutines */
56 extern void free_config_resources();
58 /* Exported variables */
61 int bsize = TAPE_BSIZE;
62 char VolName[MAX_NAME_LENGTH];
63 STORES *me = NULL; /* our Global resource */
64 bool forge_on = false; /* proceed inspite of I/O errors */
65 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
66 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
69 * If you change the format of the state file,
70 * increment this value
72 static uint32_t btape_state_level = 2;
76 DEVRES *device = NULL;
80 /* Forward referenced subroutines */
81 static void do_tape_cmds();
82 static void helpcmd();
83 static void scancmd();
84 static void rewindcmd();
85 static void clearcmd();
90 static void fillcmd();
91 static void qfillcmd();
92 static void statcmd();
93 static void unfillcmd();
94 static int flush_block(DEV_BLOCK *block, int dump);
95 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
96 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
97 static bool my_mount_next_read_volume(DCR *dcr);
98 static void scan_blocks();
99 static void set_volume_name(const char *VolName, int volnum);
100 static void rawfill_cmd();
101 static bool open_the_device();
102 static void autochangercmd();
103 static void do_unfill();
106 /* Static variables */
107 static CONFIG *config;
108 #define CONFIG_FILE "bacula-sd.conf"
109 char *configfile = NULL;
111 #define MAX_CMD_ARGS 30
113 static POOLMEM *args;
114 static char *argk[MAX_CMD_ARGS];
115 static char *argv[MAX_CMD_ARGS];
118 static int quickie_count = 0;
119 static uint64_t write_count = 0;
120 static BSR *bsr = NULL;
121 static int signals = TRUE;
124 static uint64_t vol_size;
125 static uint64_t VolBytes;
128 static int32_t file_index;
129 static int end_of_tape = 0;
130 static uint32_t LastBlock = 0;
131 static uint32_t eot_block;
132 static uint32_t eot_block_len;
133 static uint32_t eot_FileIndex;
134 static int dumped = 0;
135 static DEV_BLOCK *last_block1 = NULL;
136 static DEV_BLOCK *last_block2 = NULL;
137 static DEV_BLOCK *last_block = NULL;
138 static DEV_BLOCK *this_block = NULL;
139 static DEV_BLOCK *first_block = NULL;
140 static uint32_t last_file1 = 0;
141 static uint32_t last_file2 = 0;
142 static uint32_t last_file = 0;
143 static uint32_t last_block_num1 = 0;
144 static uint32_t last_block_num2 = 0;
145 static uint32_t last_block_num = 0;
146 static uint32_t BlockNumber = 0;
147 static bool simple = true;
149 static const char *VolumeName = NULL;
150 static int vol_num = 0;
152 static JCR *jcr = NULL;
156 static void terminate_btape(int sig);
157 int get_cmd(const char *prompt);
160 /*********************************************************************
162 * Bacula tape testing program
165 int main(int margc, char *margv[])
172 setlocale(LC_ALL, "");
173 bindtextdomain("bacula", LOCALEDIR);
174 textdomain("bacula");
178 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
179 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
180 TAPE_BSIZE, B_DEV_BSIZE);
182 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
183 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
185 if (sizeof(boffset_t) < 8) {
186 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. boffset_t=%d should be 8 or more !!!!!\n\n\n"),
190 bsnprintf(buf, sizeof(buf), "%u", x32);
191 i = bsscanf(buf, "%lu", &y32);
192 if (i != 1 || x32 != y32) {
193 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
199 bsnprintf(buf, sizeof(buf), "%" llu, x64);
200 i = bsscanf(buf, "%llu", &y64);
201 if (i != 1 || x64 != y64) {
202 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
207 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
209 working_directory = "/tmp";
210 my_name_is(margc, margv, "btape");
211 init_msg(NULL, NULL);
215 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
217 case 'b': /* bootstrap file */
218 bsr = parse_bsr(NULL, optarg);
219 // dump_bsr(bsr, true);
222 case 'c': /* specify config file */
223 if (configfile != NULL) {
226 configfile = bstrdup(optarg);
229 case 'd': /* set debug level */
230 if (*optarg == 't') {
231 dbg_timestamp = true;
233 debug_level = atoi(optarg);
234 if (debug_level <= 0) {
262 cmd = get_pool_memory(PM_FNAME);
263 args = get_pool_memory(PM_FNAME);
266 init_signals(terminate_btape);
269 if (configfile == NULL) {
270 configfile = bstrdup(CONFIG_FILE);
273 daemon_start_time = time(NULL);
275 config = new_config_parser();
276 parse_sd_config(config, configfile, M_ERROR_TERM);
278 /* See if we can open a device */
280 Pmsg0(000, _("No archive name specified.\n"));
283 } else if (margc != 1) {
284 Pmsg0(000, _("Improper number of arguments specified.\n"));
289 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
298 Pmsg0(000, _("btape does not work with DVD storage.\n"));
302 if (!dev->is_tape()) {
303 Pmsg0(000, _("btape only works with tape storage.\n"));
308 if (!open_the_device()) {
312 Dmsg0(200, "Do tape commands\n");
316 terminate_btape(exit_code);
319 static void terminate_btape(int stat)
322 sm_check(__FILE__, __LINE__, false);
327 config->free_resources();
332 free_pool_memory(args);
336 free_pool_memory(cmd);
353 if (debug_level > 10)
354 print_memory_pool_stats();
357 free_block(this_block);
362 term_last_jobs_list();
363 close_memory_pool(); /* free memory in pool */
370 static bool open_the_device()
375 block = new_block(dev);
377 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
378 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
379 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
383 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
384 dev->set_append(); /* put volume in append mode */
399 * Write a label to the tape
401 static void labelcmd()
404 pm_strcpy(cmd, VolumeName);
406 if (!get_cmd(_("Enter Volume Name: "))) {
411 if (!dev->is_open()) {
412 if (!first_open_device(dcr)) {
413 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
417 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
418 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
422 * Read the tape label
424 static void readlabelcmd()
426 int save_debug_level = debug_level;
429 stat = read_dev_volume_label(dcr);
432 Pmsg0(0, _("Volume has no label.\n"));
435 Pmsg0(0, _("Volume label read correctly.\n"));
438 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
441 Pmsg0(0, _("Volume name error\n"));
443 case VOL_CREATE_ERROR:
444 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
446 case VOL_VERSION_ERROR:
447 Pmsg0(0, _("Volume version error.\n"));
449 case VOL_LABEL_ERROR:
450 Pmsg0(0, _("Bad Volume label type.\n"));
453 Pmsg0(0, _("Unknown error.\n"));
458 dump_volume_label(dev);
459 debug_level = save_debug_level;
464 * Load the tape should have prevously been taken
465 * off line, otherwise this command is not necessary.
467 static void loadcmd()
470 if (!load_dev(dev)) {
471 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
473 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
479 static void rewindcmd()
481 if (!dev->rewind(dcr)) {
482 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
485 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
490 * Clear any tape error
492 static void clearcmd()
498 * Write and end of file on the tape
500 static void weofcmd()
510 if (!dev->weof(num)) {
511 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
515 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
518 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
524 /* Go to the end of the medium -- raw command
525 * The idea was orginally that the end of the Bacula
526 * medium would be flagged differently. This is not
527 * currently the case. So, this is identical to the
532 if (!dev->eod(dcr)) {
533 Pmsg1(0, "%s", dev->bstrerror());
536 Pmsg0(0, _("Moved to end of medium.\n"));
541 * Go to the end of the medium (either hardware determined
542 * or defined by two eofs.
562 if (!dev->bsf(num)) {
563 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
565 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
581 if (!dev->bsr(num)) {
582 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
584 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
589 * List device capabilities as defined in the
594 printf(_("Configured device capabilities:\n"));
595 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
596 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
597 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
598 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
599 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
600 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
601 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
602 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
603 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
604 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
605 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
606 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
607 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
608 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
609 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
612 printf(_("Device status:\n"));
613 printf("%sOPENED ", dev->is_open() ? "" : "!");
614 printf("%sTAPE ", dev->is_tape() ? "" : "!");
615 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
616 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
617 printf("%sAPPEND ", dev->can_append() ? "" : "!");
618 printf("%sREAD ", dev->can_read() ? "" : "!");
619 printf("%sEOT ", dev->at_eot() ? "" : "!");
620 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
621 printf("%sEOF ", dev->at_eof() ? "" : "!");
622 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
623 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
626 printf(_("Device parameters:\n"));
627 printf("Device name: %s\n", dev->dev_name);
628 printf("File=%u block=%u\n", dev->file, dev->block_num);
629 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
631 printf(_("Status:\n"));
637 * Test writing larger and larger records.
638 * This is a torture test for records.
640 static void rectestcmd()
646 Pmsg0(0, _("Test writing larger and larger records.\n"
647 "This is a torture test for records.\nI am going to write\n"
648 "larger and larger records. It will stop when the record size\n"
649 "plus the header exceeds the block size (by default about 64K)\n"));
652 get_cmd(_("Do you want to continue? (y/n): "));
654 Pmsg0(000, _("Command aborted.\n"));
658 sm_check(__FILE__, __LINE__, false);
659 block = new_block(dev);
662 for (i=1; i<500000; i++) {
663 rec->data = check_pool_memory_size(rec->data, i);
664 memset(rec->data, i & 0xFF, i);
666 sm_check(__FILE__, __LINE__, false);
667 if (write_record_to_block(block, rec)) {
670 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
674 sm_check(__FILE__, __LINE__, false);
678 sm_check(__FILE__, __LINE__, false);
682 * This test attempts to re-read a block written by Bacula
683 * normally at the end of the tape. Bacula will then back up
684 * over the two eof marks, backup over the record and reread
685 * it to make sure it is valid. Bacula can skip this validation
686 * if you set "Backward space record = no"
688 static bool re_read_block_test()
690 DEV_BLOCK *block = dcr->block;
695 if (!(dev->capabilities & CAP_BSR)) {
696 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
700 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
701 "I'm going to write three records and an EOF\n"
702 "then backup over the EOF and re-read the last record.\n"
703 "Bacula does this after writing the last block on the\n"
704 "tape to verify that the block was written correctly.\n\n"
705 "This is not an *essential* feature ...\n\n"));
709 rec->data = check_pool_memory_size(rec->data, block->buf_len);
710 len = rec->data_len = block->buf_len-100;
711 memset(rec->data, 1, rec->data_len);
712 if (!write_record_to_block(block, rec)) {
713 Pmsg0(0, _("Error writing record to block.\n"));
716 if (!write_block_to_dev(dcr)) {
717 Pmsg0(0, _("Error writing block to device.\n"));
720 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
722 memset(rec->data, 2, rec->data_len);
723 if (!write_record_to_block(block, rec)) {
724 Pmsg0(0, _("Error writing record to block.\n"));
727 if (!write_block_to_dev(dcr)) {
728 Pmsg0(0, _("Error writing block to device.\n"));
731 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
733 memset(rec->data, 3, rec->data_len);
734 if (!write_record_to_block(block, rec)) {
735 Pmsg0(0, _("Error writing record to block.\n"));
738 if (!write_block_to_dev(dcr)) {
739 Pmsg0(0, _("Error writing block to device.\n"));
742 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
745 if (dev->has_cap(CAP_TWOEOF)) {
749 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
752 if (dev->has_cap(CAP_TWOEOF)) {
754 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
758 Pmsg0(0, _("Backspaced over EOF OK.\n"));
760 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
763 Pmsg0(0, _("Backspace record OK.\n"));
764 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
766 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
769 memset(rec->data, 0, rec->data_len);
770 if (!read_record_from_block(dcr, block, rec)) {
772 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
775 for (int i=0; i<len; i++) {
776 if (rec->data[i] != 3) {
777 Pmsg0(0, _("Bad data in record. Test failed!\n"));
781 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
782 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
789 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
790 "this function to verify the last block written to the\n"
791 "tape. Bacula will skip the last block verification\n"
793 "Backward Space Record = No\n\n"
794 "to your Storage daemon's Device resource definition.\n"));
799 const int num_recs = 10000;
801 static bool write_two_files()
807 bool rc = false; /* bad return code */
809 Pmsg2(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
810 "I'm going to write %d records and an EOF\n"
811 "then write %d records and an EOF, then rewind,\n"
812 "and re-read the data to verify that it is correct.\n\n"
813 "This is an *essential* feature ...\n\n"), num_recs, num_recs);
818 rec->data = check_pool_memory_size(rec->data, block->buf_len);
819 rec->data_len = block->buf_len-100;
820 len = rec->data_len/sizeof(i);
822 if (!dev->rewind(dcr)) {
823 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
827 for (i=1; i<=num_recs; i++) {
828 p = (int *)rec->data;
829 for (j=0; j<len; j++) {
832 if (!write_record_to_block(block, rec)) {
833 Pmsg0(0, _("Error writing record to block.\n"));
836 if (!write_block_to_dev(dcr)) {
837 Pmsg0(0, _("Error writing block to device.\n"));
841 Pmsg2(0, _("Wrote %d blocks of %d bytes.\n"), num_recs, rec->data_len);
843 for (i=num_recs+1; i<=2*num_recs; i++) {
844 p = (int *)rec->data;
845 for (j=0; j<len; j++) {
848 if (!write_record_to_block(block, rec)) {
849 Pmsg0(0, _("Error writing record to block.\n"));
852 if (!write_block_to_dev(dcr)) {
853 Pmsg0(0, _("Error writing block to device.\n"));
857 Pmsg2(0, _("Wrote %d blocks of %d bytes.\n"), num_recs, rec->data_len);
859 if (dev->has_cap(CAP_TWOEOF)) {
874 * This test writes Bacula blocks to the tape in
875 * several files. It then rewinds the tape and attepts
876 * to read these blocks back checking the data.
878 static bool write_read_test()
888 if (!write_two_files()) {
895 if (!dev->rewind(dcr)) {
896 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
899 Pmsg0(0, _("Rewind OK.\n"));
902 rec->data = check_pool_memory_size(rec->data, block->buf_len);
903 rec->data_len = block->buf_len-100;
904 len = rec->data_len/sizeof(i);
906 /* Now read it back */
907 for (i=1; i<=2*num_recs; i++) {
909 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
911 if (dev_state(dev, ST_EOF)) {
912 Pmsg0(-1, _("Got EOF on tape.\n"));
913 if (i == num_recs+1) {
917 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
920 memset(rec->data, 0, rec->data_len);
921 if (!read_record_from_block(dcr, block, rec)) {
923 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
926 p = (int *)rec->data;
927 for (j=0; j<len; j++) {
929 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
935 if (i == num_recs || i == 2*num_recs) {
936 Pmsg1(-1, _("%d blocks re-read correctly.\n"), num_recs);
939 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
951 * This test writes Bacula blocks to the tape in
952 * several files. It then rewinds the tape and attepts
953 * to read these blocks back checking the data.
955 static bool position_test()
957 DEV_BLOCK *block = dcr->block;
963 int file = 0, blk = 0;
965 bool got_eof = false;
967 Pmsg0(0, _("Block position test\n"));
971 rec->data = check_pool_memory_size(rec->data, block->buf_len);
972 rec->data_len = block->buf_len-100;
973 len = rec->data_len/sizeof(j);
975 if (!dev->rewind(dcr)) {
976 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
979 Pmsg0(0, _("Rewind OK.\n"));
983 /* Set up next item to read based on where we are */
984 /* At each step, recno is what we print for the "block number"
985 * and file, blk are the real positions to go to.
1009 recno = num_recs+601;
1022 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1023 if (!dev->reposition(dcr, file, blk)) {
1024 Pmsg0(0, _("Reposition error.\n"));
1028 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1030 if (dev_state(dev, ST_EOF)) {
1031 Pmsg0(-1, _("Got EOF on tape.\n"));
1037 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1038 recno, file, blk, be.bstrerror(dev->dev_errno));
1039 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1040 " set to variable blocking as normally used by Bacula.\n"
1041 " Please see the Tape Testing chapter in the manual and \n"
1042 " look for using mt with defblksize and setoptions\n"
1043 "If your tape drive block size is correct, then perhaps\n"
1044 " your SCSI driver is *really* stupid and does not\n"
1045 " correctly report the file:block after a FSF. In this\n"
1046 " case try setting:\n"
1047 " Fast Forward Space File = no\n"
1048 " in your Device resource.\n"));
1052 memset(rec->data, 0, rec->data_len);
1053 if (!read_record_from_block(dcr, block, rec)) {
1055 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1058 p = (int *)rec->data;
1059 for (j=0; j<len; j++) {
1060 if (p[j] != recno) {
1061 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1066 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1068 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1080 * This test writes some records, then writes an end of file,
1081 * rewinds the tape, moves to the end of the data and attepts
1082 * to append to the tape. This function is essential for
1083 * Bacula to be able to write multiple jobs to the tape.
1085 static int append_test()
1087 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1088 "This test is essential to Bacula.\n\n"
1089 "I'm going to write one record in file 0,\n"
1090 " two records in file 1,\n"
1091 " and three records in file 2\n\n"));
1095 weofcmd(); /* end file 0 */
1098 weofcmd(); /* end file 1 */
1102 weofcmd(); /* end file 2 */
1103 if (dev->has_cap(CAP_TWOEOF)) {
1106 dev->close(); /* release device */
1107 if (!open_the_device()) {
1111 Pmsg0(0, _("Now moving to end of medium.\n"));
1113 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1114 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1116 if (dev->file != 3) {
1120 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1123 if (dev->has_cap(CAP_TWOEOF)) {
1127 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1128 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1130 Pmsg0(-1, _("End scanning the tape.\n"));
1131 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1132 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1134 if (dev->file != 4) {
1142 * This test exercises the autochanger
1144 static int autochanger_test()
1146 POOLMEM *results, *changer;
1147 int slot, status, loaded;
1148 int timeout = dcr->device->max_changer_wait;
1151 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1152 if (!dev->has_cap(CAP_AUTOCHANGER)) {
1155 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1156 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1160 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1161 "To test the autochanger you must have a blank tape\n"
1162 " that I can write on in Slot 1.\n"));
1163 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1166 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1170 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1172 results = get_pool_memory(PM_MESSAGE);
1173 changer = get_pool_memory(PM_FNAME);
1177 dcr->VolCatInfo.Slot = slot;
1178 /* Find out what is loaded, zero means device is unloaded */
1179 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1180 changer = edit_device_codes(dcr, changer,
1181 dcr->device->changer_command, "loaded");
1182 status = run_program(changer, timeout, results);
1183 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1185 loaded = atoi(results);
1188 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1189 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1193 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1195 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1197 Dmsg1(100, "Results from loaded query=%s\n", results);
1199 dcr->VolCatInfo.Slot = loaded;
1200 /* We are going to load a new tape, so close the device */
1202 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1203 loaded, dev->drive_index);
1204 changer = edit_device_codes(dcr, changer,
1205 dcr->device->changer_command, "unload");
1206 status = run_program(changer, timeout, results);
1207 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1210 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1211 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1220 dcr->VolCatInfo.Slot = slot;
1221 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1222 slot, dev->drive_index);
1223 changer = edit_device_codes(dcr, changer,
1224 dcr->device->changer_command, "load");
1225 Dmsg1(100, "Changer=%s\n", changer);
1227 status = run_program(changer, timeout, results);
1229 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1230 slot, dev->drive_index);
1233 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1234 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1238 if (!open_the_device()) {
1242 * Start with sleep_time 0 then increment by 30 seconds if we get
1245 bmicrosleep(sleep_time, 0);
1246 if (!dev->rewind(dcr) || !dev->weof(1)) {
1247 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1249 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1250 "a longer sleep time in the mtx-script in the load) case.\n"
1251 "Adding a 30 second sleep and trying again ...\n"));
1255 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1258 if (!dev->weof(1)) {
1259 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1262 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1266 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1268 "to your mtx-changer script in the load) case.\n\n"),
1271 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1274 free_pool_memory(changer);
1275 free_pool_memory(results);
1280 free_pool_memory(changer);
1281 free_pool_memory(results);
1282 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1286 static void autochangercmd()
1293 * This test assumes that the append test has been done,
1294 * then it tests the fsf function.
1296 static bool fsf_test()
1298 bool set_off = false;
1300 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1301 "This test is essential to Bacula.\n\n"
1302 "I'm going to write five files then test forward spacing\n\n"));
1306 weofcmd(); /* end file 0 */
1309 weofcmd(); /* end file 1 */
1313 weofcmd(); /* end file 2 */
1316 weofcmd(); /* end file 3 */
1318 weofcmd(); /* end file 4 */
1319 if (dev->has_cap(CAP_TWOEOF)) {
1325 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1327 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1330 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1331 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1333 if (dev->file != 1) {
1337 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1339 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1342 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1343 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1345 if (dev->file != 3) {
1350 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1352 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1355 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1356 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1358 if (dev->file != 4) {
1362 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1363 " Fast Forward Space File = no\n\n"
1364 "to your Device resource for this drive.\n"));
1368 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1370 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1372 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1373 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1374 if (dev->file != 5) {
1377 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1381 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1382 if (dev->has_cap(CAP_FASTFSF)) {
1383 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1384 "I am turning it off then retrying the test.\n"));
1385 dev->clear_cap(CAP_FASTFSF);
1389 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1390 "Some systems, e.g. OpenBSD, require you to set\n"
1391 " Use MTIOCGET= no\n"
1392 "in your device resource. Use with caution.\n"));
1401 * This is a general test of Bacula's functions
1402 * needed to read and write the tape.
1404 static void testcmd()
1408 if (!write_read_test()) {
1412 if (!position_test()) {
1417 stat = append_test();
1418 if (stat == 1) { /* OK get out */
1421 if (stat == -1) { /* first test failed */
1422 if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1423 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1424 "Setting \"Hardware End of Medium = no\n"
1425 " and \"Fast Forward Space File = no\n"
1426 "and retrying append test.\n\n"));
1427 dev->clear_cap(CAP_EOM); /* turn off eom */
1428 dev->clear_cap(CAP_FASTFSF); /* turn off fast fsf */
1429 stat = append_test();
1431 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1432 " Hardware End of Medium = No\n\n"
1433 " Fast Forward Space File = No\n"
1434 "to your Device resource in the Storage conf file.\n"));
1438 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1441 /* Wrong count after append */
1443 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1444 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1445 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1446 stat = append_test();
1448 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1449 " Hardware End of Medium = No\n"
1450 " Fast Forward Space File = No\n"
1451 " BSF at EOM = yes\n\n"
1452 "to your Device resource in the Storage conf file.\n"));
1459 Pmsg0(-1, _("\nAppend test failed.\n\n"
1460 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1461 "Unable to correct the problem. You MUST fix this\n"
1462 "problem before Bacula can use your tape drive correctly\n"
1463 "\nPerhaps running Bacula in fixed block mode will work.\n"
1464 "Do so by setting:\n\n"
1465 "Minimum Block Size = nnn\n"
1466 "Maximum Block Size = nnn\n\n"
1467 "in your Storage daemon's Device definition.\n"
1468 "nnn must match your tape driver's block size, which\n"
1469 "can be determined by reading your tape manufacturers\n"
1470 "information, and the information on your kernel dirver.\n"
1471 "Fixed block sizes, however, are not normally an ideal solution.\n"
1473 "Some systems, e.g. OpenBSD, require you to set\n"
1474 " Use MTIOCGET= no\n"
1475 "in your device resource. Use with caution.\n"));
1481 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1482 "Please double check it ...\n"
1483 "=== Sample correct output ===\n"
1484 "1 block of 64448 bytes in file 1\n"
1485 "End of File mark.\n"
1486 "2 blocks of 64448 bytes in file 2\n"
1487 "End of File mark.\n"
1488 "3 blocks of 64448 bytes in file 3\n"
1489 "End of File mark.\n"
1490 "1 block of 64448 bytes in file 4\n"
1491 "End of File mark.\n"
1492 "Total files=4, blocks=7, bytes = 451,136\n"
1493 "=== End sample correct output ===\n\n"
1494 "If the above scan output is not identical to the\n"
1495 "sample output, you MUST correct the problem\n"
1496 "or Bacula will not be able to write multiple Jobs to \n"
1500 if (!re_read_block_test()) {
1505 if (!fsf_test()) { /* do fast forward space file test */
1509 autochanger_test(); /* do autochanger test */
1513 /* Forward space a file */
1514 static void fsfcmd()
1518 num = atoi(argk[1]);
1523 if (!dev->fsf(num)) {
1524 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1528 Pmsg0(0, _("Forward spaced 1 file.\n"));
1531 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1535 /* Forward space a record */
1536 static void fsrcmd()
1540 num = atoi(argk[1]);
1545 if (!dev->fsr(num)) {
1546 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1550 Pmsg0(0, _("Forward spaced 1 record.\n"));
1553 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1558 * Read a Bacula block from the tape
1562 dev->open(dcr, OPEN_READ_ONLY);
1563 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1567 * Write a Bacula block to the tape
1571 DEV_BLOCK *block = dcr->block;
1572 DEV_RECORD *rec = dcr->rec;
1575 if (!dev->is_open()) {
1578 sm_check(__FILE__, __LINE__, false);
1581 dump_block(block, "test");
1584 i = block->buf_len - 100;
1586 rec->data = check_pool_memory_size(rec->data, i);
1587 memset(rec->data, i & 0xFF, i);
1589 sm_check(__FILE__, __LINE__, false);
1590 if (!write_record_to_block(block, rec)) {
1591 Pmsg0(0, _("Error writing record to block.\n"));
1594 if (!write_block_to_dev(dcr)) {
1595 Pmsg0(0, _("Error writing block to device.\n"));
1598 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1600 Pmsg0(0, _("Wrote block to device.\n"));
1603 sm_check(__FILE__, __LINE__, false);
1604 sm_check(__FILE__, __LINE__, false);
1608 * Read a record from the tape
1615 if (!get_cmd(_("Enter length to read: "))) {
1619 if (len < 0 || len > 1000000) {
1620 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1623 buf = (char *)malloc(len);
1624 stat = read(dev->fd(), buf, len);
1625 if (stat > 0 && stat <= len) {
1629 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1630 len, stat, be.bstrerror());
1636 * Scan tape by reading block by block. Report what is
1637 * on the tape. Note, this command does raw reads, and as such
1638 * will not work with fixed block size devices.
1640 static void scancmd()
1643 int blocks, tot_blocks, tot_files;
1649 blocks = block_size = tot_blocks = 0;
1651 if (dev->state & ST_EOT) {
1652 Pmsg0(0, _("End of tape\n"));
1655 dev->update_pos(dcr);
1656 tot_files = dev->file;
1657 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1659 if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1662 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1663 dev->dev_name, be.bstrerror());
1664 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1667 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1670 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1675 Dmsg1(200, "read status = %d\n", stat);
1677 if (stat != block_size) {
1678 dev->update_pos(dcr);
1681 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1684 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1690 if (stat == 0) { /* EOF */
1691 dev->update_pos(dcr);
1692 printf(_("End of File mark.\n"));
1693 /* Two reads of zero means end of tape */
1694 if (dev->state & ST_EOF)
1695 dev->state |= ST_EOT;
1697 dev->state |= ST_EOF;
1700 if (dev->state & ST_EOT) {
1701 printf(_("End of tape\n"));
1704 } else { /* Got data */
1705 dev->state &= ~ST_EOF;
1711 dev->update_pos(dcr);
1712 tot_files = dev->file - tot_files;
1713 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1714 edit_uint64_with_commas(bytes, ec1));
1719 * Scan tape by reading Bacula block by block. Report what is
1720 * on the tape. This function reads Bacula blocks, so if your
1721 * Device resource is correctly defined, it should work with
1722 * either variable or fixed block sizes.
1724 static void scan_blocks()
1726 int blocks, tot_blocks, tot_files;
1727 uint32_t block_size;
1729 DEV_BLOCK *block = dcr->block;
1731 char buf1[100], buf2[100];
1733 blocks = block_size = tot_blocks = 0;
1737 dev->update_pos(dcr);
1738 tot_files = dev->file;
1740 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1741 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1742 if (dev->state & ST_EOT) {
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);
1754 if (dev->state & ST_EOF) {
1757 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1760 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1764 printf(_("End of File mark.\n"));
1767 if (dev->state & ST_SHORT) {
1770 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1773 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1777 printf(_("Short block read.\n"));
1780 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1783 if (block->block_len != block_size) {
1786 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1789 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1793 block_size = block->block_len;
1797 bytes += block->block_len;
1798 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1799 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1800 block->VolSessionId, block->VolSessionTime);
1802 DEV_RECORD *rec = new_record();
1803 read_record_from_block(dcr, block, rec);
1804 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1805 block->BlockNumber, dev->block_num, block->block_len,
1806 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1807 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1810 } else if (verbose > 1) {
1811 dump_block(block, "");
1816 tot_files = dev->file - tot_files;
1817 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1818 edit_uint64_with_commas(bytes, ec1));
1822 static void statcmd()
1824 int debug = debug_level;
1826 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1828 dump_volume_label(dev);
1830 debug_level = debug;
1835 * First we label the tape, then we fill
1836 * it with data get a new tape and write a few blocks.
1838 static void fillcmd()
1841 DEV_BLOCK *block = dcr->block;
1843 char buf1[100], buf2[100];
1846 uint32_t min_block_size;
1857 "This command simulates Bacula writing to a tape.\n"
1858 "It requires either one or two blank tapes, which it\n"
1859 "will label and write.\n\n"
1860 "If you have an autochanger configured, it will use\n"
1861 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1862 "be prompted to insert the tapes when necessary.\n\n"
1863 "It will print a status approximately\n"
1864 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1865 "selected the simple test option, after writing the first tape\n"
1866 "it will rewind it and re-read the last block written.\n\n"
1867 "If you have selected the multiple tape test, when the first tape\n"
1868 "fills, it will ask for a second, and after writing a few more \n"
1869 "blocks, it will stop. Then it will begin re-reading the\n"
1871 "This may take a long time -- hours! ...\n\n"));
1873 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1874 "or the complete multiple tape (m) test: (s/m) "));
1875 if (cmd[0] == 's') {
1876 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1878 } else if (cmd[0] == 'm') {
1879 Pmsg0(-1, _("Multiple tape test selected.\n"));
1882 Pmsg0(000, _("Command aborted.\n"));
1886 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1887 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1889 /* Use fixed block size to simplify read back */
1890 min_block_size = dev->min_block_size;
1891 dev->min_block_size = dev->max_block_size;
1892 set_volume_name("TestVolume1", 1);
1893 dir_ask_sysop_to_create_appendable_volume(dcr);
1894 dev->set_append(); /* force volume to be relabeled */
1897 * Acquire output device for writing. Note, after acquiring a
1898 * device, we MUST release it, which is done at the end of this
1901 Dmsg0(100, "just before acquire_device\n");
1902 if (!acquire_device_for_append(dcr)) {
1903 set_jcr_job_status(jcr, JS_ErrorTerminated);
1906 block = jcr->dcr->block;
1908 Dmsg0(100, "Just after acquire_device_for_append\n");
1910 * Write Begin Session Record
1912 if (!write_session_label(dcr, SOS_LABEL)) {
1913 set_jcr_job_status(jcr, JS_ErrorTerminated);
1914 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1918 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1920 memset(&rec, 0, sizeof(rec));
1921 rec.data = get_memory(100000); /* max record size */
1923 #define REC_SIZE 32768
1924 rec.data_len = REC_SIZE;
1927 * Put some random data in the record
1929 fd = open("/dev/urandom", O_RDONLY);
1931 read(fd, rec.data, rec.data_len);
1934 uint32_t *p = (uint32_t *)rec.data;
1935 srandom(time(NULL));
1936 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1942 * Generate data as if from File daemon, write to device
1944 jcr->dcr->VolFirstIndex = 0;
1945 time(&jcr->run_time); /* start counting time for rates */
1946 (void)localtime_r(&jcr->run_time, &tm);
1947 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1949 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1951 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1953 for (file_index = 0; ok && !job_canceled(jcr); ) {
1954 rec.VolSessionId = jcr->VolSessionId;
1955 rec.VolSessionTime = jcr->VolSessionTime;
1956 rec.FileIndex = ++file_index;
1957 rec.Stream = STREAM_FILE_DATA;
1959 /* Mix up the data just a bit */
1960 uint32_t *lp = (uint32_t *)rec.data;
1962 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1966 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1967 rec.FileIndex, rec.VolSessionId,
1968 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1971 while (!write_record_to_block(block, &rec)) {
1973 * When we get here we have just filled a block
1975 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1978 /* Write block to tape */
1979 if (!flush_block(block, 1)) {
1983 /* Every 5000 blocks (approx 322MB) report where we are.
1985 if ((block->BlockNumber % 5000) == 0) {
1987 now -= jcr->run_time;
1989 now = 1; /* prevent divide error */
1991 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1992 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1993 block->BlockNumber, dev->block_num,
1994 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1996 /* Every 32000 blocks (approx 2GB) write an EOF.
1998 if ((block->BlockNumber % 32000) == 0) {
2000 (void)localtime_r(&now, &tm);
2001 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2002 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
2003 flush_block(block, 0);
2007 /* Get out after writing 10 blocks to the second tape */
2008 if (++BlockNumber > 10 && stop != 0) { /* get out */
2013 Pmsg0(000, _("Not OK\n"));
2016 jcr->JobBytes += rec.data_len; /* increment bytes this job */
2017 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
2018 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
2019 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
2021 /* Get out after writing 10 blocks to the second tape */
2022 if (BlockNumber > 10 && stop != 0) { /* get out */
2024 Pmsg1(-1, "Done writing %s records ...\n",
2025 edit_uint64_with_commas(write_count, ed1));
2030 Dmsg0(100, "Write_end_session_label()\n");
2031 /* Create Job status for end of session label */
2032 if (!job_canceled(jcr) && ok) {
2033 set_jcr_job_status(jcr, JS_Terminated);
2035 set_jcr_job_status(jcr, JS_ErrorTerminated);
2037 if (!write_session_label(dcr, EOS_LABEL)) {
2038 Pmsg1(000, _("Error writing end session label. ERR=%s\n"), dev->bstrerror());
2041 /* Write out final block of this session */
2042 if (!write_block_to_device(dcr)) {
2043 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2046 Pmsg0(-1, _("Wrote End of Session label.\n"));
2048 /* Save last block info for second tape */
2049 last_block_num2 = last_block_num;
2050 last_file2 = last_file;
2052 free_block(last_block2);
2054 last_block2 = dup_block(last_block);
2057 sprintf(buf, "%s/btape.state", working_directory);
2058 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2060 write(fd, &btape_state_level, sizeof(btape_state_level));
2061 write(fd, &simple, sizeof(simple));
2062 write(fd, &last_block_num1, sizeof(last_block_num1));
2063 write(fd, &last_block_num2, sizeof(last_block_num2));
2064 write(fd, &last_file1, sizeof(last_file1));
2065 write(fd, &last_file2, sizeof(last_file2));
2066 write(fd, last_block1->buf, last_block1->buf_len);
2067 write(fd, last_block2->buf, last_block2->buf_len);
2068 write(fd, first_block->buf, first_block->buf_len);
2070 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2071 last_block_num1, last_block_num2);
2074 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2079 (void)localtime_r(&now, &tm);
2080 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2082 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2083 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2086 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2087 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2090 jcr->dcr->block = block;
2093 dev->min_block_size = min_block_size;
2094 free_memory(rec.data);
2098 * Read two tapes written by the "fill" command and ensure
2099 * that the data is valid. If stop==1 we simulate full read back
2100 * of two tapes. If stop==-1 we simply read the last block and
2101 * verify that it is correct.
2103 static void unfillcmd()
2107 last_block1 = new_block(dev);
2108 last_block2 = new_block(dev);
2109 first_block = new_block(dev);
2110 sprintf(buf, "%s/btape.state", working_directory);
2111 fd = open(buf, O_RDONLY);
2113 uint32_t state_level;
2114 read(fd, &state_level, sizeof(btape_state_level));
2115 read(fd, &simple, sizeof(simple));
2116 read(fd, &last_block_num1, sizeof(last_block_num1));
2117 read(fd, &last_block_num2, sizeof(last_block_num2));
2118 read(fd, &last_file1, sizeof(last_file1));
2119 read(fd, &last_file2, sizeof(last_file2));
2120 read(fd, last_block1->buf, last_block1->buf_len);
2121 read(fd, last_block2->buf, last_block2->buf_len);
2122 read(fd, first_block->buf, first_block->buf_len);
2124 if (state_level != btape_state_level) {
2125 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2126 "the fill command.\n"));
2131 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2132 "You must redo the fill command.\n"), buf, be.bstrerror());
2139 static void do_unfill()
2141 DEV_BLOCK *block = dcr->block;
2148 Dmsg0(20, "Enter do_unfill\n");
2149 dev->set_cap(CAP_ANONVOLS); /* allow reading any volume */
2150 dev->clear_cap(CAP_LABEL); /* don't label anything here */
2154 time(&jcr->run_time); /* start counting time for rates */
2158 free_block(last_block);
2161 last_block_num = last_block_num1;
2162 last_file = last_file1;
2163 last_block = last_block1;
2165 free_restore_volume_list(jcr);
2167 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2168 create_restore_volume_list(jcr);
2169 if (jcr->VolList != NULL) {
2170 jcr->VolList->Slot = 1;
2171 if (jcr->VolList->next != NULL) {
2172 jcr->VolList->next->Slot = 2;
2176 set_volume_name("TestVolume1", 1);
2179 /* Multiple Volume tape */
2180 /* Close device so user can use autochanger if desired */
2181 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2184 autochanger = autoload_device(dcr, 1, NULL);
2185 if (autochanger != 1) {
2187 get_cmd(_("Mount first tape. Press enter when ready: "));
2192 dev->num_writers = 0;
2193 if (!acquire_device_for_read(dcr)) {
2194 Pmsg1(-1, "%s", dev->errmsg);
2198 * We now have the first tape mounted.
2199 * Note, re-reading last block may have caused us to
2200 * loose track of where we are (block number unknown).
2202 Pmsg0(-1, _("Rewinding.\n"));
2203 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2206 /* Read the first 10000 records */
2207 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2208 dev->file, dev->block_num);
2210 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2211 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2212 last_file, last_block_num);
2213 if (!dev->reposition(dcr, last_file, last_block_num)) {
2214 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2217 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2218 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2219 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2222 if (compare_blocks(last_block, block)) {
2224 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2226 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2233 /* restore info for last block on second Volume */
2234 last_block_num = last_block_num2;
2235 last_file = last_file2;
2236 last_block = last_block2;
2238 /* Multiple Volume tape */
2239 /* Close device so user can use autochanger if desired */
2240 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2244 set_volume_name("TestVolume2", 2);
2246 autochanger = autoload_device(dcr, 1, NULL);
2247 if (autochanger != 1) {
2249 get_cmd(_("Mount second tape. Press enter when ready: "));
2253 if (!acquire_device_for_read(dcr)) {
2254 Pmsg1(-1, "%s", dev->errmsg);
2258 /* Space to "first" block which is last block not written
2259 * on the previous tape.
2261 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2262 if (!dev->reposition(dcr, 0, 1)) {
2263 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2266 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2267 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2268 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2271 if (compare_blocks(first_block, block)) {
2272 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2275 /* Now find and compare the last block */
2276 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2277 last_file, last_block_num);
2278 if (!dev->reposition(dcr, last_file, last_block_num)) {
2279 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2282 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2283 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2284 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2287 if (compare_blocks(last_block, block)) {
2288 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2292 free_block(last_block1);
2293 free_block(last_block2);
2294 free_block(first_block);
2297 /* Read 10000 records then stop */
2298 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2300 DEVICE *dev = dcr->dev;
2302 if (quickie_count == 10000) {
2303 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2305 return quickie_count < 10000;
2308 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2311 uint32_t CheckSum, block_len;
2314 p = last_block->buf;
2316 unser_begin(q, BLKHDR2_LENGTH);
2317 unser_uint32(CheckSum);
2318 unser_uint32(block_len);
2319 while (q < (block->buf+block_len)) {
2326 dump_block(last_block, _("Last block written"));
2328 dump_block(block, _("Block read back"));
2329 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2330 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2331 "that was read back differ. The test FAILED !!!!\n"
2332 "This must be corrected before you use Bacula\n"
2333 "to write multi-tape Volumes.!!!!\n"));
2337 dump_block(last_block, _("Last block written"));
2338 dump_block(block, _("Block read back"));
2348 * Write current block to tape regardless of whether or
2349 * not it is full. If the tape fills, attempt to
2350 * acquire another tape.
2352 static int flush_block(DEV_BLOCK *block, int dump)
2356 uint32_t this_file, this_block_num;
2360 this_block = new_block(dev);
2363 last_block = new_block(dev);
2366 this_file = dev->file;
2367 this_block_num = dev->block_num;
2368 if (!write_block_to_dev(dcr)) {
2369 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2370 last_file, last_block_num, this_block_num);
2373 * This is 1st tape, so save first tape info separate
2374 * from second tape info
2376 last_block_num1 = last_block_num;
2377 last_file1 = last_file;
2378 last_block1 = dup_block(last_block);
2379 last_block2 = dup_block(last_block);
2380 first_block = dup_block(block); /* first block second tape */
2383 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2384 (unsigned)file_index, block->BlockNumber, block->block_len);
2385 dump_block(last_block, _("Last block written"));
2387 dump_block(block, _("Block not written"));
2390 eot_block = block->BlockNumber;
2391 eot_block_len = block->block_len;
2392 eot_FileIndex = file_index;
2396 now -= jcr->run_time;
2398 now = 1; /* don't divide by zero */
2400 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2401 vol_size = dev->VolCatInfo.VolCatBytes;
2402 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2403 dev->file, dev->block_num,
2404 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2407 stop = -1; /* stop, but do simplified test */
2409 /* Full test in progress */
2410 if (!fixup_device_block_write_error(jcr->dcr)) {
2411 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2416 BlockNumber = 0; /* start counting for second tape */
2419 return 1; /* end of tape reached */
2422 /* Save contents after write so that the header is serialized */
2423 memcpy(this_block->buf, block->buf, this_block->buf_len);
2426 * Note, we always read/write to block, but we toggle
2427 * copying it to one or another of two allocated blocks.
2428 * Switch blocks so that the block just successfully written is
2429 * always in last_block.
2431 tblock = last_block;
2432 last_block = this_block;
2433 this_block = tblock;
2434 last_file = this_file;
2435 last_block_num = this_block_num;
2443 * First we label the tape, then we fill
2444 * it with data get a new tape and write a few blocks.
2446 static void qfillcmd()
2448 DEV_BLOCK *block = dcr->block;
2449 DEV_RECORD *rec = dcr->rec;
2452 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2454 get_cmd(_("How many blocks do you want to write? (1000): "));
2461 sm_check(__FILE__, __LINE__, false);
2463 i = block->buf_len - 100;
2465 rec->data = check_pool_memory_size(rec->data, i);
2466 memset(rec->data, i & 0xFF, i);
2469 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2470 for (i=0; i < count; i++) {
2475 if (!write_record_to_block(block, rec)) {
2476 Pmsg0(0, _("Error writing record to block.\n"));
2479 if (!write_block_to_dev(dcr)) {
2480 Pmsg0(0, _("Error writing block to device.\n"));
2486 if (dev->has_cap(CAP_TWOEOF)) {
2493 sm_check(__FILE__, __LINE__, false);
2497 * Fill a tape using raw write() command
2499 static void rawfill_cmd()
2501 DEV_BLOCK *block = dcr->block;
2504 uint32_t block_num = 0;
2509 fd = open("/dev/urandom", O_RDONLY);
2511 read(fd, block->buf, block->buf_len);
2514 uint32_t *p = (uint32_t *)block->buf;
2515 srandom(time(NULL));
2516 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2520 p = (uint32_t *)block->buf;
2521 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2524 stat = dev->d_write(dev->fd(), block->buf, block->buf_len);
2525 if (stat == (int)block->buf_len) {
2526 if ((block_num++ % 100) == 0) {
2531 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2541 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2542 be.bstrerror(my_errno));
2548 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2549 static struct cmdstruct commands[] = {
2550 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2551 {NT_("bsf"), bsfcmd, _("backspace file")},
2552 {NT_("bsr"), bsrcmd, _("backspace record")},
2553 {NT_("cap"), capcmd, _("list device capabilities")},
2554 {NT_("clear"), clearcmd, _("clear tape errors")},
2555 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2556 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2557 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2558 {NT_("unfill"), unfillcmd, _("read filled tape")},
2559 {NT_("fsf"), fsfcmd, _("forward space a file")},
2560 {NT_("fsr"), fsrcmd, _("forward space a record")},
2561 {NT_("help"), helpcmd, _("print this command")},
2562 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2563 {NT_("load"), loadcmd, _("load a tape")},
2564 {NT_("quit"), quitcmd, _("quit btape")},
2565 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2566 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2567 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2568 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2569 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2570 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2571 {NT_("status"), statcmd, _("print tape status")},
2572 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2573 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2574 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2575 {NT_("rr"), rrcmd, _("read a single record")},
2576 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2577 {NT_("qfill"), qfillcmd, _("quick fill command")}
2579 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2587 while (!quit && get_cmd("*")) {
2588 sm_check(__FILE__, __LINE__, false);
2590 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2591 for (i=0; i<comsize; i++) /* search for command */
2592 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2593 (*commands[i].func)(); /* go execute command */
2597 if (*cmd && !found) {
2598 Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2603 static void helpcmd()
2607 printf(_("Interactive commands:\n"));
2608 printf(_(" Command Description\n ======= ===========\n"));
2609 for (i=0; i<comsize; i++)
2610 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2618 "\nVersion: %s (%s)\n\n"
2619 "Usage: btape <options> <device_name>\n"
2620 " -b <file> specify bootstrap file\n"
2621 " -c <file> set configuration file to file\n"
2622 " -d <nn> set debug level to <nn>\n"
2623 " -dt print timestamp in debug output\n"
2624 " -p proceed inspite of I/O errors\n"
2625 " -s turn off signals\n"
2627 " -? print this message.\n"
2628 "\n"), 2000, VERSION, BDATE);
2633 * Get next input command from terminal. This
2634 * routine is REALLY primitive, and should be enhanced
2635 * to have correct backspacing, etc.
2638 get_cmd(const char *prompt)
2643 fprintf(stdout, "%s", prompt);
2645 /* We really should turn off echoing and pretty this
2649 while ((ch = fgetc(stdin)) != EOF) {
2651 strip_trailing_junk(cmd);
2653 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2667 /* Dummies to replace askdir.c */
2668 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2669 bool dir_send_job_status(JCR *jcr) {return 1;}
2671 bool dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten)
2677 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2679 Dmsg0(20, "Enter dir_get_volume_info\n");
2680 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2684 bool dir_create_jobmedia_record(DCR *dcr, bool zero)
2686 dcr->WroteVol = false;
2691 bool dir_find_next_appendable_volume(DCR *dcr)
2693 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2694 return dcr->VolumeName[0] != 0;
2697 bool dir_ask_sysop_to_mount_volume(DCR *dcr, int /* mode */)
2699 DEVICE *dev = dcr->dev;
2700 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2701 if (dcr->VolumeName[0] == 0) {
2702 return dir_ask_sysop_to_create_appendable_volume(dcr);
2704 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2705 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2706 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2709 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2710 dcr->VolumeName, dev->print_name());
2717 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2720 DEVICE *dev = dcr->dev;
2721 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2723 set_volume_name("TestVolume1", 1);
2725 set_volume_name("TestVolume2", 2);
2727 /* Close device so user can use autochanger if desired */
2728 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2731 autochanger = autoload_device(dcr, 1, NULL);
2732 if (autochanger != 1) {
2733 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2744 static bool my_mount_next_read_volume(DCR *dcr)
2747 JCR *jcr = dcr->jcr;
2748 DEV_BLOCK *block = dcr->block;
2750 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2751 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2754 volume_unused(dcr); /* release current volume */
2755 if (LastBlock != block->BlockNumber) {
2756 VolBytes += block->block_len;
2758 LastBlock = block->BlockNumber;
2760 now -= jcr->run_time;
2764 kbs = (double)VolBytes / (1000.0 * (double)now);
2765 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2766 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2768 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2773 set_volume_name("TestVolume2", 2);
2776 if (!acquire_device_for_read(dcr)) {
2777 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2780 return true; /* next volume mounted */
2783 static void set_volume_name(const char *VolName, int volnum)
2785 DCR *dcr = jcr->dcr;
2786 VolumeName = VolName;
2788 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2789 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2790 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2791 dcr->VolCatInfo.Slot = volnum;
2792 dcr->VolCatInfo.InChanger = true;