2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of 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;
79 /* Forward referenced subroutines */
80 static void do_tape_cmds();
81 static void helpcmd();
82 static void scancmd();
83 static void rewindcmd();
84 static void clearcmd();
89 static void fillcmd();
90 static void qfillcmd();
91 static void statcmd();
92 static void unfillcmd();
93 static int flush_block(DEV_BLOCK *block, int dump);
94 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
95 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
96 static bool my_mount_next_read_volume(DCR *dcr);
97 static void scan_blocks();
98 static void set_volume_name(const char *VolName, int volnum);
99 static void rawfill_cmd();
100 static bool open_the_device();
101 static void autochangercmd();
102 static void do_unfill();
105 /* Static variables */
106 static CONFIG *config;
107 #define CONFIG_FILE "bacula-sd.conf"
108 char *configfile = NULL;
110 #define MAX_CMD_ARGS 30
112 static POOLMEM *args;
113 static char *argk[MAX_CMD_ARGS];
114 static char *argv[MAX_CMD_ARGS];
117 static int quickie_count = 0;
118 static uint64_t write_count = 0;
119 static BSR *bsr = NULL;
120 static int signals = TRUE;
123 static uint64_t vol_size;
124 static uint64_t VolBytes;
127 static int32_t file_index;
128 static int end_of_tape = 0;
129 static uint32_t LastBlock = 0;
130 static uint32_t eot_block;
131 static uint32_t eot_block_len;
132 static uint32_t eot_FileIndex;
133 static int dumped = 0;
134 static DEV_BLOCK *last_block1 = NULL;
135 static DEV_BLOCK *last_block2 = NULL;
136 static DEV_BLOCK *last_block = NULL;
137 static DEV_BLOCK *this_block = NULL;
138 static DEV_BLOCK *first_block = NULL;
139 static uint32_t last_file1 = 0;
140 static uint32_t last_file2 = 0;
141 static uint32_t last_file = 0;
142 static uint32_t last_block_num1 = 0;
143 static uint32_t last_block_num2 = 0;
144 static uint32_t last_block_num = 0;
145 static uint32_t BlockNumber = 0;
146 static bool simple = true;
148 static const char *VolumeName = NULL;
149 static int vol_num = 0;
151 static JCR *jcr = NULL;
155 static void terminate_btape(int sig);
156 int get_cmd(const char *prompt);
159 /*********************************************************************
161 * Bacula tape testing program
164 int main(int margc, char *margv[])
171 setlocale(LC_ALL, "");
172 bindtextdomain("bacula", LOCALEDIR);
173 textdomain("bacula");
177 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
178 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
179 TAPE_BSIZE, B_DEV_BSIZE);
181 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
182 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
184 if (sizeof(boffset_t) < 8) {
185 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. boffset_t=%d should be 8 or more !!!!!\n\n\n"),
189 bsnprintf(buf, sizeof(buf), "%u", x32);
190 i = bsscanf(buf, "%lu", &y32);
191 if (i != 1 || x32 != y32) {
192 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
198 bsnprintf(buf, sizeof(buf), "%" llu, x64);
199 i = bsscanf(buf, "%llu", &y64);
200 if (i != 1 || x64 != y64) {
201 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
206 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
208 working_directory = "/tmp";
209 my_name_is(margc, margv, "btape");
210 init_msg(NULL, NULL);
214 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
216 case 'b': /* bootstrap file */
217 bsr = parse_bsr(NULL, optarg);
218 // dump_bsr(bsr, true);
221 case 'c': /* specify config file */
222 if (configfile != NULL) {
225 configfile = bstrdup(optarg);
228 case 'd': /* set debug level */
229 if (*optarg == 't') {
230 dbg_timestamp = true;
232 debug_level = atoi(optarg);
233 if (debug_level <= 0) {
261 cmd = get_pool_memory(PM_FNAME);
262 args = get_pool_memory(PM_FNAME);
265 init_signals(terminate_btape);
268 if (configfile == NULL) {
269 configfile = bstrdup(CONFIG_FILE);
272 daemon_start_time = time(NULL);
274 config = new_config_parser();
275 parse_sd_config(config, configfile, M_ERROR_TERM);
277 /* See if we can open a device */
279 Pmsg0(000, _("No archive name specified.\n"));
282 } else if (margc != 1) {
283 Pmsg0(000, _("Improper number of arguments specified.\n"));
288 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
297 Pmsg0(000, _("btape does not work with DVD storage.\n"));
301 if (!dev->is_tape()) {
302 Pmsg0(000, _("btape only works with tape storage.\n"));
307 if (!open_the_device()) {
311 Dmsg0(200, "Do tape commands\n");
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 close_memory_pool(); /* free memory in pool */
363 term_last_jobs_list();
369 static bool open_the_device()
374 block = new_block(dev);
376 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
377 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
378 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
382 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
383 dev->set_append(); /* put volume in append mode */
398 * Write a label to the tape
400 static void labelcmd()
403 pm_strcpy(cmd, VolumeName);
405 if (!get_cmd(_("Enter Volume Name: "))) {
410 if (!dev->is_open()) {
411 if (!first_open_device(dcr)) {
412 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 writting larger and larger records.
638 * This is a torture test for records.
640 static void rectestcmd()
646 Pmsg0(0, _("Test writting 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 int 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"));
801 * This test writes Bacula blocks to the tape in
802 * several files. It then rewinds the tape and attepts
803 * to read these blocks back checking the data.
805 static int write_read_test()
813 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
814 "I'm going to write 1000 records and an EOF\n"
815 "then write 1000 records and an EOF, then rewind,\n"
816 "and re-read the data to verify that it is correct.\n\n"
817 "This is an *essential* feature ...\n\n"));
820 if (!dev->rewind(dcr)) {
821 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
824 rec->data = check_pool_memory_size(rec->data, block->buf_len);
825 rec->data_len = block->buf_len-100;
826 len = rec->data_len/sizeof(i);
827 for (i=1; i<=1000; 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 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
843 for (i=1001; i<=2000; 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 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
859 if (dev->has_cap(CAP_TWOEOF)) {
862 if (!dev->rewind(dcr)) {
863 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
866 Pmsg0(0, _("Rewind OK.\n"));
868 for (i=1; i<=2000; i++) {
870 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
872 if (dev_state(dev, ST_EOF)) {
873 Pmsg0(-1, _("Got EOF on tape.\n"));
878 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
881 memset(rec->data, 0, rec->data_len);
882 if (!read_record_from_block(dcr, block, rec)) {
884 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
887 p = (int *)rec->data;
888 for (j=0; j<len; j++) {
890 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
896 if (i == 1000 || i == 2000) {
897 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
900 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
909 * This test writes Bacula blocks to the tape in
910 * several files. It then rewinds the tape and attepts
911 * to read these blocks back checking the data.
913 static int position_test()
915 DEV_BLOCK *block = dcr->block;
921 int file = 0, blk = 0;
923 bool got_eof = false;
925 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
926 "I'm going to write 1000 records and an EOF\n"
927 "then write 1000 records and an EOF, then rewind,\n"
928 "and position to a few blocks and verify that it is correct.\n\n"
929 "This is an *essential* feature ...\n\n"));
932 if (!dev->rewind(dcr)) {
933 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
936 rec->data = check_pool_memory_size(rec->data, block->buf_len);
937 rec->data_len = block->buf_len-100;
938 len = rec->data_len/sizeof(i);
939 for (i=1; i<=1000; i++) {
940 p = (int *)rec->data;
941 for (j=0; j<len; j++) {
944 if (!write_record_to_block(block, rec)) {
945 Pmsg0(0, _("Error writing record to block.\n"));
948 if (!write_block_to_dev(dcr)) {
949 Pmsg0(0, _("Error writing block to device.\n"));
953 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
955 for (i=1001; i<=2000; i++) {
956 p = (int *)rec->data;
957 for (j=0; j<len; j++) {
960 if (!write_record_to_block(block, rec)) {
961 Pmsg0(0, _("Error writing record to block.\n"));
964 if (!write_block_to_dev(dcr)) {
965 Pmsg0(0, _("Error writing block to device.\n"));
969 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
971 if (dev->has_cap(CAP_TWOEOF)) {
974 if (!dev->rewind(dcr)) {
975 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
978 Pmsg0(0, _("Rewind OK.\n"));
982 /* Set up next item to read based on where we are */
1018 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1019 if (!dev->reposition(dcr, file, blk)) {
1020 Pmsg0(0, _("Reposition error.\n"));
1024 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1026 if (dev_state(dev, ST_EOF)) {
1027 Pmsg0(-1, _("Got EOF on tape.\n"));
1033 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1034 recno, file, blk, be.bstrerror(dev->dev_errno));
1035 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1036 " set to variable blocking as normally used by Bacula.\n"
1037 " Please see the Tape Testing chapter in the manual and \n"
1038 " look for using mt with defblksize and setoptions\n"
1039 "If your tape drive block size is correct, then perhaps\n"
1040 " your SCSI driver is *really* stupid and does not\n"
1041 " correctly report the file:block after a FSF. In this\n"
1042 " case try setting:\n"
1043 " Fast Forward Space File = no\n"
1044 " in your Device resource.\n"));
1048 memset(rec->data, 0, rec->data_len);
1049 if (!read_record_from_block(dcr, block, rec)) {
1051 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1054 p = (int *)rec->data;
1055 for (j=0; j<len; j++) {
1056 if (p[j] != recno) {
1057 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1062 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1064 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1076 * This test writes some records, then writes an end of file,
1077 * rewinds the tape, moves to the end of the data and attepts
1078 * to append to the tape. This function is essential for
1079 * Bacula to be able to write multiple jobs to the tape.
1081 static int append_test()
1083 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1084 "This test is essential to Bacula.\n\n"
1085 "I'm going to write one record in file 0,\n"
1086 " two records in file 1,\n"
1087 " and three records in file 2\n\n"));
1091 weofcmd(); /* end file 0 */
1094 weofcmd(); /* end file 1 */
1098 weofcmd(); /* end file 2 */
1099 if (dev->has_cap(CAP_TWOEOF)) {
1102 dev->close(); /* release device */
1103 if (!open_the_device()) {
1107 Pmsg0(0, _("Now moving to end of medium.\n"));
1109 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1110 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1112 if (dev->file != 3) {
1116 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1119 if (dev->has_cap(CAP_TWOEOF)) {
1123 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1124 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1126 Pmsg0(-1, _("End scanning the tape.\n"));
1127 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1128 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1130 if (dev->file != 4) {
1138 * This test exercises the autochanger
1140 static int autochanger_test()
1142 POOLMEM *results, *changer;
1143 int slot, status, loaded;
1144 int timeout = dcr->device->max_changer_wait;
1147 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1148 if (!dev->has_cap(CAP_AUTOCHANGER)) {
1151 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1152 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1156 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1157 "To test the autochanger you must have a blank tape\n"
1158 " that I can write on in Slot 1.\n"));
1159 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1162 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1166 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1168 results = get_pool_memory(PM_MESSAGE);
1169 changer = get_pool_memory(PM_FNAME);
1173 dcr->VolCatInfo.Slot = slot;
1174 /* Find out what is loaded, zero means device is unloaded */
1175 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1176 changer = edit_device_codes(dcr, changer,
1177 dcr->device->changer_command, "loaded");
1178 status = run_program(changer, timeout, results);
1179 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1181 loaded = atoi(results);
1184 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1185 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1189 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1191 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1193 Dmsg1(100, "Results from loaded query=%s\n", results);
1195 dcr->VolCatInfo.Slot = loaded;
1196 /* We are going to load a new tape, so close the device */
1198 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1199 loaded, dev->drive_index);
1200 changer = edit_device_codes(dcr, changer,
1201 dcr->device->changer_command, "unload");
1202 status = run_program(changer, timeout, results);
1203 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1206 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1207 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1216 dcr->VolCatInfo.Slot = slot;
1217 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1218 slot, dev->drive_index);
1219 changer = edit_device_codes(dcr, changer,
1220 dcr->device->changer_command, "load");
1221 Dmsg1(100, "Changer=%s\n", changer);
1223 status = run_program(changer, timeout, results);
1225 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1226 slot, dev->drive_index);
1229 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1230 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1234 if (!open_the_device()) {
1238 * Start with sleep_time 0 then increment by 30 seconds if we get
1241 bmicrosleep(sleep_time, 0);
1242 if (!dev->rewind(dcr) || !dev->weof(1)) {
1243 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1245 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1246 "a longer sleep time in the mtx-script in the load) case.\n"
1247 "Adding a 30 second sleep and trying again ...\n"));
1251 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1254 if (!dev->weof(1)) {
1255 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1258 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1262 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1264 "to your mtx-changer script in the load) case.\n\n"),
1267 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1270 free_pool_memory(changer);
1271 free_pool_memory(results);
1276 free_pool_memory(changer);
1277 free_pool_memory(results);
1278 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1282 static void autochangercmd()
1289 * This test assumes that the append test has been done,
1290 * then it tests the fsf function.
1292 static int fsf_test()
1294 bool set_off = false;
1296 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1297 "This test is essential to Bacula.\n\n"
1298 "I'm going to write five files then test forward spacing\n\n"));
1302 weofcmd(); /* end file 0 */
1305 weofcmd(); /* end file 1 */
1309 weofcmd(); /* end file 2 */
1312 weofcmd(); /* end file 3 */
1314 weofcmd(); /* end file 4 */
1315 if (dev->has_cap(CAP_TWOEOF)) {
1321 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1323 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1326 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1327 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1329 if (dev->file != 1) {
1333 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1335 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1338 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1339 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1341 if (dev->file != 3) {
1346 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1348 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1351 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1352 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1354 if (dev->file != 4) {
1358 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1359 " Fast Forward Space File = no\n\n"
1360 "to your Device resource for this drive.\n"));
1364 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1366 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1368 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1369 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1370 if (dev->file != 5) {
1373 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1377 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1378 if (dev->has_cap(CAP_FASTFSF)) {
1379 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1380 "I am turning it off then retrying the test.\n"));
1381 dev->clear_cap(CAP_FASTFSF);
1385 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1386 "Some systems, e.g. OpenBSD, require you to set\n"
1387 " Use MTIOCGET= no\n"
1388 "in your device resource. Use with caution.\n"));
1397 * This is a general test of Bacula's functions
1398 * needed to read and write the tape.
1400 static void testcmd()
1404 if (!write_read_test()) {
1407 if (!position_test()) {
1411 stat = append_test();
1412 if (stat == 1) { /* OK get out */
1415 if (stat == -1) { /* first test failed */
1416 if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1417 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1418 "Setting \"Hardware End of Medium = no\n"
1419 " and \"Fast Forward Space File = no\n"
1420 "and retrying append test.\n\n"));
1421 dev->clear_cap(CAP_EOM); /* turn off eom */
1422 dev->clear_cap(CAP_FASTFSF); /* turn off fast fsf */
1423 stat = append_test();
1425 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1426 " Hardware End of Medium = No\n\n"
1427 " Fast Forward Space File = No\n"
1428 "to your Device resource in the Storage conf file.\n"));
1432 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1435 /* Wrong count after append */
1437 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1438 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1439 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1440 stat = append_test();
1442 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1443 " Hardware End of Medium = No\n"
1444 " Fast Forward Space File = No\n"
1445 " BSF at EOM = yes\n\n"
1446 "to your Device resource in the Storage conf file.\n"));
1453 Pmsg0(-1, _("\nAppend test failed.\n\n"
1454 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1455 "Unable to correct the problem. You MUST fix this\n"
1456 "problem before Bacula can use your tape drive correctly\n"
1457 "\nPerhaps running Bacula in fixed block mode will work.\n"
1458 "Do so by setting:\n\n"
1459 "Minimum Block Size = nnn\n"
1460 "Maximum Block Size = nnn\n\n"
1461 "in your Storage daemon's Device definition.\n"
1462 "nnn must match your tape driver's block size, which\n"
1463 "can be determined by reading your tape manufacturers\n"
1464 "information, and the information on your kernel dirver.\n"
1465 "Fixed block sizes, however, are not normally an ideal solution.\n"
1467 "Some systems, e.g. OpenBSD, require you to set\n"
1468 " Use MTIOCGET= no\n"
1469 "in your device resource. Use with caution.\n"));
1474 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1475 "Please double check it ...\n"
1476 "=== Sample correct output ===\n"
1477 "1 block of 64448 bytes in file 1\n"
1478 "End of File mark.\n"
1479 "2 blocks of 64448 bytes in file 2\n"
1480 "End of File mark.\n"
1481 "3 blocks of 64448 bytes in file 3\n"
1482 "End of File mark.\n"
1483 "1 block of 64448 bytes in file 4\n"
1484 "End of File mark.\n"
1485 "Total files=4, blocks=7, bytes = 451,136\n"
1486 "=== End sample correct output ===\n\n"
1487 "If the above scan output is not identical to the\n"
1488 "sample output, you MUST correct the problem\n"
1489 "or Bacula will not be able to write multiple Jobs to \n"
1493 re_read_block_test();
1496 fsf_test(); /* do fast forward space file test */
1498 autochanger_test(); /* do autochanger test */
1502 /* Forward space a file */
1503 static void fsfcmd()
1507 num = atoi(argk[1]);
1512 if (!dev->fsf(num)) {
1513 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1517 Pmsg0(0, _("Forward spaced 1 file.\n"));
1520 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1524 /* Forward space a record */
1525 static void fsrcmd()
1529 num = atoi(argk[1]);
1534 if (!dev->fsr(num)) {
1535 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1539 Pmsg0(0, _("Forward spaced 1 record.\n"));
1542 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1547 * Read a Bacula block from the tape
1551 dev->open(dcr, OPEN_READ_ONLY);
1552 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1556 * Write a Bacula block to the tape
1560 DEV_BLOCK *block = dcr->block;
1561 DEV_RECORD *rec = dcr->rec;
1564 if (!dev->is_open()) {
1567 sm_check(__FILE__, __LINE__, false);
1570 dump_block(block, "test");
1573 i = block->buf_len - 100;
1575 rec->data = check_pool_memory_size(rec->data, i);
1576 memset(rec->data, i & 0xFF, i);
1578 sm_check(__FILE__, __LINE__, false);
1579 if (!write_record_to_block(block, rec)) {
1580 Pmsg0(0, _("Error writing record to block.\n"));
1583 if (!write_block_to_dev(dcr)) {
1584 Pmsg0(0, _("Error writing block to device.\n"));
1587 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1589 Pmsg0(0, _("Wrote block to device.\n"));
1592 sm_check(__FILE__, __LINE__, false);
1593 sm_check(__FILE__, __LINE__, false);
1597 * Read a record from the tape
1604 if (!get_cmd(_("Enter length to read: "))) {
1608 if (len < 0 || len > 1000000) {
1609 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1612 buf = (char *)malloc(len);
1613 stat = read(dev->fd(), buf, len);
1614 if (stat > 0 && stat <= len) {
1618 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1619 len, stat, be.bstrerror());
1625 * Scan tape by reading block by block. Report what is
1626 * on the tape. Note, this command does raw reads, and as such
1627 * will not work with fixed block size devices.
1629 static void scancmd()
1632 int blocks, tot_blocks, tot_files;
1638 blocks = block_size = tot_blocks = 0;
1640 if (dev->state & ST_EOT) {
1641 Pmsg0(0, _("End of tape\n"));
1644 dev->update_pos(dcr);
1645 tot_files = dev->file;
1646 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1648 if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1651 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1652 dev->dev_name, be.bstrerror());
1653 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
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);
1664 Dmsg1(200, "read status = %d\n", stat);
1666 if (stat != block_size) {
1667 dev->update_pos(dcr);
1670 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1673 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1679 if (stat == 0) { /* EOF */
1680 dev->update_pos(dcr);
1681 printf(_("End of File mark.\n"));
1682 /* Two reads of zero means end of tape */
1683 if (dev->state & ST_EOF)
1684 dev->state |= ST_EOT;
1686 dev->state |= ST_EOF;
1689 if (dev->state & ST_EOT) {
1690 printf(_("End of tape\n"));
1693 } else { /* Got data */
1694 dev->state &= ~ST_EOF;
1700 dev->update_pos(dcr);
1701 tot_files = dev->file - tot_files;
1702 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1703 edit_uint64_with_commas(bytes, ec1));
1708 * Scan tape by reading Bacula block by block. Report what is
1709 * on the tape. This function reads Bacula blocks, so if your
1710 * Device resource is correctly defined, it should work with
1711 * either variable or fixed block sizes.
1713 static void scan_blocks()
1715 int blocks, tot_blocks, tot_files;
1716 uint32_t block_size;
1718 DEV_BLOCK *block = dcr->block;
1720 char buf1[100], buf2[100];
1722 blocks = block_size = tot_blocks = 0;
1726 dev->update_pos(dcr);
1727 tot_files = dev->file;
1729 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1730 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1731 if (dev->state & ST_EOT) {
1734 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1737 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1743 if (dev->state & ST_EOF) {
1746 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1749 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1753 printf(_("End of File mark.\n"));
1756 if (dev->state & ST_SHORT) {
1759 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1762 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1766 printf(_("Short block read.\n"));
1769 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1772 if (block->block_len != block_size) {
1775 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1778 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1782 block_size = block->block_len;
1786 bytes += block->block_len;
1787 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1788 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1789 block->VolSessionId, block->VolSessionTime);
1791 DEV_RECORD *rec = new_record();
1792 read_record_from_block(dcr, block, rec);
1793 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1794 block->BlockNumber, dev->block_num, block->block_len,
1795 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1796 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1799 } else if (verbose > 1) {
1800 dump_block(block, "");
1805 tot_files = dev->file - tot_files;
1806 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1807 edit_uint64_with_commas(bytes, ec1));
1811 static void statcmd()
1813 int debug = debug_level;
1815 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1817 dump_volume_label(dev);
1819 debug_level = debug;
1824 * First we label the tape, then we fill
1825 * it with data get a new tape and write a few blocks.
1827 static void fillcmd()
1830 DEV_BLOCK *block = dcr->block;
1832 char buf1[100], buf2[100];
1835 uint32_t min_block_size;
1846 "This command simulates Bacula writing to a tape.\n"
1847 "It requires either one or two blank tapes, which it\n"
1848 "will label and write.\n\n"
1849 "If you have an autochanger configured, it will use\n"
1850 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1851 "be prompted to insert the tapes when necessary.\n\n"
1852 "It will print a status approximately\n"
1853 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1854 "selected the simple test option, after writing the first tape\n"
1855 "it will rewind it and re-read the last block written.\n\n"
1856 "If you have selected the multiple tape test, when the first tape\n"
1857 "fills, it will ask for a second, and after writing a few more \n"
1858 "blocks, it will stop. Then it will begin re-reading the\n"
1860 "This may take a long time -- hours! ...\n\n"));
1862 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1863 "or the complete multiple tape (m) test: (s/m) "));
1864 if (cmd[0] == 's') {
1865 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1867 } else if (cmd[0] == 'm') {
1868 Pmsg0(-1, _("Multiple tape test selected.\n"));
1871 Pmsg0(000, _("Command aborted.\n"));
1875 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1876 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1878 /* Use fixed block size to simplify read back */
1879 min_block_size = dev->min_block_size;
1880 dev->min_block_size = dev->max_block_size;
1881 set_volume_name("TestVolume1", 1);
1882 dir_ask_sysop_to_create_appendable_volume(dcr);
1883 dev->set_append(); /* force volume to be relabeled */
1886 * Acquire output device for writing. Note, after acquiring a
1887 * device, we MUST release it, which is done at the end of this
1890 Dmsg0(100, "just before acquire_device\n");
1891 if (!acquire_device_for_append(dcr)) {
1892 set_jcr_job_status(jcr, JS_ErrorTerminated);
1895 block = jcr->dcr->block;
1897 Dmsg0(100, "Just after acquire_device_for_append\n");
1899 * Write Begin Session Record
1901 if (!write_session_label(dcr, SOS_LABEL)) {
1902 set_jcr_job_status(jcr, JS_ErrorTerminated);
1903 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1907 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1909 memset(&rec, 0, sizeof(rec));
1910 rec.data = get_memory(100000); /* max record size */
1912 #define REC_SIZE 32768
1913 rec.data_len = REC_SIZE;
1916 * Put some random data in the record
1918 fd = open("/dev/urandom", O_RDONLY);
1920 read(fd, rec.data, rec.data_len);
1923 uint32_t *p = (uint32_t *)rec.data;
1924 srandom(time(NULL));
1925 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1931 * Generate data as if from File daemon, write to device
1933 jcr->dcr->VolFirstIndex = 0;
1934 time(&jcr->run_time); /* start counting time for rates */
1935 (void)localtime_r(&jcr->run_time, &tm);
1936 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1938 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1940 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1942 for (file_index = 0; ok && !job_canceled(jcr); ) {
1943 rec.VolSessionId = jcr->VolSessionId;
1944 rec.VolSessionTime = jcr->VolSessionTime;
1945 rec.FileIndex = ++file_index;
1946 rec.Stream = STREAM_FILE_DATA;
1948 /* Mix up the data just a bit */
1949 uint32_t *lp = (uint32_t *)rec.data;
1951 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1955 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1956 rec.FileIndex, rec.VolSessionId,
1957 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1960 while (!write_record_to_block(block, &rec)) {
1962 * When we get here we have just filled a block
1964 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1967 /* Write block to tape */
1968 if (!flush_block(block, 1)) {
1972 /* Every 5000 blocks (approx 322MB) report where we are.
1974 if ((block->BlockNumber % 5000) == 0) {
1976 now -= jcr->run_time;
1978 now = 1; /* prevent divide error */
1980 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1981 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1982 block->BlockNumber, dev->block_num,
1983 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1985 /* Every 32000 blocks (approx 2GB) write an EOF.
1987 if ((block->BlockNumber % 32000) == 0) {
1989 (void)localtime_r(&now, &tm);
1990 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1991 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1992 flush_block(block, 0);
1996 /* Get out after writing 10 blocks to the second tape */
1997 if (++BlockNumber > 10 && stop != 0) { /* get out */
2002 Pmsg0(000, _("Not OK\n"));
2005 jcr->JobBytes += rec.data_len; /* increment bytes this job */
2006 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
2007 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
2008 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
2010 /* Get out after writing 10 blocks to the second tape */
2011 if (BlockNumber > 10 && stop != 0) { /* get out */
2013 Pmsg1(-1, "Done writing %s records ...\n",
2014 edit_uint64_with_commas(write_count, ed1));
2019 Dmsg0(100, "Write_end_session_label()\n");
2020 /* Create Job status for end of session label */
2021 if (!job_canceled(jcr) && ok) {
2022 set_jcr_job_status(jcr, JS_Terminated);
2024 set_jcr_job_status(jcr, JS_ErrorTerminated);
2026 if (!write_session_label(dcr, EOS_LABEL)) {
2027 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2030 /* Write out final block of this session */
2031 if (!write_block_to_device(dcr)) {
2032 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2035 Pmsg0(-1, _("Wrote End of Session label.\n"));
2037 /* Save last block info for second tape */
2038 last_block_num2 = last_block_num;
2039 last_file2 = last_file;
2041 free_block(last_block2);
2043 last_block2 = dup_block(last_block);
2046 sprintf(buf, "%s/btape.state", working_directory);
2047 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2049 write(fd, &btape_state_level, sizeof(btape_state_level));
2050 write(fd, &simple, sizeof(simple));
2051 write(fd, &last_block_num1, sizeof(last_block_num1));
2052 write(fd, &last_block_num2, sizeof(last_block_num2));
2053 write(fd, &last_file1, sizeof(last_file1));
2054 write(fd, &last_file2, sizeof(last_file2));
2055 write(fd, last_block1->buf, last_block1->buf_len);
2056 write(fd, last_block2->buf, last_block2->buf_len);
2057 write(fd, first_block->buf, first_block->buf_len);
2059 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2060 last_block_num1, last_block_num2);
2063 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2068 (void)localtime_r(&now, &tm);
2069 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2071 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2072 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2075 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2076 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2079 jcr->dcr->block = block;
2082 dev->min_block_size = min_block_size;
2083 free_memory(rec.data);
2087 * Read two tapes written by the "fill" command and ensure
2088 * that the data is valid. If stop==1 we simulate full read back
2089 * of two tapes. If stop==-1 we simply read the last block and
2090 * verify that it is correct.
2092 static void unfillcmd()
2096 last_block1 = new_block(dev);
2097 last_block2 = new_block(dev);
2098 first_block = new_block(dev);
2099 sprintf(buf, "%s/btape.state", working_directory);
2100 fd = open(buf, O_RDONLY);
2102 uint32_t state_level;
2103 read(fd, &state_level, sizeof(btape_state_level));
2104 read(fd, &simple, sizeof(simple));
2105 read(fd, &last_block_num1, sizeof(last_block_num1));
2106 read(fd, &last_block_num2, sizeof(last_block_num2));
2107 read(fd, &last_file1, sizeof(last_file1));
2108 read(fd, &last_file2, sizeof(last_file2));
2109 read(fd, last_block1->buf, last_block1->buf_len);
2110 read(fd, last_block2->buf, last_block2->buf_len);
2111 read(fd, first_block->buf, first_block->buf_len);
2113 if (state_level != btape_state_level) {
2114 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2115 "the fill command.\n"));
2120 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2121 "You must redo the fill command.\n"), buf, be.bstrerror());
2128 static void do_unfill()
2130 DEV_BLOCK *block = dcr->block;
2137 Dmsg0(20, "Enter do_unfill\n");
2138 dev->set_cap(CAP_ANONVOLS); /* allow reading any volume */
2139 dev->clear_cap(CAP_LABEL); /* don't label anything here */
2143 time(&jcr->run_time); /* start counting time for rates */
2147 free_block(last_block);
2150 last_block_num = last_block_num1;
2151 last_file = last_file1;
2152 last_block = last_block1;
2154 free_restore_volume_list(jcr);
2156 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2157 create_restore_volume_list(jcr);
2158 if (jcr->VolList != NULL) {
2159 jcr->VolList->Slot = 1;
2160 if (jcr->VolList->next != NULL) {
2161 jcr->VolList->next->Slot = 2;
2165 set_volume_name("TestVolume1", 1);
2168 /* Multiple Volume tape */
2169 /* Close device so user can use autochanger if desired */
2170 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2173 autochanger = autoload_device(dcr, 1, NULL);
2174 if (autochanger != 1) {
2176 get_cmd(_("Mount first tape. Press enter when ready: "));
2181 dev->num_writers = 0;
2182 if (!acquire_device_for_read(dcr)) {
2183 Pmsg1(-1, "%s", dev->errmsg);
2187 * We now have the first tape mounted.
2188 * Note, re-reading last block may have caused us to
2189 * loose track of where we are (block number unknown).
2191 Pmsg0(-1, _("Rewinding.\n"));
2192 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2195 /* Read the first 10000 records */
2196 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2197 dev->file, dev->block_num);
2199 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2200 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2201 last_file, last_block_num);
2202 if (!dev->reposition(dcr, last_file, last_block_num)) {
2203 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2206 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2207 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2208 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2211 if (compare_blocks(last_block, block)) {
2213 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2215 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2222 /* restore info for last block on second Volume */
2223 last_block_num = last_block_num2;
2224 last_file = last_file2;
2225 last_block = last_block2;
2227 /* Multiple Volume tape */
2228 /* Close device so user can use autochanger if desired */
2229 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2233 set_volume_name("TestVolume2", 2);
2235 autochanger = autoload_device(dcr, 1, NULL);
2236 if (autochanger != 1) {
2238 get_cmd(_("Mount second tape. Press enter when ready: "));
2242 if (!acquire_device_for_read(dcr)) {
2243 Pmsg1(-1, "%s", dev->errmsg);
2247 /* Space to "first" block which is last block not written
2248 * on the previous tape.
2250 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2251 if (!dev->reposition(dcr, 0, 1)) {
2252 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2255 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2256 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2257 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2260 if (compare_blocks(first_block, block)) {
2261 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2264 /* Now find and compare the last block */
2265 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2266 last_file, last_block_num);
2267 if (!dev->reposition(dcr, last_file, last_block_num)) {
2268 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2271 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2272 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2273 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2276 if (compare_blocks(last_block, block)) {
2277 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2281 free_block(last_block1);
2282 free_block(last_block2);
2283 free_block(first_block);
2286 /* Read 10000 records then stop */
2287 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2289 DEVICE *dev = dcr->dev;
2291 if (quickie_count == 10000) {
2292 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2294 return quickie_count < 10000;
2297 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2300 uint32_t CheckSum, block_len;
2303 p = last_block->buf;
2305 unser_begin(q, BLKHDR2_LENGTH);
2306 unser_uint32(CheckSum);
2307 unser_uint32(block_len);
2308 while (q < (block->buf+block_len)) {
2315 dump_block(last_block, _("Last block written"));
2317 dump_block(block, _("Block read back"));
2318 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2319 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2320 "that was read back differ. The test FAILED !!!!\n"
2321 "This must be corrected before you use Bacula\n"
2322 "to write multi-tape Volumes.!!!!\n"));
2326 dump_block(last_block, _("Last block written"));
2327 dump_block(block, _("Block read back"));
2337 * Write current block to tape regardless of whether or
2338 * not it is full. If the tape fills, attempt to
2339 * acquire another tape.
2341 static int flush_block(DEV_BLOCK *block, int dump)
2345 uint32_t this_file, this_block_num;
2349 this_block = new_block(dev);
2352 last_block = new_block(dev);
2355 this_file = dev->file;
2356 this_block_num = dev->block_num;
2357 if (!write_block_to_dev(dcr)) {
2358 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2359 last_file, last_block_num, this_block_num);
2362 * This is 1st tape, so save first tape info separate
2363 * from second tape info
2365 last_block_num1 = last_block_num;
2366 last_file1 = last_file;
2367 last_block1 = dup_block(last_block);
2368 last_block2 = dup_block(last_block);
2369 first_block = dup_block(block); /* first block second tape */
2372 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2373 (unsigned)file_index, block->BlockNumber, block->block_len);
2374 dump_block(last_block, _("Last block written"));
2376 dump_block(block, _("Block not written"));
2379 eot_block = block->BlockNumber;
2380 eot_block_len = block->block_len;
2381 eot_FileIndex = file_index;
2385 now -= jcr->run_time;
2387 now = 1; /* don't divide by zero */
2389 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2390 vol_size = dev->VolCatInfo.VolCatBytes;
2391 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2392 dev->file, dev->block_num,
2393 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2396 stop = -1; /* stop, but do simplified test */
2398 /* Full test in progress */
2399 if (!fixup_device_block_write_error(jcr->dcr)) {
2400 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2405 BlockNumber = 0; /* start counting for second tape */
2408 return 1; /* end of tape reached */
2411 /* Save contents after write so that the header is serialized */
2412 memcpy(this_block->buf, block->buf, this_block->buf_len);
2415 * Note, we always read/write to block, but we toggle
2416 * copying it to one or another of two allocated blocks.
2417 * Switch blocks so that the block just successfully written is
2418 * always in last_block.
2420 tblock = last_block;
2421 last_block = this_block;
2422 this_block = tblock;
2423 last_file = this_file;
2424 last_block_num = this_block_num;
2432 * First we label the tape, then we fill
2433 * it with data get a new tape and write a few blocks.
2435 static void qfillcmd()
2437 DEV_BLOCK *block = dcr->block;
2438 DEV_RECORD *rec = dcr->rec;
2441 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2443 get_cmd(_("How many blocks do you want to write? (1000): "));
2450 sm_check(__FILE__, __LINE__, false);
2452 i = block->buf_len - 100;
2454 rec->data = check_pool_memory_size(rec->data, i);
2455 memset(rec->data, i & 0xFF, i);
2458 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2459 for (i=0; i < count; i++) {
2464 if (!write_record_to_block(block, rec)) {
2465 Pmsg0(0, _("Error writing record to block.\n"));
2468 if (!write_block_to_dev(dcr)) {
2469 Pmsg0(0, _("Error writing block to device.\n"));
2475 if (dev->has_cap(CAP_TWOEOF)) {
2482 sm_check(__FILE__, __LINE__, false);
2486 * Fill a tape using raw write() command
2488 static void rawfill_cmd()
2490 DEV_BLOCK *block = dcr->block;
2493 uint32_t block_num = 0;
2498 fd = open("/dev/urandom", O_RDONLY);
2500 read(fd, block->buf, block->buf_len);
2503 uint32_t *p = (uint32_t *)block->buf;
2504 srandom(time(NULL));
2505 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2509 p = (uint32_t *)block->buf;
2510 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2513 stat = dev->d_write(dev->fd(), block->buf, block->buf_len);
2514 if (stat == (int)block->buf_len) {
2515 if ((block_num++ % 100) == 0) {
2520 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2530 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2531 be.bstrerror(my_errno));
2537 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2538 static struct cmdstruct commands[] = {
2539 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2540 {NT_("bsf"), bsfcmd, _("backspace file")},
2541 {NT_("bsr"), bsrcmd, _("backspace record")},
2542 {NT_("cap"), capcmd, _("list device capabilities")},
2543 {NT_("clear"), clearcmd, _("clear tape errors")},
2544 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2545 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2546 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2547 {NT_("unfill"), unfillcmd, _("read filled tape")},
2548 {NT_("fsf"), fsfcmd, _("forward space a file")},
2549 {NT_("fsr"), fsrcmd, _("forward space a record")},
2550 {NT_("help"), helpcmd, _("print this command")},
2551 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2552 {NT_("load"), loadcmd, _("load a tape")},
2553 {NT_("quit"), quitcmd, _("quit btape")},
2554 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2555 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2556 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2557 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2558 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2559 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2560 {NT_("status"), statcmd, _("print tape status")},
2561 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2562 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2563 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2564 {NT_("rr"), rrcmd, _("read a single record")},
2565 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2566 {NT_("qfill"), qfillcmd, _("quick fill command")}
2568 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2576 while (!quit && get_cmd("*")) {
2577 sm_check(__FILE__, __LINE__, false);
2579 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2580 for (i=0; i<comsize; i++) /* search for command */
2581 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2582 (*commands[i].func)(); /* go execute command */
2586 if (*cmd && !found) {
2587 Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2592 static void helpcmd()
2596 printf(_("Interactive commands:\n"));
2597 printf(_(" Command Description\n ======= ===========\n"));
2598 for (i=0; i<comsize; i++)
2599 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2607 "\nVersion: %s (%s)\n\n"
2608 "Usage: btape <options> <device_name>\n"
2609 " -b <file> specify bootstrap file\n"
2610 " -c <file> set configuration file to file\n"
2611 " -d <nn> set debug level to <nn>\n"
2612 " -dt print timestamp in debug output\n"
2613 " -p proceed inspite of I/O errors\n"
2614 " -s turn off signals\n"
2616 " -? print this message.\n"
2617 "\n"), 2000, VERSION, BDATE);
2622 * Get next input command from terminal. This
2623 * routine is REALLY primitive, and should be enhanced
2624 * to have correct backspacing, etc.
2627 get_cmd(const char *prompt)
2631 fprintf(stdout, prompt);
2633 /* We really should turn off echoing and pretty this
2637 while ((ch = fgetc(stdin)) != EOF) {
2639 strip_trailing_junk(cmd);
2641 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2654 /* Dummies to replace askdir.c */
2655 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2656 bool dir_send_job_status(JCR *jcr) {return 1;}
2658 bool dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten)
2664 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2666 Dmsg0(20, "Enter dir_get_volume_info\n");
2667 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2671 bool dir_create_jobmedia_record(DCR *dcr, bool zero)
2673 dcr->WroteVol = false;
2678 bool dir_find_next_appendable_volume(DCR *dcr)
2680 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2681 return dcr->VolumeName[0] != 0;
2684 bool dir_ask_sysop_to_mount_volume(DCR *dcr, int /* mode */)
2686 DEVICE *dev = dcr->dev;
2687 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2688 if (dcr->VolumeName[0] == 0) {
2689 return dir_ask_sysop_to_create_appendable_volume(dcr);
2691 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2692 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2693 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2696 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2697 dcr->VolumeName, dev->print_name());
2704 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2707 DEVICE *dev = dcr->dev;
2708 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2710 set_volume_name("TestVolume1", 1);
2712 set_volume_name("TestVolume2", 2);
2714 /* Close device so user can use autochanger if desired */
2715 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2718 autochanger = autoload_device(dcr, 1, NULL);
2719 if (autochanger != 1) {
2720 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2731 static bool my_mount_next_read_volume(DCR *dcr)
2734 JCR *jcr = dcr->jcr;
2735 DEV_BLOCK *block = dcr->block;
2737 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2738 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2741 volume_unused(dcr); /* release current volume */
2742 if (LastBlock != block->BlockNumber) {
2743 VolBytes += block->block_len;
2745 LastBlock = block->BlockNumber;
2747 now -= jcr->run_time;
2751 kbs = (double)VolBytes / (1000.0 * (double)now);
2752 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2753 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2755 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2760 set_volume_name("TestVolume2", 2);
2763 if (!acquire_device_for_read(dcr)) {
2764 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2767 return true; /* next volume mounted */
2770 static void set_volume_name(const char *VolName, int volnum)
2772 DCR *dcr = jcr->dcr;
2773 VolumeName = VolName;
2775 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2776 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2777 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2778 dcr->VolCatInfo.Slot = volnum;
2779 dcr->VolCatInfo.InChanger = true;