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 term_last_jobs_list();
363 close_memory_pool(); /* free memory in pool */
370 static bool open_the_device()
375 block = new_block(dev);
377 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
378 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
379 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
383 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
384 dev->set_append(); /* put volume in append mode */
399 * Write a label to the tape
401 static void labelcmd()
404 pm_strcpy(cmd, VolumeName);
406 if (!get_cmd(_("Enter Volume Name: "))) {
411 if (!dev->is_open()) {
412 if (!first_open_device(dcr)) {
413 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
418 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
419 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
423 * Read the tape label
425 static void readlabelcmd()
427 int save_debug_level = debug_level;
430 stat = read_dev_volume_label(dcr);
433 Pmsg0(0, _("Volume has no label.\n"));
436 Pmsg0(0, _("Volume label read correctly.\n"));
439 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
442 Pmsg0(0, _("Volume name error\n"));
444 case VOL_CREATE_ERROR:
445 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
447 case VOL_VERSION_ERROR:
448 Pmsg0(0, _("Volume version error.\n"));
450 case VOL_LABEL_ERROR:
451 Pmsg0(0, _("Bad Volume label type.\n"));
454 Pmsg0(0, _("Unknown error.\n"));
459 dump_volume_label(dev);
460 debug_level = save_debug_level;
465 * Load the tape should have prevously been taken
466 * off line, otherwise this command is not necessary.
468 static void loadcmd()
471 if (!load_dev(dev)) {
472 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
474 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
480 static void rewindcmd()
482 if (!dev->rewind(dcr)) {
483 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
486 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
491 * Clear any tape error
493 static void clearcmd()
499 * Write and end of file on the tape
501 static void weofcmd()
511 if (!dev->weof(num)) {
512 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
516 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
519 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
525 /* Go to the end of the medium -- raw command
526 * The idea was orginally that the end of the Bacula
527 * medium would be flagged differently. This is not
528 * currently the case. So, this is identical to the
533 if (!dev->eod(dcr)) {
534 Pmsg1(0, "%s", dev->bstrerror());
537 Pmsg0(0, _("Moved to end of medium.\n"));
542 * Go to the end of the medium (either hardware determined
543 * or defined by two eofs.
563 if (!dev->bsf(num)) {
564 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
566 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
582 if (!dev->bsr(num)) {
583 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
585 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
590 * List device capabilities as defined in the
595 printf(_("Configured device capabilities:\n"));
596 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
597 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
598 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
599 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
600 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
601 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
602 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
603 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
604 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
605 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
606 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
607 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
608 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
609 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
610 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
613 printf(_("Device status:\n"));
614 printf("%sOPENED ", dev->is_open() ? "" : "!");
615 printf("%sTAPE ", dev->is_tape() ? "" : "!");
616 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
617 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
618 printf("%sAPPEND ", dev->can_append() ? "" : "!");
619 printf("%sREAD ", dev->can_read() ? "" : "!");
620 printf("%sEOT ", dev->at_eot() ? "" : "!");
621 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
622 printf("%sEOF ", dev->at_eof() ? "" : "!");
623 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
624 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
627 printf(_("Device parameters:\n"));
628 printf("Device name: %s\n", dev->dev_name);
629 printf("File=%u block=%u\n", dev->file, dev->block_num);
630 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
632 printf(_("Status:\n"));
638 * Test writting larger and larger records.
639 * This is a torture test for records.
641 static void rectestcmd()
647 Pmsg0(0, _("Test writting larger and larger records.\n"
648 "This is a torture test for records.\nI am going to write\n"
649 "larger and larger records. It will stop when the record size\n"
650 "plus the header exceeds the block size (by default about 64K)\n"));
653 get_cmd(_("Do you want to continue? (y/n): "));
655 Pmsg0(000, _("Command aborted.\n"));
659 sm_check(__FILE__, __LINE__, false);
660 block = new_block(dev);
663 for (i=1; i<500000; i++) {
664 rec->data = check_pool_memory_size(rec->data, i);
665 memset(rec->data, i & 0xFF, i);
667 sm_check(__FILE__, __LINE__, false);
668 if (write_record_to_block(block, rec)) {
671 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
675 sm_check(__FILE__, __LINE__, false);
679 sm_check(__FILE__, __LINE__, false);
683 * This test attempts to re-read a block written by Bacula
684 * normally at the end of the tape. Bacula will then back up
685 * over the two eof marks, backup over the record and reread
686 * it to make sure it is valid. Bacula can skip this validation
687 * if you set "Backward space record = no"
689 static int re_read_block_test()
691 DEV_BLOCK *block = dcr->block;
696 if (!(dev->capabilities & CAP_BSR)) {
697 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
701 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
702 "I'm going to write three records and an EOF\n"
703 "then backup over the EOF and re-read the last record.\n"
704 "Bacula does this after writing the last block on the\n"
705 "tape to verify that the block was written correctly.\n\n"
706 "This is not an *essential* feature ...\n\n"));
710 rec->data = check_pool_memory_size(rec->data, block->buf_len);
711 len = rec->data_len = block->buf_len-100;
712 memset(rec->data, 1, rec->data_len);
713 if (!write_record_to_block(block, rec)) {
714 Pmsg0(0, _("Error writing record to block.\n"));
717 if (!write_block_to_dev(dcr)) {
718 Pmsg0(0, _("Error writing block to device.\n"));
721 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
723 memset(rec->data, 2, rec->data_len);
724 if (!write_record_to_block(block, rec)) {
725 Pmsg0(0, _("Error writing record to block.\n"));
728 if (!write_block_to_dev(dcr)) {
729 Pmsg0(0, _("Error writing block to device.\n"));
732 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
734 memset(rec->data, 3, rec->data_len);
735 if (!write_record_to_block(block, rec)) {
736 Pmsg0(0, _("Error writing record to block.\n"));
739 if (!write_block_to_dev(dcr)) {
740 Pmsg0(0, _("Error writing block to device.\n"));
743 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
746 if (dev->has_cap(CAP_TWOEOF)) {
750 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
753 if (dev->has_cap(CAP_TWOEOF)) {
755 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
759 Pmsg0(0, _("Backspaced over EOF OK.\n"));
761 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
764 Pmsg0(0, _("Backspace record OK.\n"));
765 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
767 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
770 memset(rec->data, 0, rec->data_len);
771 if (!read_record_from_block(dcr, block, rec)) {
773 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
776 for (int i=0; i<len; i++) {
777 if (rec->data[i] != 3) {
778 Pmsg0(0, _("Bad data in record. Test failed!\n"));
782 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
783 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
790 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
791 "this function to verify the last block written to the\n"
792 "tape. Bacula will skip the last block verification\n"
794 "Backward Space Record = No\n\n"
795 "to your Storage daemon's Device resource definition.\n"));
802 * This test writes Bacula blocks to the tape in
803 * several files. It then rewinds the tape and attepts
804 * to read these blocks back checking the data.
806 static int write_read_test()
814 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
815 "I'm going to write 1000 records and an EOF\n"
816 "then write 1000 records and an EOF, then rewind,\n"
817 "and re-read the data to verify that it is correct.\n\n"
818 "This is an *essential* feature ...\n\n"));
821 if (!dev->rewind(dcr)) {
822 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
825 rec->data = check_pool_memory_size(rec->data, block->buf_len);
826 rec->data_len = block->buf_len-100;
827 len = rec->data_len/sizeof(i);
828 for (i=1; i<=1000; i++) {
829 p = (int *)rec->data;
830 for (j=0; j<len; j++) {
833 if (!write_record_to_block(block, rec)) {
834 Pmsg0(0, _("Error writing record to block.\n"));
837 if (!write_block_to_dev(dcr)) {
838 Pmsg0(0, _("Error writing block to device.\n"));
842 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
844 for (i=1001; i<=2000; i++) {
845 p = (int *)rec->data;
846 for (j=0; j<len; j++) {
849 if (!write_record_to_block(block, rec)) {
850 Pmsg0(0, _("Error writing record to block.\n"));
853 if (!write_block_to_dev(dcr)) {
854 Pmsg0(0, _("Error writing block to device.\n"));
858 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
860 if (dev->has_cap(CAP_TWOEOF)) {
863 if (!dev->rewind(dcr)) {
864 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
867 Pmsg0(0, _("Rewind OK.\n"));
869 for (i=1; i<=2000; i++) {
871 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
873 if (dev_state(dev, ST_EOF)) {
874 Pmsg0(-1, _("Got EOF on tape.\n"));
879 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
882 memset(rec->data, 0, rec->data_len);
883 if (!read_record_from_block(dcr, block, rec)) {
885 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
888 p = (int *)rec->data;
889 for (j=0; j<len; j++) {
891 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
897 if (i == 1000 || i == 2000) {
898 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
901 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
910 * This test writes Bacula blocks to the tape in
911 * several files. It then rewinds the tape and attepts
912 * to read these blocks back checking the data.
914 static int position_test()
916 DEV_BLOCK *block = dcr->block;
922 int file = 0, blk = 0;
924 bool got_eof = false;
926 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
927 "I'm going to write 1000 records and an EOF\n"
928 "then write 1000 records and an EOF, then rewind,\n"
929 "and position to a few blocks and verify that it is correct.\n\n"
930 "This is an *essential* feature ...\n\n"));
933 if (!dev->rewind(dcr)) {
934 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
937 rec->data = check_pool_memory_size(rec->data, block->buf_len);
938 rec->data_len = block->buf_len-100;
939 len = rec->data_len/sizeof(i);
940 for (i=1; i<=1000; i++) {
941 p = (int *)rec->data;
942 for (j=0; j<len; j++) {
945 if (!write_record_to_block(block, rec)) {
946 Pmsg0(0, _("Error writing record to block.\n"));
949 if (!write_block_to_dev(dcr)) {
950 Pmsg0(0, _("Error writing block to device.\n"));
954 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
956 for (i=1001; i<=2000; i++) {
957 p = (int *)rec->data;
958 for (j=0; j<len; j++) {
961 if (!write_record_to_block(block, rec)) {
962 Pmsg0(0, _("Error writing record to block.\n"));
965 if (!write_block_to_dev(dcr)) {
966 Pmsg0(0, _("Error writing block to device.\n"));
970 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
972 if (dev->has_cap(CAP_TWOEOF)) {
975 if (!dev->rewind(dcr)) {
976 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
979 Pmsg0(0, _("Rewind OK.\n"));
983 /* Set up next item to read based on where we are */
1019 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1020 if (!dev->reposition(dcr, file, blk)) {
1021 Pmsg0(0, _("Reposition error.\n"));
1025 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1027 if (dev_state(dev, ST_EOF)) {
1028 Pmsg0(-1, _("Got EOF on tape.\n"));
1034 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1035 recno, file, blk, be.bstrerror(dev->dev_errno));
1036 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1037 " set to variable blocking as normally used by Bacula.\n"
1038 " Please see the Tape Testing chapter in the manual and \n"
1039 " look for using mt with defblksize and setoptions\n"
1040 "If your tape drive block size is correct, then perhaps\n"
1041 " your SCSI driver is *really* stupid and does not\n"
1042 " correctly report the file:block after a FSF. In this\n"
1043 " case try setting:\n"
1044 " Fast Forward Space File = no\n"
1045 " in your Device resource.\n"));
1049 memset(rec->data, 0, rec->data_len);
1050 if (!read_record_from_block(dcr, block, rec)) {
1052 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1055 p = (int *)rec->data;
1056 for (j=0; j<len; j++) {
1057 if (p[j] != recno) {
1058 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1063 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1065 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1077 * This test writes some records, then writes an end of file,
1078 * rewinds the tape, moves to the end of the data and attepts
1079 * to append to the tape. This function is essential for
1080 * Bacula to be able to write multiple jobs to the tape.
1082 static int append_test()
1084 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1085 "This test is essential to Bacula.\n\n"
1086 "I'm going to write one record in file 0,\n"
1087 " two records in file 1,\n"
1088 " and three records in file 2\n\n"));
1092 weofcmd(); /* end file 0 */
1095 weofcmd(); /* end file 1 */
1099 weofcmd(); /* end file 2 */
1100 if (dev->has_cap(CAP_TWOEOF)) {
1103 dev->close(); /* release device */
1104 if (!open_the_device()) {
1108 Pmsg0(0, _("Now moving to end of medium.\n"));
1110 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1111 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1113 if (dev->file != 3) {
1117 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1120 if (dev->has_cap(CAP_TWOEOF)) {
1124 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1125 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1127 Pmsg0(-1, _("End scanning the tape.\n"));
1128 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1129 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1131 if (dev->file != 4) {
1139 * This test exercises the autochanger
1141 static int autochanger_test()
1143 POOLMEM *results, *changer;
1144 int slot, status, loaded;
1145 int timeout = dcr->device->max_changer_wait;
1148 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1149 if (!dev->has_cap(CAP_AUTOCHANGER)) {
1152 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1153 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1157 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1158 "To test the autochanger you must have a blank tape\n"
1159 " that I can write on in Slot 1.\n"));
1160 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1163 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1167 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1169 results = get_pool_memory(PM_MESSAGE);
1170 changer = get_pool_memory(PM_FNAME);
1174 dcr->VolCatInfo.Slot = slot;
1175 /* Find out what is loaded, zero means device is unloaded */
1176 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1177 changer = edit_device_codes(dcr, changer,
1178 dcr->device->changer_command, "loaded");
1179 status = run_program(changer, timeout, results);
1180 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1182 loaded = atoi(results);
1185 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1186 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1190 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1192 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1194 Dmsg1(100, "Results from loaded query=%s\n", results);
1196 dcr->VolCatInfo.Slot = loaded;
1197 /* We are going to load a new tape, so close the device */
1199 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1200 loaded, dev->drive_index);
1201 changer = edit_device_codes(dcr, changer,
1202 dcr->device->changer_command, "unload");
1203 status = run_program(changer, timeout, results);
1204 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1207 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1208 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1217 dcr->VolCatInfo.Slot = slot;
1218 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1219 slot, dev->drive_index);
1220 changer = edit_device_codes(dcr, changer,
1221 dcr->device->changer_command, "load");
1222 Dmsg1(100, "Changer=%s\n", changer);
1224 status = run_program(changer, timeout, results);
1226 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1227 slot, dev->drive_index);
1230 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1231 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1235 if (!open_the_device()) {
1239 * Start with sleep_time 0 then increment by 30 seconds if we get
1242 bmicrosleep(sleep_time, 0);
1243 if (!dev->rewind(dcr) || !dev->weof(1)) {
1244 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1246 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1247 "a longer sleep time in the mtx-script in the load) case.\n"
1248 "Adding a 30 second sleep and trying again ...\n"));
1252 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1255 if (!dev->weof(1)) {
1256 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1259 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1263 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1265 "to your mtx-changer script in the load) case.\n\n"),
1268 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1271 free_pool_memory(changer);
1272 free_pool_memory(results);
1277 free_pool_memory(changer);
1278 free_pool_memory(results);
1279 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1283 static void autochangercmd()
1290 * This test assumes that the append test has been done,
1291 * then it tests the fsf function.
1293 static int fsf_test()
1295 bool set_off = false;
1297 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1298 "This test is essential to Bacula.\n\n"
1299 "I'm going to write five files then test forward spacing\n\n"));
1303 weofcmd(); /* end file 0 */
1306 weofcmd(); /* end file 1 */
1310 weofcmd(); /* end file 2 */
1313 weofcmd(); /* end file 3 */
1315 weofcmd(); /* end file 4 */
1316 if (dev->has_cap(CAP_TWOEOF)) {
1322 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1324 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1327 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1328 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1330 if (dev->file != 1) {
1334 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1336 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1339 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1340 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1342 if (dev->file != 3) {
1347 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1349 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1352 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1353 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1355 if (dev->file != 4) {
1359 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1360 " Fast Forward Space File = no\n\n"
1361 "to your Device resource for this drive.\n"));
1365 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1367 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1369 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1370 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1371 if (dev->file != 5) {
1374 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1378 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1379 if (dev->has_cap(CAP_FASTFSF)) {
1380 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1381 "I am turning it off then retrying the test.\n"));
1382 dev->clear_cap(CAP_FASTFSF);
1386 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1387 "Some systems, e.g. OpenBSD, require you to set\n"
1388 " Use MTIOCGET= no\n"
1389 "in your device resource. Use with caution.\n"));
1398 * This is a general test of Bacula's functions
1399 * needed to read and write the tape.
1401 static void testcmd()
1405 if (!write_read_test()) {
1408 if (!position_test()) {
1412 stat = append_test();
1413 if (stat == 1) { /* OK get out */
1416 if (stat == -1) { /* first test failed */
1417 if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1418 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1419 "Setting \"Hardware End of Medium = no\n"
1420 " and \"Fast Forward Space File = no\n"
1421 "and retrying append test.\n\n"));
1422 dev->clear_cap(CAP_EOM); /* turn off eom */
1423 dev->clear_cap(CAP_FASTFSF); /* turn off fast fsf */
1424 stat = append_test();
1426 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1427 " Hardware End of Medium = No\n\n"
1428 " Fast Forward Space File = No\n"
1429 "to your Device resource in the Storage conf file.\n"));
1433 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1436 /* Wrong count after append */
1438 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1439 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1440 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1441 stat = append_test();
1443 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1444 " Hardware End of Medium = No\n"
1445 " Fast Forward Space File = No\n"
1446 " BSF at EOM = yes\n\n"
1447 "to your Device resource in the Storage conf file.\n"));
1454 Pmsg0(-1, _("\nAppend test failed.\n\n"
1455 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1456 "Unable to correct the problem. You MUST fix this\n"
1457 "problem before Bacula can use your tape drive correctly\n"
1458 "\nPerhaps running Bacula in fixed block mode will work.\n"
1459 "Do so by setting:\n\n"
1460 "Minimum Block Size = nnn\n"
1461 "Maximum Block Size = nnn\n\n"
1462 "in your Storage daemon's Device definition.\n"
1463 "nnn must match your tape driver's block size, which\n"
1464 "can be determined by reading your tape manufacturers\n"
1465 "information, and the information on your kernel dirver.\n"
1466 "Fixed block sizes, however, are not normally an ideal solution.\n"
1468 "Some systems, e.g. OpenBSD, require you to set\n"
1469 " Use MTIOCGET= no\n"
1470 "in your device resource. Use with caution.\n"));
1475 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1476 "Please double check it ...\n"
1477 "=== Sample correct output ===\n"
1478 "1 block of 64448 bytes in file 1\n"
1479 "End of File mark.\n"
1480 "2 blocks of 64448 bytes in file 2\n"
1481 "End of File mark.\n"
1482 "3 blocks of 64448 bytes in file 3\n"
1483 "End of File mark.\n"
1484 "1 block of 64448 bytes in file 4\n"
1485 "End of File mark.\n"
1486 "Total files=4, blocks=7, bytes = 451,136\n"
1487 "=== End sample correct output ===\n\n"
1488 "If the above scan output is not identical to the\n"
1489 "sample output, you MUST correct the problem\n"
1490 "or Bacula will not be able to write multiple Jobs to \n"
1494 re_read_block_test();
1497 fsf_test(); /* do fast forward space file test */
1499 autochanger_test(); /* do autochanger test */
1503 /* Forward space a file */
1504 static void fsfcmd()
1508 num = atoi(argk[1]);
1513 if (!dev->fsf(num)) {
1514 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1518 Pmsg0(0, _("Forward spaced 1 file.\n"));
1521 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1525 /* Forward space a record */
1526 static void fsrcmd()
1530 num = atoi(argk[1]);
1535 if (!dev->fsr(num)) {
1536 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1540 Pmsg0(0, _("Forward spaced 1 record.\n"));
1543 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1548 * Read a Bacula block from the tape
1552 dev->open(dcr, OPEN_READ_ONLY);
1553 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1557 * Write a Bacula block to the tape
1561 DEV_BLOCK *block = dcr->block;
1562 DEV_RECORD *rec = dcr->rec;
1565 if (!dev->is_open()) {
1568 sm_check(__FILE__, __LINE__, false);
1571 dump_block(block, "test");
1574 i = block->buf_len - 100;
1576 rec->data = check_pool_memory_size(rec->data, i);
1577 memset(rec->data, i & 0xFF, i);
1579 sm_check(__FILE__, __LINE__, false);
1580 if (!write_record_to_block(block, rec)) {
1581 Pmsg0(0, _("Error writing record to block.\n"));
1584 if (!write_block_to_dev(dcr)) {
1585 Pmsg0(0, _("Error writing block to device.\n"));
1588 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1590 Pmsg0(0, _("Wrote block to device.\n"));
1593 sm_check(__FILE__, __LINE__, false);
1594 sm_check(__FILE__, __LINE__, false);
1598 * Read a record from the tape
1605 if (!get_cmd(_("Enter length to read: "))) {
1609 if (len < 0 || len > 1000000) {
1610 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1613 buf = (char *)malloc(len);
1614 stat = read(dev->fd(), buf, len);
1615 if (stat > 0 && stat <= len) {
1619 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1620 len, stat, be.bstrerror());
1626 * Scan tape by reading block by block. Report what is
1627 * on the tape. Note, this command does raw reads, and as such
1628 * will not work with fixed block size devices.
1630 static void scancmd()
1633 int blocks, tot_blocks, tot_files;
1639 blocks = block_size = tot_blocks = 0;
1641 if (dev->state & ST_EOT) {
1642 Pmsg0(0, _("End of tape\n"));
1645 dev->update_pos(dcr);
1646 tot_files = dev->file;
1647 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1649 if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1652 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1653 dev->dev_name, be.bstrerror());
1654 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1657 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1660 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1665 Dmsg1(200, "read status = %d\n", stat);
1667 if (stat != block_size) {
1668 dev->update_pos(dcr);
1671 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1674 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1680 if (stat == 0) { /* EOF */
1681 dev->update_pos(dcr);
1682 printf(_("End of File mark.\n"));
1683 /* Two reads of zero means end of tape */
1684 if (dev->state & ST_EOF)
1685 dev->state |= ST_EOT;
1687 dev->state |= ST_EOF;
1690 if (dev->state & ST_EOT) {
1691 printf(_("End of tape\n"));
1694 } else { /* Got data */
1695 dev->state &= ~ST_EOF;
1701 dev->update_pos(dcr);
1702 tot_files = dev->file - tot_files;
1703 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1704 edit_uint64_with_commas(bytes, ec1));
1709 * Scan tape by reading Bacula block by block. Report what is
1710 * on the tape. This function reads Bacula blocks, so if your
1711 * Device resource is correctly defined, it should work with
1712 * either variable or fixed block sizes.
1714 static void scan_blocks()
1716 int blocks, tot_blocks, tot_files;
1717 uint32_t block_size;
1719 DEV_BLOCK *block = dcr->block;
1721 char buf1[100], buf2[100];
1723 blocks = block_size = tot_blocks = 0;
1727 dev->update_pos(dcr);
1728 tot_files = dev->file;
1730 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1731 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1732 if (dev->state & ST_EOT) {
1735 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1738 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1744 if (dev->state & ST_EOF) {
1747 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1750 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1754 printf(_("End of File mark.\n"));
1757 if (dev->state & ST_SHORT) {
1760 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1763 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1767 printf(_("Short block read.\n"));
1770 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1773 if (block->block_len != block_size) {
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 block_size = block->block_len;
1787 bytes += block->block_len;
1788 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1789 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1790 block->VolSessionId, block->VolSessionTime);
1792 DEV_RECORD *rec = new_record();
1793 read_record_from_block(dcr, block, rec);
1794 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1795 block->BlockNumber, dev->block_num, block->block_len,
1796 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1797 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1800 } else if (verbose > 1) {
1801 dump_block(block, "");
1806 tot_files = dev->file - tot_files;
1807 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1808 edit_uint64_with_commas(bytes, ec1));
1812 static void statcmd()
1814 int debug = debug_level;
1816 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1818 dump_volume_label(dev);
1820 debug_level = debug;
1825 * First we label the tape, then we fill
1826 * it with data get a new tape and write a few blocks.
1828 static void fillcmd()
1831 DEV_BLOCK *block = dcr->block;
1833 char buf1[100], buf2[100];
1836 uint32_t min_block_size;
1847 "This command simulates Bacula writing to a tape.\n"
1848 "It requires either one or two blank tapes, which it\n"
1849 "will label and write.\n\n"
1850 "If you have an autochanger configured, it will use\n"
1851 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1852 "be prompted to insert the tapes when necessary.\n\n"
1853 "It will print a status approximately\n"
1854 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1855 "selected the simple test option, after writing the first tape\n"
1856 "it will rewind it and re-read the last block written.\n\n"
1857 "If you have selected the multiple tape test, when the first tape\n"
1858 "fills, it will ask for a second, and after writing a few more \n"
1859 "blocks, it will stop. Then it will begin re-reading the\n"
1861 "This may take a long time -- hours! ...\n\n"));
1863 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1864 "or the complete multiple tape (m) test: (s/m) "));
1865 if (cmd[0] == 's') {
1866 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1868 } else if (cmd[0] == 'm') {
1869 Pmsg0(-1, _("Multiple tape test selected.\n"));
1872 Pmsg0(000, _("Command aborted.\n"));
1876 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1877 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1879 /* Use fixed block size to simplify read back */
1880 min_block_size = dev->min_block_size;
1881 dev->min_block_size = dev->max_block_size;
1882 set_volume_name("TestVolume1", 1);
1883 dir_ask_sysop_to_create_appendable_volume(dcr);
1884 dev->set_append(); /* force volume to be relabeled */
1887 * Acquire output device for writing. Note, after acquiring a
1888 * device, we MUST release it, which is done at the end of this
1891 Dmsg0(100, "just before acquire_device\n");
1892 if (!acquire_device_for_append(dcr)) {
1893 set_jcr_job_status(jcr, JS_ErrorTerminated);
1896 block = jcr->dcr->block;
1898 Dmsg0(100, "Just after acquire_device_for_append\n");
1900 * Write Begin Session Record
1902 if (!write_session_label(dcr, SOS_LABEL)) {
1903 set_jcr_job_status(jcr, JS_ErrorTerminated);
1904 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1908 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1910 memset(&rec, 0, sizeof(rec));
1911 rec.data = get_memory(100000); /* max record size */
1913 #define REC_SIZE 32768
1914 rec.data_len = REC_SIZE;
1917 * Put some random data in the record
1919 fd = open("/dev/urandom", O_RDONLY);
1921 read(fd, rec.data, rec.data_len);
1924 uint32_t *p = (uint32_t *)rec.data;
1925 srandom(time(NULL));
1926 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1932 * Generate data as if from File daemon, write to device
1934 jcr->dcr->VolFirstIndex = 0;
1935 time(&jcr->run_time); /* start counting time for rates */
1936 (void)localtime_r(&jcr->run_time, &tm);
1937 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1939 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1941 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1943 for (file_index = 0; ok && !job_canceled(jcr); ) {
1944 rec.VolSessionId = jcr->VolSessionId;
1945 rec.VolSessionTime = jcr->VolSessionTime;
1946 rec.FileIndex = ++file_index;
1947 rec.Stream = STREAM_FILE_DATA;
1949 /* Mix up the data just a bit */
1950 uint32_t *lp = (uint32_t *)rec.data;
1952 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1956 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1957 rec.FileIndex, rec.VolSessionId,
1958 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1961 while (!write_record_to_block(block, &rec)) {
1963 * When we get here we have just filled a block
1965 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1968 /* Write block to tape */
1969 if (!flush_block(block, 1)) {
1973 /* Every 5000 blocks (approx 322MB) report where we are.
1975 if ((block->BlockNumber % 5000) == 0) {
1977 now -= jcr->run_time;
1979 now = 1; /* prevent divide error */
1981 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1982 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1983 block->BlockNumber, dev->block_num,
1984 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1986 /* Every 32000 blocks (approx 2GB) write an EOF.
1988 if ((block->BlockNumber % 32000) == 0) {
1990 (void)localtime_r(&now, &tm);
1991 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1992 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1993 flush_block(block, 0);
1997 /* Get out after writing 10 blocks to the second tape */
1998 if (++BlockNumber > 10 && stop != 0) { /* get out */
2003 Pmsg0(000, _("Not OK\n"));
2006 jcr->JobBytes += rec.data_len; /* increment bytes this job */
2007 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
2008 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
2009 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
2011 /* Get out after writing 10 blocks to the second tape */
2012 if (BlockNumber > 10 && stop != 0) { /* get out */
2014 Pmsg1(-1, "Done writing %s records ...\n",
2015 edit_uint64_with_commas(write_count, ed1));
2020 Dmsg0(100, "Write_end_session_label()\n");
2021 /* Create Job status for end of session label */
2022 if (!job_canceled(jcr) && ok) {
2023 set_jcr_job_status(jcr, JS_Terminated);
2025 set_jcr_job_status(jcr, JS_ErrorTerminated);
2027 if (!write_session_label(dcr, EOS_LABEL)) {
2028 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2031 /* Write out final block of this session */
2032 if (!write_block_to_device(dcr)) {
2033 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2036 Pmsg0(-1, _("Wrote End of Session label.\n"));
2038 /* Save last block info for second tape */
2039 last_block_num2 = last_block_num;
2040 last_file2 = last_file;
2042 free_block(last_block2);
2044 last_block2 = dup_block(last_block);
2047 sprintf(buf, "%s/btape.state", working_directory);
2048 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2050 write(fd, &btape_state_level, sizeof(btape_state_level));
2051 write(fd, &simple, sizeof(simple));
2052 write(fd, &last_block_num1, sizeof(last_block_num1));
2053 write(fd, &last_block_num2, sizeof(last_block_num2));
2054 write(fd, &last_file1, sizeof(last_file1));
2055 write(fd, &last_file2, sizeof(last_file2));
2056 write(fd, last_block1->buf, last_block1->buf_len);
2057 write(fd, last_block2->buf, last_block2->buf_len);
2058 write(fd, first_block->buf, first_block->buf_len);
2060 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2061 last_block_num1, last_block_num2);
2064 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2069 (void)localtime_r(&now, &tm);
2070 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2072 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2073 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2076 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2077 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2080 jcr->dcr->block = block;
2083 dev->min_block_size = min_block_size;
2084 free_memory(rec.data);
2088 * Read two tapes written by the "fill" command and ensure
2089 * that the data is valid. If stop==1 we simulate full read back
2090 * of two tapes. If stop==-1 we simply read the last block and
2091 * verify that it is correct.
2093 static void unfillcmd()
2097 last_block1 = new_block(dev);
2098 last_block2 = new_block(dev);
2099 first_block = new_block(dev);
2100 sprintf(buf, "%s/btape.state", working_directory);
2101 fd = open(buf, O_RDONLY);
2103 uint32_t state_level;
2104 read(fd, &state_level, sizeof(btape_state_level));
2105 read(fd, &simple, sizeof(simple));
2106 read(fd, &last_block_num1, sizeof(last_block_num1));
2107 read(fd, &last_block_num2, sizeof(last_block_num2));
2108 read(fd, &last_file1, sizeof(last_file1));
2109 read(fd, &last_file2, sizeof(last_file2));
2110 read(fd, last_block1->buf, last_block1->buf_len);
2111 read(fd, last_block2->buf, last_block2->buf_len);
2112 read(fd, first_block->buf, first_block->buf_len);
2114 if (state_level != btape_state_level) {
2115 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2116 "the fill command.\n"));
2121 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2122 "You must redo the fill command.\n"), buf, be.bstrerror());
2129 static void do_unfill()
2131 DEV_BLOCK *block = dcr->block;
2138 Dmsg0(20, "Enter do_unfill\n");
2139 dev->set_cap(CAP_ANONVOLS); /* allow reading any volume */
2140 dev->clear_cap(CAP_LABEL); /* don't label anything here */
2144 time(&jcr->run_time); /* start counting time for rates */
2148 free_block(last_block);
2151 last_block_num = last_block_num1;
2152 last_file = last_file1;
2153 last_block = last_block1;
2155 free_restore_volume_list(jcr);
2157 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2158 create_restore_volume_list(jcr);
2159 if (jcr->VolList != NULL) {
2160 jcr->VolList->Slot = 1;
2161 if (jcr->VolList->next != NULL) {
2162 jcr->VolList->next->Slot = 2;
2166 set_volume_name("TestVolume1", 1);
2169 /* Multiple Volume tape */
2170 /* Close device so user can use autochanger if desired */
2171 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2174 autochanger = autoload_device(dcr, 1, NULL);
2175 if (autochanger != 1) {
2177 get_cmd(_("Mount first tape. Press enter when ready: "));
2182 dev->num_writers = 0;
2183 if (!acquire_device_for_read(dcr)) {
2184 Pmsg1(-1, "%s", dev->errmsg);
2188 * We now have the first tape mounted.
2189 * Note, re-reading last block may have caused us to
2190 * loose track of where we are (block number unknown).
2192 Pmsg0(-1, _("Rewinding.\n"));
2193 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2196 /* Read the first 10000 records */
2197 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2198 dev->file, dev->block_num);
2200 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2201 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2202 last_file, last_block_num);
2203 if (!dev->reposition(dcr, last_file, last_block_num)) {
2204 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2207 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2208 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2209 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2212 if (compare_blocks(last_block, block)) {
2214 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2216 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2223 /* restore info for last block on second Volume */
2224 last_block_num = last_block_num2;
2225 last_file = last_file2;
2226 last_block = last_block2;
2228 /* Multiple Volume tape */
2229 /* Close device so user can use autochanger if desired */
2230 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2234 set_volume_name("TestVolume2", 2);
2236 autochanger = autoload_device(dcr, 1, NULL);
2237 if (autochanger != 1) {
2239 get_cmd(_("Mount second tape. Press enter when ready: "));
2243 if (!acquire_device_for_read(dcr)) {
2244 Pmsg1(-1, "%s", dev->errmsg);
2248 /* Space to "first" block which is last block not written
2249 * on the previous tape.
2251 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2252 if (!dev->reposition(dcr, 0, 1)) {
2253 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2256 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2257 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2258 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2261 if (compare_blocks(first_block, block)) {
2262 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2265 /* Now find and compare the last block */
2266 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2267 last_file, last_block_num);
2268 if (!dev->reposition(dcr, last_file, last_block_num)) {
2269 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2272 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2273 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2274 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2277 if (compare_blocks(last_block, block)) {
2278 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2282 free_block(last_block1);
2283 free_block(last_block2);
2284 free_block(first_block);
2287 /* Read 10000 records then stop */
2288 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2290 DEVICE *dev = dcr->dev;
2292 if (quickie_count == 10000) {
2293 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2295 return quickie_count < 10000;
2298 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2301 uint32_t CheckSum, block_len;
2304 p = last_block->buf;
2306 unser_begin(q, BLKHDR2_LENGTH);
2307 unser_uint32(CheckSum);
2308 unser_uint32(block_len);
2309 while (q < (block->buf+block_len)) {
2316 dump_block(last_block, _("Last block written"));
2318 dump_block(block, _("Block read back"));
2319 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2320 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2321 "that was read back differ. The test FAILED !!!!\n"
2322 "This must be corrected before you use Bacula\n"
2323 "to write multi-tape Volumes.!!!!\n"));
2327 dump_block(last_block, _("Last block written"));
2328 dump_block(block, _("Block read back"));
2338 * Write current block to tape regardless of whether or
2339 * not it is full. If the tape fills, attempt to
2340 * acquire another tape.
2342 static int flush_block(DEV_BLOCK *block, int dump)
2346 uint32_t this_file, this_block_num;
2350 this_block = new_block(dev);
2353 last_block = new_block(dev);
2356 this_file = dev->file;
2357 this_block_num = dev->block_num;
2358 if (!write_block_to_dev(dcr)) {
2359 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2360 last_file, last_block_num, this_block_num);
2363 * This is 1st tape, so save first tape info separate
2364 * from second tape info
2366 last_block_num1 = last_block_num;
2367 last_file1 = last_file;
2368 last_block1 = dup_block(last_block);
2369 last_block2 = dup_block(last_block);
2370 first_block = dup_block(block); /* first block second tape */
2373 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2374 (unsigned)file_index, block->BlockNumber, block->block_len);
2375 dump_block(last_block, _("Last block written"));
2377 dump_block(block, _("Block not written"));
2380 eot_block = block->BlockNumber;
2381 eot_block_len = block->block_len;
2382 eot_FileIndex = file_index;
2386 now -= jcr->run_time;
2388 now = 1; /* don't divide by zero */
2390 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2391 vol_size = dev->VolCatInfo.VolCatBytes;
2392 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2393 dev->file, dev->block_num,
2394 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2397 stop = -1; /* stop, but do simplified test */
2399 /* Full test in progress */
2400 if (!fixup_device_block_write_error(jcr->dcr)) {
2401 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2406 BlockNumber = 0; /* start counting for second tape */
2409 return 1; /* end of tape reached */
2412 /* Save contents after write so that the header is serialized */
2413 memcpy(this_block->buf, block->buf, this_block->buf_len);
2416 * Note, we always read/write to block, but we toggle
2417 * copying it to one or another of two allocated blocks.
2418 * Switch blocks so that the block just successfully written is
2419 * always in last_block.
2421 tblock = last_block;
2422 last_block = this_block;
2423 this_block = tblock;
2424 last_file = this_file;
2425 last_block_num = this_block_num;
2433 * First we label the tape, then we fill
2434 * it with data get a new tape and write a few blocks.
2436 static void qfillcmd()
2438 DEV_BLOCK *block = dcr->block;
2439 DEV_RECORD *rec = dcr->rec;
2442 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2444 get_cmd(_("How many blocks do you want to write? (1000): "));
2451 sm_check(__FILE__, __LINE__, false);
2453 i = block->buf_len - 100;
2455 rec->data = check_pool_memory_size(rec->data, i);
2456 memset(rec->data, i & 0xFF, i);
2459 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2460 for (i=0; i < count; i++) {
2465 if (!write_record_to_block(block, rec)) {
2466 Pmsg0(0, _("Error writing record to block.\n"));
2469 if (!write_block_to_dev(dcr)) {
2470 Pmsg0(0, _("Error writing block to device.\n"));
2476 if (dev->has_cap(CAP_TWOEOF)) {
2483 sm_check(__FILE__, __LINE__, false);
2487 * Fill a tape using raw write() command
2489 static void rawfill_cmd()
2491 DEV_BLOCK *block = dcr->block;
2494 uint32_t block_num = 0;
2499 fd = open("/dev/urandom", O_RDONLY);
2501 read(fd, block->buf, block->buf_len);
2504 uint32_t *p = (uint32_t *)block->buf;
2505 srandom(time(NULL));
2506 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2510 p = (uint32_t *)block->buf;
2511 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2514 stat = dev->d_write(dev->fd(), block->buf, block->buf_len);
2515 if (stat == (int)block->buf_len) {
2516 if ((block_num++ % 100) == 0) {
2521 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2531 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2532 be.bstrerror(my_errno));
2538 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2539 static struct cmdstruct commands[] = {
2540 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2541 {NT_("bsf"), bsfcmd, _("backspace file")},
2542 {NT_("bsr"), bsrcmd, _("backspace record")},
2543 {NT_("cap"), capcmd, _("list device capabilities")},
2544 {NT_("clear"), clearcmd, _("clear tape errors")},
2545 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2546 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2547 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2548 {NT_("unfill"), unfillcmd, _("read filled tape")},
2549 {NT_("fsf"), fsfcmd, _("forward space a file")},
2550 {NT_("fsr"), fsrcmd, _("forward space a record")},
2551 {NT_("help"), helpcmd, _("print this command")},
2552 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2553 {NT_("load"), loadcmd, _("load a tape")},
2554 {NT_("quit"), quitcmd, _("quit btape")},
2555 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2556 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2557 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2558 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2559 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2560 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2561 {NT_("status"), statcmd, _("print tape status")},
2562 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2563 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2564 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2565 {NT_("rr"), rrcmd, _("read a single record")},
2566 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2567 {NT_("qfill"), qfillcmd, _("quick fill command")}
2569 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2577 while (!quit && get_cmd("*")) {
2578 sm_check(__FILE__, __LINE__, false);
2580 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2581 for (i=0; i<comsize; i++) /* search for command */
2582 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2583 (*commands[i].func)(); /* go execute command */
2587 if (*cmd && !found) {
2588 Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2593 static void helpcmd()
2597 printf(_("Interactive commands:\n"));
2598 printf(_(" Command Description\n ======= ===========\n"));
2599 for (i=0; i<comsize; i++)
2600 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2608 "\nVersion: %s (%s)\n\n"
2609 "Usage: btape <options> <device_name>\n"
2610 " -b <file> specify bootstrap file\n"
2611 " -c <file> set configuration file to file\n"
2612 " -d <nn> set debug level to <nn>\n"
2613 " -dt print timestamp in debug output\n"
2614 " -p proceed inspite of I/O errors\n"
2615 " -s turn off signals\n"
2617 " -? print this message.\n"
2618 "\n"), 2000, VERSION, BDATE);
2623 * Get next input command from terminal. This
2624 * routine is REALLY primitive, and should be enhanced
2625 * to have correct backspacing, etc.
2628 get_cmd(const char *prompt)
2632 fprintf(stdout, prompt);
2634 /* We really should turn off echoing and pretty this
2638 while ((ch = fgetc(stdin)) != EOF) {
2640 strip_trailing_junk(cmd);
2642 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2655 /* Dummies to replace askdir.c */
2656 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2657 bool dir_send_job_status(JCR *jcr) {return 1;}
2659 bool dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten)
2665 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2667 Dmsg0(20, "Enter dir_get_volume_info\n");
2668 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2672 bool dir_create_jobmedia_record(DCR *dcr, bool zero)
2674 dcr->WroteVol = false;
2679 bool dir_find_next_appendable_volume(DCR *dcr)
2681 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2682 return dcr->VolumeName[0] != 0;
2685 bool dir_ask_sysop_to_mount_volume(DCR *dcr, int /* mode */)
2687 DEVICE *dev = dcr->dev;
2688 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2689 if (dcr->VolumeName[0] == 0) {
2690 return dir_ask_sysop_to_create_appendable_volume(dcr);
2692 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2693 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2694 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2697 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2698 dcr->VolumeName, dev->print_name());
2705 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2708 DEVICE *dev = dcr->dev;
2709 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2711 set_volume_name("TestVolume1", 1);
2713 set_volume_name("TestVolume2", 2);
2715 /* Close device so user can use autochanger if desired */
2716 if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2719 autochanger = autoload_device(dcr, 1, NULL);
2720 if (autochanger != 1) {
2721 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2732 static bool my_mount_next_read_volume(DCR *dcr)
2735 JCR *jcr = dcr->jcr;
2736 DEV_BLOCK *block = dcr->block;
2738 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2739 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2742 volume_unused(dcr); /* release current volume */
2743 if (LastBlock != block->BlockNumber) {
2744 VolBytes += block->block_len;
2746 LastBlock = block->BlockNumber;
2748 now -= jcr->run_time;
2752 kbs = (double)VolBytes / (1000.0 * (double)now);
2753 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2754 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2756 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2761 set_volume_name("TestVolume2", 2);
2764 if (!acquire_device_for_read(dcr)) {
2765 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2768 return true; /* next volume mounted */
2771 static void set_volume_name(const char *VolName, int volnum)
2773 DCR *dcr = jcr->dcr;
2774 VolumeName = VolName;
2776 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2777 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2778 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2779 dcr->VolCatInfo.Slot = volnum;
2780 dcr->VolCatInfo.InChanger = true;