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;
79 #define REC_SIZE 32768
81 /* Forward referenced subroutines */
82 static void do_tape_cmds();
83 static void helpcmd();
84 static void scancmd();
85 static void rewindcmd();
86 static void clearcmd();
91 static void fillcmd();
92 static void qfillcmd();
93 static void statcmd();
94 static void unfillcmd();
95 static int flush_block(DEV_BLOCK *block, int dump);
96 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
97 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
98 static bool my_mount_next_read_volume(DCR *dcr);
99 static void scan_blocks();
100 static void set_volume_name(const char *VolName, int volnum);
101 static void rawfill_cmd();
102 static bool open_the_device();
103 static void autochangercmd();
104 static bool do_unfill();
107 /* Static variables */
108 static CONFIG *config;
109 #define CONFIG_FILE "bacula-sd.conf"
110 char *configfile = NULL;
112 #define MAX_CMD_ARGS 30
114 static POOLMEM *args;
115 static char *argk[MAX_CMD_ARGS];
116 static char *argv[MAX_CMD_ARGS];
119 static int quickie_count = 0;
120 static uint64_t write_count = 0;
121 static BSR *bsr = NULL;
122 static int signals = TRUE;
125 static uint64_t vol_size;
126 static uint64_t VolBytes;
129 static int32_t file_index;
130 static int end_of_tape = 0;
131 static uint32_t LastBlock = 0;
132 static uint32_t eot_block;
133 static uint32_t eot_block_len;
134 static uint32_t eot_FileIndex;
135 static int dumped = 0;
136 static DEV_BLOCK *last_block1 = NULL;
137 static DEV_BLOCK *last_block2 = NULL;
138 static DEV_BLOCK *last_block = NULL;
139 static DEV_BLOCK *this_block = NULL;
140 static DEV_BLOCK *first_block = NULL;
141 static uint32_t last_file1 = 0;
142 static uint32_t last_file2 = 0;
143 static uint32_t last_file = 0;
144 static uint32_t last_block_num1 = 0;
145 static uint32_t last_block_num2 = 0;
146 static uint32_t last_block_num = 0;
147 static uint32_t BlockNumber = 0;
148 static bool simple = true;
150 static const char *VolumeName = NULL;
151 static int vol_num = 0;
153 static JCR *jcr = NULL;
157 static void terminate_btape(int sig);
158 int get_cmd(const char *prompt);
161 /*********************************************************************
163 * Bacula tape testing program
166 int main(int margc, char *margv[])
173 setlocale(LC_ALL, "");
174 bindtextdomain("bacula", LOCALEDIR);
175 textdomain("bacula");
179 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
180 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
181 TAPE_BSIZE, B_DEV_BSIZE);
183 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
184 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
186 if (sizeof(boffset_t) < 8) {
187 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. boffset_t=%d should be 8 or more !!!!!\n\n\n"),
191 bsnprintf(buf, sizeof(buf), "%u", x32);
192 i = bsscanf(buf, "%lu", &y32);
193 if (i != 1 || x32 != y32) {
194 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
200 bsnprintf(buf, sizeof(buf), "%" llu, x64);
201 i = bsscanf(buf, "%llu", &y64);
202 if (i != 1 || x64 != y64) {
203 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
208 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
210 working_directory = "/tmp";
211 my_name_is(margc, margv, "btape");
212 init_msg(NULL, NULL);
216 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
218 case 'b': /* bootstrap file */
219 bsr = parse_bsr(NULL, optarg);
220 // dump_bsr(bsr, true);
223 case 'c': /* specify config file */
224 if (configfile != NULL) {
227 configfile = bstrdup(optarg);
230 case 'd': /* set debug level */
231 if (*optarg == 't') {
232 dbg_timestamp = true;
234 debug_level = atoi(optarg);
235 if (debug_level <= 0) {
263 cmd = get_pool_memory(PM_FNAME);
264 args = get_pool_memory(PM_FNAME);
267 init_signals(terminate_btape);
270 if (configfile == NULL) {
271 configfile = bstrdup(CONFIG_FILE);
274 daemon_start_time = time(NULL);
276 config = new_config_parser();
277 parse_sd_config(config, configfile, M_ERROR_TERM);
279 /* See if we can open a device */
281 Pmsg0(000, _("No archive name specified.\n"));
284 } else if (margc != 1) {
285 Pmsg0(000, _("Improper number of arguments specified.\n"));
290 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
299 Pmsg0(000, _("btape does not work with DVD storage.\n"));
303 if (!dev->is_tape()) {
304 Pmsg0(000, _("btape only works with tape storage.\n"));
309 if (!open_the_device()) {
313 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 void init_speed()
372 time(&jcr->run_time); /* start counting time for rates */
376 static void print_speed(uint64_t bytes)
380 now -= jcr->run_time;
382 now = 1; /* don't divide by zero */
384 kbs = (double)bytes / (1000 * now);
385 Pmsg2(000, _("VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
386 edit_uint64_with_commas(bytes, ec1), kbs);
389 static bool open_the_device()
394 block = new_block(dev);
396 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
397 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
398 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
402 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
403 dev->set_append(); /* put volume in append mode */
418 * Write a label to the tape
420 static void labelcmd()
423 pm_strcpy(cmd, VolumeName);
425 if (!get_cmd(_("Enter Volume Name: "))) {
430 if (!dev->is_open()) {
431 if (!first_open_device(dcr)) {
432 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
436 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
437 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
441 * Read the tape label
443 static void readlabelcmd()
445 int save_debug_level = debug_level;
448 stat = read_dev_volume_label(dcr);
451 Pmsg0(0, _("Volume has no label.\n"));
454 Pmsg0(0, _("Volume label read correctly.\n"));
457 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
460 Pmsg0(0, _("Volume name error\n"));
462 case VOL_CREATE_ERROR:
463 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
465 case VOL_VERSION_ERROR:
466 Pmsg0(0, _("Volume version error.\n"));
468 case VOL_LABEL_ERROR:
469 Pmsg0(0, _("Bad Volume label type.\n"));
472 Pmsg0(0, _("Unknown error.\n"));
477 dump_volume_label(dev);
478 debug_level = save_debug_level;
483 * Load the tape should have prevously been taken
484 * off line, otherwise this command is not necessary.
486 static void loadcmd()
489 if (!load_dev(dev)) {
490 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
492 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
498 static void rewindcmd()
500 if (!dev->rewind(dcr)) {
501 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
504 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
509 * Clear any tape error
511 static void clearcmd()
517 * Write and end of file on the tape
519 static void weofcmd()
529 if (!dev->weof(num)) {
530 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
534 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
537 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
543 /* Go to the end of the medium -- raw command
544 * The idea was orginally that the end of the Bacula
545 * medium would be flagged differently. This is not
546 * currently the case. So, this is identical to the
551 if (!dev->eod(dcr)) {
552 Pmsg1(0, "%s", dev->bstrerror());
555 Pmsg0(0, _("Moved to end of medium.\n"));
560 * Go to the end of the medium (either hardware determined
561 * or defined by two eofs.
581 if (!dev->bsf(num)) {
582 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
584 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
600 if (!dev->bsr(num)) {
601 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
603 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
608 * List device capabilities as defined in the
613 printf(_("Configured device capabilities:\n"));
614 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
615 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
616 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
617 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
618 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
619 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
620 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
621 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
622 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
623 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
624 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
625 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
626 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
627 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
628 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
631 printf(_("Device status:\n"));
632 printf("%sOPENED ", dev->is_open() ? "" : "!");
633 printf("%sTAPE ", dev->is_tape() ? "" : "!");
634 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
635 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
636 printf("%sAPPEND ", dev->can_append() ? "" : "!");
637 printf("%sREAD ", dev->can_read() ? "" : "!");
638 printf("%sEOT ", dev->at_eot() ? "" : "!");
639 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
640 printf("%sEOF ", dev->at_eof() ? "" : "!");
641 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
642 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
645 printf(_("Device parameters:\n"));
646 printf("Device name: %s\n", dev->dev_name);
647 printf("File=%u block=%u\n", dev->file, dev->block_num);
648 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
650 printf(_("Status:\n"));
656 * Test writing larger and larger records.
657 * This is a torture test for records.
659 static void rectestcmd()
665 Pmsg0(0, _("Test writing larger and larger records.\n"
666 "This is a torture test for records.\nI am going to write\n"
667 "larger and larger records. It will stop when the record size\n"
668 "plus the header exceeds the block size (by default about 64K)\n"));
671 get_cmd(_("Do you want to continue? (y/n): "));
673 Pmsg0(000, _("Command aborted.\n"));
677 sm_check(__FILE__, __LINE__, false);
678 block = new_block(dev);
681 for (i=1; i<500000; i++) {
682 rec->data = check_pool_memory_size(rec->data, i);
683 memset(rec->data, i & 0xFF, i);
685 sm_check(__FILE__, __LINE__, false);
686 if (write_record_to_block(block, rec)) {
689 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
693 sm_check(__FILE__, __LINE__, false);
697 sm_check(__FILE__, __LINE__, false);
701 * This test attempts to re-read a block written by Bacula
702 * normally at the end of the tape. Bacula will then back up
703 * over the two eof marks, backup over the record and reread
704 * it to make sure it is valid. Bacula can skip this validation
705 * if you set "Backward space record = no"
707 static bool re_read_block_test()
709 DEV_BLOCK *block = dcr->block;
714 if (!(dev->capabilities & CAP_BSR)) {
715 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
719 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
720 "I'm going to write three records and an EOF\n"
721 "then backup over the EOF and re-read the last record.\n"
722 "Bacula does this after writing the last block on the\n"
723 "tape to verify that the block was written correctly.\n\n"
724 "This is not an *essential* feature ...\n\n"));
728 rec->data = check_pool_memory_size(rec->data, block->buf_len);
729 len = rec->data_len = block->buf_len-100;
730 memset(rec->data, 1, rec->data_len);
731 if (!write_record_to_block(block, rec)) {
732 Pmsg0(0, _("Error writing record to block.\n"));
735 if (!write_block_to_dev(dcr)) {
736 Pmsg0(0, _("Error writing block to device.\n"));
739 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
741 memset(rec->data, 2, rec->data_len);
742 if (!write_record_to_block(block, rec)) {
743 Pmsg0(0, _("Error writing record to block.\n"));
746 if (!write_block_to_dev(dcr)) {
747 Pmsg0(0, _("Error writing block to device.\n"));
750 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
752 memset(rec->data, 3, rec->data_len);
753 if (!write_record_to_block(block, rec)) {
754 Pmsg0(0, _("Error writing record to block.\n"));
757 if (!write_block_to_dev(dcr)) {
758 Pmsg0(0, _("Error writing block to device.\n"));
761 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
764 if (dev->has_cap(CAP_TWOEOF)) {
768 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
771 if (dev->has_cap(CAP_TWOEOF)) {
773 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
777 Pmsg0(0, _("Backspaced over EOF OK.\n"));
779 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
782 Pmsg0(0, _("Backspace record OK.\n"));
783 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
785 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
788 memset(rec->data, 0, rec->data_len);
789 if (!read_record_from_block(dcr, block, rec)) {
791 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
794 for (int i=0; i<len; i++) {
795 if (rec->data[i] != 3) {
796 Pmsg0(0, _("Bad data in record. Test failed!\n"));
800 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
801 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
808 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
809 "this function to verify the last block written to the\n"
810 "tape. Bacula will skip the last block verification\n"
812 "Backward Space Record = No\n\n"
813 "to your Storage daemon's Device resource definition.\n"));
818 const int num_recs = 10000;
820 static bool write_two_files()
826 bool rc = false; /* bad return code */
828 Pmsg2(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
829 "I'm going to write %d records and an EOF\n"
830 "then write %d records and an EOF, then rewind,\n"
831 "and re-read the data to verify that it is correct.\n\n"
832 "This is an *essential* feature ...\n\n"), num_recs, num_recs);
837 rec->data = check_pool_memory_size(rec->data, block->buf_len);
838 rec->data_len = block->buf_len-100;
839 len = rec->data_len/sizeof(i);
841 if (!dev->rewind(dcr)) {
842 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
846 for (i=1; i<=num_recs; i++) {
847 p = (int *)rec->data;
848 for (j=0; j<len; j++) {
851 if (!write_record_to_block(block, rec)) {
852 Pmsg0(0, _("Error writing record to block.\n"));
855 if (!write_block_to_dev(dcr)) {
856 Pmsg0(0, _("Error writing block to device.\n"));
860 Pmsg2(0, _("Wrote %d blocks of %d bytes.\n"), num_recs, rec->data_len);
862 for (i=num_recs+1; i<=2*num_recs; i++) {
863 p = (int *)rec->data;
864 for (j=0; j<len; j++) {
867 if (!write_record_to_block(block, rec)) {
868 Pmsg0(0, _("Error writing record to block.\n"));
871 if (!write_block_to_dev(dcr)) {
872 Pmsg0(0, _("Error writing block to device.\n"));
876 Pmsg2(0, _("Wrote %d blocks of %d bytes.\n"), num_recs, rec->data_len);
878 if (dev->has_cap(CAP_TWOEOF)) {
893 * This test writes Bacula blocks to the tape in
894 * several files. It then rewinds the tape and attepts
895 * to read these blocks back checking the data.
897 static bool write_read_test()
907 if (!write_two_files()) {
914 if (!dev->rewind(dcr)) {
915 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
918 Pmsg0(0, _("Rewind OK.\n"));
921 rec->data = check_pool_memory_size(rec->data, block->buf_len);
922 rec->data_len = block->buf_len-100;
923 len = rec->data_len/sizeof(i);
925 /* Now read it back */
926 for (i=1; i<=2*num_recs; i++) {
928 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
930 if (dev_state(dev, ST_EOF)) {
931 Pmsg0(-1, _("Got EOF on tape.\n"));
932 if (i == num_recs+1) {
936 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
939 memset(rec->data, 0, rec->data_len);
940 if (!read_record_from_block(dcr, block, rec)) {
942 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
945 p = (int *)rec->data;
946 for (j=0; j<len; j++) {
948 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
954 if (i == num_recs || i == 2*num_recs) {
955 Pmsg1(-1, _("%d blocks re-read correctly.\n"), num_recs);
958 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
970 * This test writes Bacula blocks to the tape in
971 * several files. It then rewinds the tape and attepts
972 * to read these blocks back checking the data.
974 static bool position_test()
976 DEV_BLOCK *block = dcr->block;
982 int file = 0, blk = 0;
984 bool got_eof = false;
986 Pmsg0(0, _("Block position test\n"));
990 rec->data = check_pool_memory_size(rec->data, block->buf_len);
991 rec->data_len = block->buf_len-100;
992 len = rec->data_len/sizeof(j);
994 if (!dev->rewind(dcr)) {
995 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
998 Pmsg0(0, _("Rewind OK.\n"));
1002 /* Set up next item to read based on where we are */
1003 /* At each step, recno is what we print for the "block number"
1004 * and file, blk are the real positions to go to.
1028 recno = num_recs+601;
1041 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1042 if (!dev->reposition(dcr, file, blk)) {
1043 Pmsg0(0, _("Reposition error.\n"));
1047 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1049 if (dev_state(dev, ST_EOF)) {
1050 Pmsg0(-1, _("Got EOF on tape.\n"));
1056 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1057 recno, file, blk, be.bstrerror(dev->dev_errno));
1058 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1059 " set to variable blocking as normally used by Bacula.\n"
1060 " Please see the Tape Testing chapter in the manual and \n"
1061 " look for using mt with defblksize and setoptions\n"
1062 "If your tape drive block size is correct, then perhaps\n"
1063 " your SCSI driver is *really* stupid and does not\n"
1064 " correctly report the file:block after a FSF. In this\n"
1065 " case try setting:\n"
1066 " Fast Forward Space File = no\n"
1067 " in your Device resource.\n"));
1071 memset(rec->data, 0, rec->data_len);
1072 if (!read_record_from_block(dcr, block, rec)) {
1074 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1077 p = (int *)rec->data;
1078 for (j=0; j<len; j++) {
1079 if (p[j] != recno) {
1080 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1085 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1087 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1099 * This test writes some records, then writes an end of file,
1100 * rewinds the tape, moves to the end of the data and attepts
1101 * to append to the tape. This function is essential for
1102 * Bacula to be able to write multiple jobs to the tape.
1104 static int append_test()
1106 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1107 "This test is essential to Bacula.\n\n"
1108 "I'm going to write one record in file 0,\n"
1109 " two records in file 1,\n"
1110 " and three records in file 2\n\n"));
1114 weofcmd(); /* end file 0 */
1117 weofcmd(); /* end file 1 */
1121 weofcmd(); /* end file 2 */
1122 if (dev->has_cap(CAP_TWOEOF)) {
1125 dev->close(); /* release device */
1126 if (!open_the_device()) {
1130 Pmsg0(0, _("Now moving to end of medium.\n"));
1132 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1133 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1135 if (dev->file != 3) {
1139 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1142 if (dev->has_cap(CAP_TWOEOF)) {
1146 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1147 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1149 Pmsg0(-1, _("End scanning the tape.\n"));
1150 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1151 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1153 if (dev->file != 4) {
1161 * This test exercises the autochanger
1163 static int autochanger_test()
1165 POOLMEM *results, *changer;
1166 int slot, status, loaded;
1167 int timeout = dcr->device->max_changer_wait;
1170 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1171 if (!dev->has_cap(CAP_AUTOCHANGER)) {
1174 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1175 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1179 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1180 "To test the autochanger you must have a blank tape\n"
1181 " that I can write on in Slot 1.\n"));
1182 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1185 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1189 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1191 results = get_pool_memory(PM_MESSAGE);
1192 changer = get_pool_memory(PM_FNAME);
1196 dcr->VolCatInfo.Slot = slot;
1197 /* Find out what is loaded, zero means device is unloaded */
1198 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1199 changer = edit_device_codes(dcr, changer,
1200 dcr->device->changer_command, "loaded");
1201 status = run_program(changer, timeout, results);
1202 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1204 loaded = atoi(results);
1207 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1208 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1212 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1214 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1216 Dmsg1(100, "Results from loaded query=%s\n", results);
1218 dcr->VolCatInfo.Slot = loaded;
1219 /* We are going to load a new tape, so close the device */
1221 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1222 loaded, dev->drive_index);
1223 changer = edit_device_codes(dcr, changer,
1224 dcr->device->changer_command, "unload");
1225 status = run_program(changer, timeout, results);
1226 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1229 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1230 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1239 dcr->VolCatInfo.Slot = slot;
1240 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1241 slot, dev->drive_index);
1242 changer = edit_device_codes(dcr, changer,
1243 dcr->device->changer_command, "load");
1244 Dmsg1(100, "Changer=%s\n", changer);
1246 status = run_program(changer, timeout, results);
1248 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1249 slot, dev->drive_index);
1252 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1253 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1257 if (!open_the_device()) {
1261 * Start with sleep_time 0 then increment by 30 seconds if we get
1264 bmicrosleep(sleep_time, 0);
1265 if (!dev->rewind(dcr) || !dev->weof(1)) {
1266 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1268 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1269 "a longer sleep time in the mtx-script in the load) case.\n"
1270 "Adding a 30 second sleep and trying again ...\n"));
1274 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1277 if (!dev->weof(1)) {
1278 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1281 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1285 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1287 "to your mtx-changer script in the load) case.\n\n"),
1290 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1293 free_pool_memory(changer);
1294 free_pool_memory(results);
1299 free_pool_memory(changer);
1300 free_pool_memory(results);
1301 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1305 static void autochangercmd()
1312 * This test assumes that the append test has been done,
1313 * then it tests the fsf function.
1315 static bool fsf_test()
1317 bool set_off = false;
1319 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1320 "This test is essential to Bacula.\n\n"
1321 "I'm going to write five files then test forward spacing\n\n"));
1325 weofcmd(); /* end file 0 */
1328 weofcmd(); /* end file 1 */
1332 weofcmd(); /* end file 2 */
1335 weofcmd(); /* end file 3 */
1337 weofcmd(); /* end file 4 */
1338 if (dev->has_cap(CAP_TWOEOF)) {
1344 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1346 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1349 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1350 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1352 if (dev->file != 1) {
1356 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1358 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1361 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1362 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1364 if (dev->file != 3) {
1369 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1371 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1374 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1375 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1377 if (dev->file != 4) {
1381 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1382 " Fast Forward Space File = no\n\n"
1383 "to your Device resource for this drive.\n"));
1387 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1389 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1391 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1392 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1393 if (dev->file != 5) {
1396 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1400 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1401 if (dev->has_cap(CAP_FASTFSF)) {
1402 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1403 "I am turning it off then retrying the test.\n"));
1404 dev->clear_cap(CAP_FASTFSF);
1408 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1409 "Some systems, e.g. OpenBSD, require you to set\n"
1410 " Use MTIOCGET= no\n"
1411 "in your device resource. Use with caution.\n"));
1420 * This is a general test of Bacula's functions
1421 * needed to read and write the tape.
1423 static void testcmd()
1427 if (!write_read_test()) {
1431 if (!position_test()) {
1436 stat = append_test();
1437 if (stat == 1) { /* OK get out */
1440 if (stat == -1) { /* first test failed */
1441 if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1442 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1443 "Setting \"Hardware End of Medium = no\n"
1444 " and \"Fast Forward Space File = no\n"
1445 "and retrying append test.\n\n"));
1446 dev->clear_cap(CAP_EOM); /* turn off eom */
1447 dev->clear_cap(CAP_FASTFSF); /* turn off fast fsf */
1448 stat = append_test();
1450 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1451 " Hardware End of Medium = No\n\n"
1452 " Fast Forward Space File = No\n"
1453 "to your Device resource in the Storage conf file.\n"));
1457 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1460 /* Wrong count after append */
1462 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1463 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1464 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1465 stat = append_test();
1467 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1468 " Hardware End of Medium = No\n"
1469 " Fast Forward Space File = No\n"
1470 " BSF at EOM = yes\n\n"
1471 "to your Device resource in the Storage conf file.\n"));
1478 Pmsg0(-1, _("\nAppend test failed.\n\n"
1479 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1480 "Unable to correct the problem. You MUST fix this\n"
1481 "problem before Bacula can use your tape drive correctly\n"
1482 "\nPerhaps running Bacula in fixed block mode will work.\n"
1483 "Do so by setting:\n\n"
1484 "Minimum Block Size = nnn\n"
1485 "Maximum Block Size = nnn\n\n"
1486 "in your Storage daemon's Device definition.\n"
1487 "nnn must match your tape driver's block size, which\n"
1488 "can be determined by reading your tape manufacturers\n"
1489 "information, and the information on your kernel dirver.\n"
1490 "Fixed block sizes, however, are not normally an ideal solution.\n"
1492 "Some systems, e.g. OpenBSD, require you to set\n"
1493 " Use MTIOCGET= no\n"
1494 "in your device resource. Use with caution.\n"));
1500 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1501 "Please double check it ...\n"
1502 "=== Sample correct output ===\n"
1503 "1 block of 64448 bytes in file 1\n"
1504 "End of File mark.\n"
1505 "2 blocks of 64448 bytes in file 2\n"
1506 "End of File mark.\n"
1507 "3 blocks of 64448 bytes in file 3\n"
1508 "End of File mark.\n"
1509 "1 block of 64448 bytes in file 4\n"
1510 "End of File mark.\n"
1511 "Total files=4, blocks=7, bytes = 451,136\n"
1512 "=== End sample correct output ===\n\n"
1513 "If the above scan output is not identical to the\n"
1514 "sample output, you MUST correct the problem\n"
1515 "or Bacula will not be able to write multiple Jobs to \n"
1519 if (!re_read_block_test()) {
1524 if (!fsf_test()) { /* do fast forward space file test */
1528 autochanger_test(); /* do autochanger test */
1532 /* Forward space a file */
1533 static void fsfcmd()
1537 num = atoi(argk[1]);
1542 if (!dev->fsf(num)) {
1543 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1547 Pmsg0(0, _("Forward spaced 1 file.\n"));
1550 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1554 /* Forward space a record */
1555 static void fsrcmd()
1559 num = atoi(argk[1]);
1564 if (!dev->fsr(num)) {
1565 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1569 Pmsg0(0, _("Forward spaced 1 record.\n"));
1572 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1577 * Read a Bacula block from the tape
1581 dev->open(dcr, OPEN_READ_ONLY);
1582 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1586 * Write a Bacula block to the tape
1590 DEV_BLOCK *block = dcr->block;
1591 DEV_RECORD *rec = dcr->rec;
1594 if (!dev->is_open()) {
1597 sm_check(__FILE__, __LINE__, false);
1600 dump_block(block, "test");
1603 i = block->buf_len - 100;
1605 rec->data = check_pool_memory_size(rec->data, i);
1606 memset(rec->data, i & 0xFF, i);
1608 sm_check(__FILE__, __LINE__, false);
1609 if (!write_record_to_block(block, rec)) {
1610 Pmsg0(0, _("Error writing record to block.\n"));
1613 if (!write_block_to_dev(dcr)) {
1614 Pmsg0(0, _("Error writing block to device.\n"));
1617 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1619 Pmsg0(0, _("Wrote block to device.\n"));
1622 sm_check(__FILE__, __LINE__, false);
1623 sm_check(__FILE__, __LINE__, false);
1627 * Read a record from the tape
1634 if (!get_cmd(_("Enter length to read: "))) {
1638 if (len < 0 || len > 1000000) {
1639 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1642 buf = (char *)malloc(len);
1643 stat = read(dev->fd(), buf, len);
1644 if (stat > 0 && stat <= len) {
1648 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1649 len, stat, be.bstrerror());
1655 * Scan tape by reading block by block. Report what is
1656 * on the tape. Note, this command does raw reads, and as such
1657 * will not work with fixed block size devices.
1659 static void scancmd()
1662 int blocks, tot_blocks, tot_files;
1668 blocks = block_size = tot_blocks = 0;
1670 if (dev->state & ST_EOT) {
1671 Pmsg0(0, _("End of tape\n"));
1674 dev->update_pos(dcr);
1675 tot_files = dev->file;
1676 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1678 if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1681 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1682 dev->dev_name, be.bstrerror());
1683 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1686 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1689 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1694 Dmsg1(200, "read status = %d\n", stat);
1696 if (stat != block_size) {
1697 dev->update_pos(dcr);
1700 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1703 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1709 if (stat == 0) { /* EOF */
1710 dev->update_pos(dcr);
1711 printf(_("End of File mark.\n"));
1712 /* Two reads of zero means end of tape */
1713 if (dev->state & ST_EOF)
1714 dev->state |= ST_EOT;
1716 dev->state |= ST_EOF;
1719 if (dev->state & ST_EOT) {
1720 printf(_("End of tape\n"));
1723 } else { /* Got data */
1724 dev->state &= ~ST_EOF;
1730 dev->update_pos(dcr);
1731 tot_files = dev->file - tot_files;
1732 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1733 edit_uint64_with_commas(bytes, ec1));
1738 * Scan tape by reading Bacula block by block. Report what is
1739 * on the tape. This function reads Bacula blocks, so if your
1740 * Device resource is correctly defined, it should work with
1741 * either variable or fixed block sizes.
1743 static void scan_blocks()
1745 int blocks, tot_blocks, tot_files;
1746 uint32_t block_size;
1748 DEV_BLOCK *block = dcr->block;
1750 char buf1[100], buf2[100];
1752 blocks = block_size = tot_blocks = 0;
1756 dev->update_pos(dcr);
1757 tot_files = dev->file;
1759 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1760 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1761 if (dev->state & ST_EOT) {
1764 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1767 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1773 if (dev->state & ST_EOF) {
1776 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1779 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1783 printf(_("End of File mark.\n"));
1786 if (dev->state & ST_SHORT) {
1789 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1792 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1796 printf(_("Short block read.\n"));
1799 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1802 if (block->block_len != block_size) {
1805 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1808 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1812 block_size = block->block_len;
1816 bytes += block->block_len;
1817 Dmsg7(100, "Blk_blk=%u file,blk=%u,%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1818 block->BlockNumber, dev->file, dev->block_num, block->block_len, block->BlockVer,
1819 block->VolSessionId, block->VolSessionTime);
1821 DEV_RECORD *rec = new_record();
1822 read_record_from_block(dcr, block, rec);
1823 Pmsg9(-1, _("Block=%u file,blk=%u,%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1824 block->BlockNumber, dev->file, dev->block_num, block->block_len,
1825 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1826 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1829 } else if (verbose > 1) {
1830 dump_block(block, "");
1835 tot_files = dev->file - tot_files;
1836 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1837 edit_uint64_with_commas(bytes, ec1));
1841 static void statcmd()
1843 int debug = debug_level;
1845 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1847 dump_volume_label(dev);
1849 debug_level = debug;
1854 * First we label the tape, then we fill
1855 * it with data get a new tape and write a few blocks.
1857 static void fillcmd()
1860 DEV_BLOCK *block = dcr->block;
1862 char buf1[100], buf2[100];
1866 uint32_t min_block_size;
1878 "This command simulates Bacula writing to a tape.\n"
1879 "It requires either one or two blank tapes, which it\n"
1880 "will label and write.\n\n"
1881 "If you have an autochanger configured, it will use\n"
1882 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1883 "be prompted to insert the tapes when necessary.\n\n"
1884 "It will print a status approximately\n"
1885 "every 322 MB, and write an EOF every %s. If you have\n"
1886 "selected the simple test option, after writing the first tape\n"
1887 "it will rewind it and re-read the last block written.\n\n"
1888 "If you have selected the multiple tape test, when the first tape\n"
1889 "fills, it will ask for a second, and after writing a few more \n"
1890 "blocks, it will stop. Then it will begin re-reading the\n"
1892 "This may take a long time -- hours! ...\n\n"),
1893 edit_uint64_with_suffix(dev->max_file_size, buf1));
1895 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1896 "or the complete multiple tape (m) test: (s/m) "));
1897 if (cmd[0] == 's') {
1898 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1900 } else if (cmd[0] == 'm') {
1901 Pmsg0(-1, _("Multiple tape test selected.\n"));
1904 Pmsg0(000, _("Command aborted.\n"));
1909 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1910 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1912 /* Use fixed block size to simplify read back */
1913 min_block_size = dev->min_block_size;
1914 dev->min_block_size = dev->max_block_size;
1915 write_eof = dev->max_file_size / REC_SIZE; /*compute when we add EOF*/
1916 set_volume_name("TestVolume1", 1);
1917 dir_ask_sysop_to_create_appendable_volume(dcr);
1918 dev->set_append(); /* force volume to be relabeled */
1921 * Acquire output device for writing. Note, after acquiring a
1922 * device, we MUST release it, which is done at the end of this
1925 Dmsg0(100, "just before acquire_device\n");
1926 if (!acquire_device_for_append(dcr)) {
1927 set_jcr_job_status(jcr, JS_ErrorTerminated);
1931 block = jcr->dcr->block;
1933 Dmsg0(100, "Just after acquire_device_for_append\n");
1935 * Write Begin Session Record
1937 if (!write_session_label(dcr, SOS_LABEL)) {
1938 set_jcr_job_status(jcr, JS_ErrorTerminated);
1939 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1943 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1945 memset(&rec, 0, sizeof(rec));
1946 rec.data = get_memory(100000); /* max record size */
1947 rec.data_len = REC_SIZE;
1950 * Put some random data in the record
1952 fd = open("/dev/urandom", O_RDONLY);
1954 read(fd, rec.data, rec.data_len);
1957 uint32_t *p = (uint32_t *)rec.data;
1958 srandom(time(NULL));
1959 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1965 * Generate data as if from File daemon, write to device
1967 jcr->dcr->VolFirstIndex = 0;
1968 time(&jcr->run_time); /* start counting time for rates */
1969 (void)localtime_r(&jcr->run_time, &tm);
1970 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1972 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1974 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1976 for (file_index = 0; ok && !job_canceled(jcr); ) {
1977 rec.VolSessionId = jcr->VolSessionId;
1978 rec.VolSessionTime = jcr->VolSessionTime;
1979 rec.FileIndex = ++file_index;
1980 rec.Stream = STREAM_FILE_DATA;
1982 /* Mix up the data just a bit */
1983 uint32_t *lp = (uint32_t *)rec.data;
1985 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i+=100) {
1989 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1990 rec.FileIndex, rec.VolSessionId,
1991 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1994 while (!write_record_to_block(block, &rec)) {
1996 * When we get here we have just filled a block
1998 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
2001 /* Write block to tape */
2002 if (!flush_block(block, 1)) {
2007 /* Every 5000 blocks (approx 322MB) report where we are.
2009 if ((block->BlockNumber % 5000) == 0) {
2011 now -= jcr->run_time;
2013 now = 1; /* prevent divide error */
2015 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
2016 Pmsg5(-1, _("Wrote block=%u, file,blk=%u,%u VolBytes=%s rate=%.1f KB/s\n"),
2017 block->BlockNumber, dev->file, dev->block_num,
2018 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
2020 /* Every X blocks (dev->max_file_size) write an EOF.
2022 if ((block->BlockNumber % write_eof) == 0) {
2024 (void)localtime_r(&now, &tm);
2025 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2026 Pmsg1(-1, _("%s\n"), buf1);
2028 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
2029 flush_block(block, 0);
2034 /* Get out after writing 10 blocks to the second tape */
2035 if (++BlockNumber > 10 && stop != 0) { /* get out */
2040 Pmsg0(000, _("Not OK\n"));
2044 jcr->JobBytes += rec.data_len; /* increment bytes this job */
2045 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
2046 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
2047 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
2049 /* Get out after writing 10 blocks to the second tape */
2050 if (BlockNumber > 10 && stop != 0) { /* get out */
2052 Pmsg1(-1, "Done writing %s records ...\n",
2053 edit_uint64_with_commas(write_count, ed1));
2058 Dmsg0(100, "Write_end_session_label()\n");
2059 /* Create Job status for end of session label */
2060 if (!job_canceled(jcr) && ok) {
2061 set_jcr_job_status(jcr, JS_Terminated);
2063 set_jcr_job_status(jcr, JS_ErrorTerminated);
2066 if (!write_session_label(dcr, EOS_LABEL)) {
2067 Pmsg1(000, _("Error writing end session label. ERR=%s\n"), dev->bstrerror());
2071 /* Write out final block of this session */
2072 if (!write_block_to_device(dcr)) {
2073 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2077 Pmsg0(-1, _("Wrote End of Session label.\n"));
2079 /* Save last block info for second tape */
2080 last_block_num2 = last_block_num;
2081 last_file2 = last_file;
2083 free_block(last_block2);
2085 last_block2 = dup_block(last_block);
2088 sprintf(buf, "%s/btape.state", working_directory);
2089 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2091 write(fd, &btape_state_level, sizeof(btape_state_level));
2092 write(fd, &simple, sizeof(simple));
2093 write(fd, &last_block_num1, sizeof(last_block_num1));
2094 write(fd, &last_block_num2, sizeof(last_block_num2));
2095 write(fd, &last_file1, sizeof(last_file1));
2096 write(fd, &last_file2, sizeof(last_file2));
2097 write(fd, last_block1->buf, last_block1->buf_len);
2098 write(fd, last_block2->buf, last_block2->buf_len);
2099 write(fd, first_block->buf, first_block->buf_len);
2101 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2102 last_block_num1, last_block_num2);
2105 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2111 (void)localtime_r(&now, &tm);
2112 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2114 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2115 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2118 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2119 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2122 jcr->dcr->block = block;
2127 dev->min_block_size = min_block_size;
2128 free_memory(rec.data);
2132 * Read two tapes written by the "fill" command and ensure
2133 * that the data is valid. If stop==1 we simulate full read back
2134 * of two tapes. If stop==-1 we simply read the last block and
2135 * verify that it is correct.
2137 static void unfillcmd()
2142 last_block1 = new_block(dev);
2143 last_block2 = new_block(dev);
2144 first_block = new_block(dev);
2145 sprintf(buf, "%s/btape.state", working_directory);
2146 fd = open(buf, O_RDONLY);
2148 uint32_t state_level;
2149 read(fd, &state_level, sizeof(btape_state_level));
2150 read(fd, &simple, sizeof(simple));
2151 read(fd, &last_block_num1, sizeof(last_block_num1));
2152 read(fd, &last_block_num2, sizeof(last_block_num2));
2153 read(fd, &last_file1, sizeof(last_file1));
2154 read(fd, &last_file2, sizeof(last_file2));
2155 read(fd, last_block1->buf, last_block1->buf_len);
2156 read(fd, last_block2->buf, last_block2->buf_len);
2157 read(fd, first_block->buf, first_block->buf_len);
2159 if (state_level != btape_state_level) {
2160 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2161 "the fill command.\n"));
2167 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2168 "You must redo the fill command.\n"), buf, be.bstrerror());
2178 static bool do_unfill()
2180 DEV_BLOCK *block = dcr->block;
2188 Dmsg0(20, "Enter do_unfill\n");
2189 dev->set_cap(CAP_ANONVOLS); /* allow reading any volume */
2190 dev->clear_cap(CAP_LABEL); /* don't label anything here */
2194 time(&jcr->run_time); /* start counting time for rates */
2198 free_block(last_block);
2201 last_block_num = last_block_num1;
2202 last_file = last_file1;
2203 last_block = last_block1;
2205 free_restore_volume_list(jcr);
2207 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2208 create_restore_volume_list(jcr);
2209 if (jcr->VolList != NULL) {
2210 jcr->VolList->Slot = 1;
2211 if (jcr->VolList->next != NULL) {
2212 jcr->VolList->next->Slot = 2;
2216 set_volume_name("TestVolume1", 1);
2219 /* Multiple Volume tape */
2220 /* Close device so user can use autochanger if desired */
2221 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2224 autochanger = autoload_device(dcr, 1, NULL);
2225 if (autochanger != 1) {
2227 get_cmd(_("Mount first tape. Press enter when ready: "));
2232 dev->num_writers = 0;
2233 if (!acquire_device_for_read(dcr)) {
2234 Pmsg1(-1, "%s", dev->errmsg);
2238 * We now have the first tape mounted.
2239 * Note, re-reading last block may have caused us to
2240 * loose track of where we are (block number unknown).
2242 Pmsg0(-1, _("Rewinding.\n"));
2243 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2246 /* Read the first 10000 records */
2247 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2248 dev->file, dev->block_num);
2250 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2251 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2252 last_file, last_block_num);
2253 if (!dev->reposition(dcr, last_file, last_block_num)) {
2254 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2257 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2258 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2259 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2262 if (compare_blocks(last_block, block)) {
2264 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2266 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2273 /* restore info for last block on second Volume */
2274 last_block_num = last_block_num2;
2275 last_file = last_file2;
2276 last_block = last_block2;
2278 /* Multiple Volume tape */
2279 /* Close device so user can use autochanger if desired */
2280 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2284 set_volume_name("TestVolume2", 2);
2286 autochanger = autoload_device(dcr, 1, NULL);
2287 if (autochanger != 1) {
2289 get_cmd(_("Mount second tape. Press enter when ready: "));
2293 if (!acquire_device_for_read(dcr)) {
2294 Pmsg1(-1, "%s", dev->errmsg);
2298 /* Space to "first" block which is last block not written
2299 * on the previous tape.
2301 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2302 if (!dev->reposition(dcr, 0, 1)) {
2303 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2306 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2307 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2308 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2311 if (compare_blocks(first_block, block)) {
2312 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2315 /* Now find and compare the last block */
2316 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2317 last_file, last_block_num);
2318 if (!dev->reposition(dcr, last_file, last_block_num)) {
2319 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2322 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2323 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2324 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2327 if (compare_blocks(last_block, block)) {
2328 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2333 free_block(last_block1);
2334 free_block(last_block2);
2335 free_block(first_block);
2339 /* Read 10000 records then stop */
2340 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2342 DEVICE *dev = dcr->dev;
2344 if (quickie_count == 10000) {
2345 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2347 return quickie_count < 10000;
2350 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2353 uint32_t CheckSum, block_len;
2356 p = last_block->buf;
2358 unser_begin(q, BLKHDR2_LENGTH);
2359 unser_uint32(CheckSum);
2360 unser_uint32(block_len);
2361 while (q < (block->buf+block_len)) {
2368 dump_block(last_block, _("Last block written"));
2370 dump_block(block, _("Block read back"));
2371 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2372 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2373 "that was read back differ. The test FAILED !!!!\n"
2374 "This must be corrected before you use Bacula\n"
2375 "to write multi-tape Volumes.!!!!\n"));
2379 dump_block(last_block, _("Last block written"));
2380 dump_block(block, _("Block read back"));
2386 * Write current block to tape regardless of whether or
2387 * not it is full. If the tape fills, attempt to
2388 * acquire another tape.
2390 static int flush_block(DEV_BLOCK *block, int dump)
2394 uint32_t this_file, this_block_num;
2398 this_block = new_block(dev);
2401 last_block = new_block(dev);
2404 this_file = dev->file;
2405 this_block_num = dev->block_num;
2406 if (!write_block_to_dev(dcr)) {
2407 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2408 last_file, last_block_num, this_block_num);
2411 * This is 1st tape, so save first tape info separate
2412 * from second tape info
2414 last_block_num1 = last_block_num;
2415 last_file1 = last_file;
2416 last_block1 = dup_block(last_block);
2417 last_block2 = dup_block(last_block);
2418 first_block = dup_block(block); /* first block second tape */
2421 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2422 (unsigned)file_index, block->BlockNumber, block->block_len);
2423 dump_block(last_block, _("Last block written"));
2425 dump_block(block, _("Block not written"));
2428 eot_block = block->BlockNumber;
2429 eot_block_len = block->block_len;
2430 eot_FileIndex = file_index;
2434 now -= jcr->run_time;
2436 now = 1; /* don't divide by zero */
2438 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2439 vol_size = dev->VolCatInfo.VolCatBytes;
2440 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2441 dev->file, dev->block_num,
2442 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2445 stop = -1; /* stop, but do simplified test */
2447 /* Full test in progress */
2448 if (!fixup_device_block_write_error(jcr->dcr)) {
2449 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2454 BlockNumber = 0; /* start counting for second tape */
2457 return 1; /* end of tape reached */
2460 /* Save contents after write so that the header is serialized */
2461 memcpy(this_block->buf, block->buf, this_block->buf_len);
2464 * Note, we always read/write to block, but we toggle
2465 * copying it to one or another of two allocated blocks.
2466 * Switch blocks so that the block just successfully written is
2467 * always in last_block.
2469 tblock = last_block;
2470 last_block = this_block;
2471 this_block = tblock;
2472 last_file = this_file;
2473 last_block_num = this_block_num;
2481 * First we label the tape, then we fill
2482 * it with data get a new tape and write a few blocks.
2484 static void qfillcmd()
2486 DEV_BLOCK *block = dcr->block;
2487 DEV_RECORD *rec = dcr->rec;
2490 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2492 get_cmd(_("How many blocks do you want to write? (1000): "));
2499 sm_check(__FILE__, __LINE__, false);
2501 i = block->buf_len - 100;
2503 rec->data = check_pool_memory_size(rec->data, i);
2504 memset(rec->data, i & 0xFF, i);
2509 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2510 for (i=0; i < count; i++) {
2515 if (!write_record_to_block(block, rec)) {
2516 Pmsg0(0, _("Error writing record to block.\n"));
2519 if (!write_block_to_dev(dcr)) {
2520 Pmsg0(0, _("Error writing block to device.\n"));
2525 print_speed(dev->VolCatInfo.VolCatBytes);
2527 if (dev->has_cap(CAP_TWOEOF)) {
2534 sm_check(__FILE__, __LINE__, false);
2538 * Fill a tape using raw write() command
2540 static void rawfill_cmd()
2542 DEV_BLOCK *block = dcr->block;
2545 uint32_t block_num = 0;
2550 fd = open("/dev/urandom", O_RDONLY);
2552 read(fd, block->buf, block->buf_len);
2555 uint32_t *p = (uint32_t *)block->buf;
2556 srandom(time(NULL));
2557 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2564 p = (uint32_t *)block->buf;
2565 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2568 stat = dev->d_write(dev->fd(), block->buf, block->buf_len);
2569 if (stat == (int)block->buf_len) {
2570 if ((block_num++ % 100) == 0) {
2575 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i+=100) {
2578 jcr->JobBytes += stat;
2586 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2587 be.bstrerror(my_errno));
2589 print_speed(jcr->JobBytes);
2595 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2596 static struct cmdstruct commands[] = {
2597 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2598 {NT_("bsf"), bsfcmd, _("backspace file")},
2599 {NT_("bsr"), bsrcmd, _("backspace record")},
2600 {NT_("cap"), capcmd, _("list device capabilities")},
2601 {NT_("clear"), clearcmd, _("clear tape errors")},
2602 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2603 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2604 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2605 {NT_("unfill"), unfillcmd, _("read filled tape")},
2606 {NT_("fsf"), fsfcmd, _("forward space a file")},
2607 {NT_("fsr"), fsrcmd, _("forward space a record")},
2608 {NT_("help"), helpcmd, _("print this command")},
2609 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2610 {NT_("load"), loadcmd, _("load a tape")},
2611 {NT_("quit"), quitcmd, _("quit btape")},
2612 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2613 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2614 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2615 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2616 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2617 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2618 {NT_("status"), statcmd, _("print tape status")},
2619 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2620 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2621 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2622 {NT_("rr"), rrcmd, _("read a single record")},
2623 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2624 {NT_("qfill"), qfillcmd, _("quick fill command")}
2626 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2634 while (!quit && get_cmd("*")) {
2635 sm_check(__FILE__, __LINE__, false);
2637 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2638 for (i=0; i<comsize; i++) /* search for command */
2639 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2640 (*commands[i].func)(); /* go execute command */
2644 if (*cmd && !found) {
2645 Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2650 static void helpcmd()
2654 printf(_("Interactive commands:\n"));
2655 printf(_(" Command Description\n ======= ===========\n"));
2656 for (i=0; i<comsize; i++)
2657 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2665 "\nVersion: %s (%s)\n\n"
2666 "Usage: btape <options> <device_name>\n"
2667 " -b <file> specify bootstrap file\n"
2668 " -c <file> set configuration file to file\n"
2669 " -d <nn> set debug level to <nn>\n"
2670 " -dt print timestamp in debug output\n"
2671 " -p proceed inspite of I/O errors\n"
2672 " -s turn off signals\n"
2674 " -? print this message.\n"
2675 "\n"), 2000, VERSION, BDATE);
2680 * Get next input command from terminal. This
2681 * routine is REALLY primitive, and should be enhanced
2682 * to have correct backspacing, etc.
2685 get_cmd(const char *prompt)
2690 fprintf(stdout, "%s", prompt);
2692 /* We really should turn off echoing and pretty this
2696 while ((ch = fgetc(stdin)) != EOF) {
2698 strip_trailing_junk(cmd);
2700 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2714 /* Dummies to replace askdir.c */
2715 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2716 bool dir_send_job_status(JCR *jcr) {return 1;}
2718 bool dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten)
2724 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2726 Dmsg0(20, "Enter dir_get_volume_info\n");
2727 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2731 bool dir_create_jobmedia_record(DCR *dcr, bool zero)
2733 dcr->WroteVol = false;
2738 bool dir_find_next_appendable_volume(DCR *dcr)
2740 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2741 return dcr->VolumeName[0] != 0;
2744 bool dir_ask_sysop_to_mount_volume(DCR *dcr, int /* mode */)
2746 DEVICE *dev = dcr->dev;
2747 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2748 if (dcr->VolumeName[0] == 0) {
2749 return dir_ask_sysop_to_create_appendable_volume(dcr);
2751 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2752 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2753 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2756 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2757 dcr->VolumeName, dev->print_name());
2764 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2767 DEVICE *dev = dcr->dev;
2768 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2770 set_volume_name("TestVolume1", 1);
2772 set_volume_name("TestVolume2", 2);
2774 /* Close device so user can use autochanger if desired */
2775 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2778 autochanger = autoload_device(dcr, 1, NULL);
2779 if (autochanger != 1) {
2780 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2791 static bool my_mount_next_read_volume(DCR *dcr)
2794 JCR *jcr = dcr->jcr;
2795 DEV_BLOCK *block = dcr->block;
2797 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2798 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2801 volume_unused(dcr); /* release current volume */
2802 if (LastBlock != block->BlockNumber) {
2803 VolBytes += block->block_len;
2805 LastBlock = block->BlockNumber;
2807 now -= jcr->run_time;
2811 kbs = (double)VolBytes / (1000.0 * (double)now);
2812 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2813 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2815 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2820 set_volume_name("TestVolume2", 2);
2823 if (!acquire_device_for_read(dcr)) {
2824 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2827 return true; /* next volume mounted */
2830 static void set_volume_name(const char *VolName, int volnum)
2832 DCR *dcr = jcr->dcr;
2833 VolumeName = VolName;
2835 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2836 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2837 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2838 dcr->VolCatInfo.Slot = volnum;
2839 dcr->VolCatInfo.InChanger = true;