3 * Bacula Tape manipulation program
5 * Has various tape manipulation commands -- mostly for
6 * use in determining how tapes really work.
8 * Kern Sibbald, April MM
10 * Note, this program reads stored.conf, and will only
11 * talk to devices that are configured.
17 Bacula® - The Network Backup Solution
19 Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
21 The main author of Bacula is Kern Sibbald, with contributions from
22 many others, a complete list can be found in the file AUTHORS.
23 This program is Free Software; you can redistribute it and/or
24 modify it under the terms of version two of the GNU General Public
25 License as published by the Free Software Foundation plus additions
26 that are listed in the file LICENSE.
28 This program is distributed in the hope that it will be useful, but
29 WITHOUT ANY WARRANTY; without even the implied warranty of
30 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 General Public License for more details.
33 You should have received a copy of the GNU General Public License
34 along with this program; if not, write to the Free Software
35 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
38 Bacula® is a registered trademark of John Walker.
39 The licensor of Bacula is the Free Software Foundation Europe
40 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
41 Switzerland, email:ftf@fsfeurope.org.
48 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
50 /* External subroutines */
51 extern void free_config_resources();
53 /* Exported variables */
56 int bsize = TAPE_BSIZE;
57 char VolName[MAX_NAME_LENGTH];
58 STORES *me = NULL; /* our Global resource */
59 bool forge_on = false; /* proceed inspite of I/O errors */
60 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
61 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
64 * If you change the format of the state file,
65 * increment this value
67 static uint32_t btape_state_level = 2;
71 DEVRES *device = NULL;
74 /* Forward referenced subroutines */
75 static void do_tape_cmds();
76 static void helpcmd();
77 static void scancmd();
78 static void rewindcmd();
79 static void clearcmd();
84 static void fillcmd();
85 static void qfillcmd();
86 static void statcmd();
87 static void unfillcmd();
88 static int flush_block(DEV_BLOCK *block, int dump);
89 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
90 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
91 static bool my_mount_next_read_volume(DCR *dcr);
92 static void scan_blocks();
93 static void set_volume_name(const char *VolName, int volnum);
94 static void rawfill_cmd();
95 static bool open_the_device();
96 static void autochangercmd();
97 static void do_unfill();
100 /* Static variables */
101 #define CONFIG_FILE "bacula-sd.conf"
102 char *configfile = NULL;
104 #define MAX_CMD_ARGS 30
106 static POOLMEM *args;
107 static char *argk[MAX_CMD_ARGS];
108 static char *argv[MAX_CMD_ARGS];
111 static int quickie_count = 0;
112 static uint64_t write_count = 0;
113 static BSR *bsr = NULL;
114 static int signals = TRUE;
117 static uint64_t vol_size;
118 static uint64_t VolBytes;
121 static int32_t file_index;
122 static int end_of_tape = 0;
123 static uint32_t LastBlock = 0;
124 static uint32_t eot_block;
125 static uint32_t eot_block_len;
126 static uint32_t eot_FileIndex;
127 static int dumped = 0;
128 static DEV_BLOCK *last_block1 = NULL;
129 static DEV_BLOCK *last_block2 = NULL;
130 static DEV_BLOCK *last_block = NULL;
131 static DEV_BLOCK *this_block = NULL;
132 static DEV_BLOCK *first_block = NULL;
133 static uint32_t last_file1 = 0;
134 static uint32_t last_file2 = 0;
135 static uint32_t last_file = 0;
136 static uint32_t last_block_num1 = 0;
137 static uint32_t last_block_num2 = 0;
138 static uint32_t last_block_num = 0;
139 static uint32_t BlockNumber = 0;
140 static bool simple = true;
142 static const char *VolumeName = NULL;
143 static int vol_num = 0;
145 static JCR *jcr = NULL;
149 static void terminate_btape(int sig);
150 int get_cmd(const char *prompt);
153 /*********************************************************************
155 * Bacula tape testing program
158 int main(int margc, char *margv[])
165 setlocale(LC_ALL, "");
166 bindtextdomain("bacula", LOCALEDIR);
167 textdomain("bacula");
171 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
172 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
173 TAPE_BSIZE, B_DEV_BSIZE);
175 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
176 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
178 if (sizeof(boffset_t) < 8) {
179 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. boffset_t=%d should be 8 or more !!!!!\n\n\n"),
183 bsnprintf(buf, sizeof(buf), "%u", x32);
184 i = bsscanf(buf, "%lu", &y32);
185 if (i != 1 || x32 != y32) {
186 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
192 bsnprintf(buf, sizeof(buf), "%" llu, x64);
193 i = bsscanf(buf, "%llu", &y64);
194 if (i != 1 || x64 != y64) {
195 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
200 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
202 working_directory = "/tmp";
203 my_name_is(margc, margv, "btape");
204 init_msg(NULL, NULL);
208 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
210 case 'b': /* bootstrap file */
211 bsr = parse_bsr(NULL, optarg);
212 // dump_bsr(bsr, true);
215 case 'c': /* specify config file */
216 if (configfile != NULL) {
219 configfile = bstrdup(optarg);
222 case 'd': /* set debug level */
223 debug_level = atoi(optarg);
224 if (debug_level <= 0) {
251 cmd = get_pool_memory(PM_FNAME);
252 args = get_pool_memory(PM_FNAME);
255 init_signals(terminate_btape);
258 if (configfile == NULL) {
259 configfile = bstrdup(CONFIG_FILE);
262 daemon_start_time = time(NULL);
264 parse_config(configfile);
267 /* See if we can open a device */
269 Pmsg0(000, _("No archive name specified.\n"));
272 } else if (margc != 1) {
273 Pmsg0(000, _("Improper number of arguments specified.\n"));
278 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
287 Pmsg0(000, _("btape does not work with DVD storage.\n"));
291 if (!dev->is_tape()) {
292 Pmsg0(000, _("btape only works with tape storage.\n"));
297 if (!open_the_device()) {
301 Dmsg0(200, "Do tape commands\n");
309 static void terminate_btape(int stat)
312 sm_check(__FILE__, __LINE__, false);
316 free_config_resources();
318 free_pool_memory(args);
322 free_pool_memory(cmd);
339 if (debug_level > 10)
340 print_memory_pool_stats();
343 free_block(this_block);
348 close_memory_pool(); /* free memory in pool */
349 term_last_jobs_list();
355 static bool open_the_device()
359 block = new_block(dev);
361 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
362 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
363 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
368 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
369 dev->set_append(); /* put volume in append mode */
382 * Write a label to the tape
384 static void labelcmd()
387 pm_strcpy(cmd, VolumeName);
389 if (!get_cmd(_("Enter Volume Name: "))) {
394 if (!dev->is_open()) {
395 if (!first_open_device(dcr)) {
396 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
401 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
402 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
406 * Read the tape label
408 static void readlabelcmd()
410 int save_debug_level = debug_level;
413 stat = read_dev_volume_label(dcr);
416 Pmsg0(0, _("Volume has no label.\n"));
419 Pmsg0(0, _("Volume label read correctly.\n"));
422 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
425 Pmsg0(0, _("Volume name error\n"));
427 case VOL_CREATE_ERROR:
428 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
430 case VOL_VERSION_ERROR:
431 Pmsg0(0, _("Volume version error.\n"));
433 case VOL_LABEL_ERROR:
434 Pmsg0(0, _("Bad Volume label type.\n"));
437 Pmsg0(0, _("Unknown error.\n"));
442 dump_volume_label(dev);
443 debug_level = save_debug_level;
448 * Load the tape should have prevously been taken
449 * off line, otherwise this command is not necessary.
451 static void loadcmd()
454 if (!load_dev(dev)) {
455 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
457 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
463 static void rewindcmd()
465 if (!dev->rewind(dcr)) {
466 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
469 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
474 * Clear any tape error
476 static void clearcmd()
482 * Write and end of file on the tape
484 static void weofcmd()
494 if (!dev->weof(num)) {
495 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
499 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
502 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
508 /* Go to the end of the medium -- raw command
509 * The idea was orginally that the end of the Bacula
510 * medium would be flagged differently. This is not
511 * currently the case. So, this is identical to the
516 if (!dev->eod(dcr)) {
517 Pmsg1(0, "%s", dev->bstrerror());
520 Pmsg0(0, _("Moved to end of medium.\n"));
525 * Go to the end of the medium (either hardware determined
526 * or defined by two eofs.
546 if (!dev->bsf(num)) {
547 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
549 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
565 if (!dev->bsr(num)) {
566 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
568 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
573 * List device capabilities as defined in the
578 printf(_("Configured device capabilities:\n"));
579 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
580 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
581 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
582 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
583 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
584 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
585 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
586 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
587 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
588 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
589 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
590 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
591 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
592 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
593 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
596 printf(_("Device status:\n"));
597 printf("%sOPENED ", dev->is_open() ? "" : "!");
598 printf("%sTAPE ", dev->is_tape() ? "" : "!");
599 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
600 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
601 printf("%sAPPEND ", dev->can_append() ? "" : "!");
602 printf("%sREAD ", dev->can_read() ? "" : "!");
603 printf("%sEOT ", dev->at_eot() ? "" : "!");
604 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
605 printf("%sEOF ", dev->at_eof() ? "" : "!");
606 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
607 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
610 printf(_("Device parameters:\n"));
611 printf("Device name: %s\n", dev->dev_name);
612 printf("File=%u block=%u\n", dev->file, dev->block_num);
613 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
615 printf(_("Status:\n"));
621 * Test writting larger and larger records.
622 * This is a torture test for records.
624 static void rectestcmd()
630 Pmsg0(0, _("Test writting larger and larger records.\n"
631 "This is a torture test for records.\nI am going to write\n"
632 "larger and larger records. It will stop when the record size\n"
633 "plus the header exceeds the block size (by default about 64K)\n"));
636 get_cmd(_("Do you want to continue? (y/n): "));
638 Pmsg0(000, _("Command aborted.\n"));
642 sm_check(__FILE__, __LINE__, false);
643 block = new_block(dev);
646 for (i=1; i<500000; i++) {
647 rec->data = check_pool_memory_size(rec->data, i);
648 memset(rec->data, i & 0xFF, i);
650 sm_check(__FILE__, __LINE__, false);
651 if (write_record_to_block(block, rec)) {
654 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
658 sm_check(__FILE__, __LINE__, false);
662 sm_check(__FILE__, __LINE__, false);
666 * This test attempts to re-read a block written by Bacula
667 * normally at the end of the tape. Bacula will then back up
668 * over the two eof marks, backup over the record and reread
669 * it to make sure it is valid. Bacula can skip this validation
670 * if you set "Backward space record = no"
672 static int re_read_block_test()
674 DEV_BLOCK *block = dcr->block;
679 if (!(dev->capabilities & CAP_BSR)) {
680 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
684 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
685 "I'm going to write three records and an EOF\n"
686 "then backup over the EOF and re-read the last record.\n"
687 "Bacula does this after writing the last block on the\n"
688 "tape to verify that the block was written correctly.\n\n"
689 "This is not an *essential* feature ...\n\n"));
693 rec->data = check_pool_memory_size(rec->data, block->buf_len);
694 len = rec->data_len = block->buf_len-100;
695 memset(rec->data, 1, rec->data_len);
696 if (!write_record_to_block(block, rec)) {
697 Pmsg0(0, _("Error writing record to block.\n"));
700 if (!write_block_to_dev(dcr)) {
701 Pmsg0(0, _("Error writing block to device.\n"));
704 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
706 memset(rec->data, 2, rec->data_len);
707 if (!write_record_to_block(block, rec)) {
708 Pmsg0(0, _("Error writing record to block.\n"));
711 if (!write_block_to_dev(dcr)) {
712 Pmsg0(0, _("Error writing block to device.\n"));
715 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
717 memset(rec->data, 3, rec->data_len);
718 if (!write_record_to_block(block, rec)) {
719 Pmsg0(0, _("Error writing record to block.\n"));
722 if (!write_block_to_dev(dcr)) {
723 Pmsg0(0, _("Error writing block to device.\n"));
726 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
729 if (dev_cap(dev, CAP_TWOEOF)) {
733 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
736 if (dev_cap(dev, CAP_TWOEOF)) {
738 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
742 Pmsg0(0, _("Backspaced over EOF OK.\n"));
744 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
747 Pmsg0(0, _("Backspace record OK.\n"));
748 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
750 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
753 memset(rec->data, 0, rec->data_len);
754 if (!read_record_from_block(block, rec)) {
756 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
759 for (int i=0; i<len; i++) {
760 if (rec->data[i] != 3) {
761 Pmsg0(0, _("Bad data in record. Test failed!\n"));
765 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
766 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
773 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
774 "this function to verify the last block written to the\n"
775 "tape. Bacula will skip the last block verification\n"
777 "Backward Space Record = No\n\n"
778 "to your Storage daemon's Device resource definition.\n"));
785 * This test writes Bacula blocks to the tape in
786 * several files. It then rewinds the tape and attepts
787 * to read these blocks back checking the data.
789 static int write_read_test()
797 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
798 "I'm going to write 1000 records and an EOF\n"
799 "then write 1000 records and an EOF, then rewind,\n"
800 "and re-read the data to verify that it is correct.\n\n"
801 "This is an *essential* feature ...\n\n"));
804 if (!dev->rewind(dcr)) {
805 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
808 rec->data = check_pool_memory_size(rec->data, block->buf_len);
809 rec->data_len = block->buf_len-100;
810 len = rec->data_len/sizeof(i);
811 for (i=1; i<=1000; i++) {
812 p = (int *)rec->data;
813 for (j=0; j<len; j++) {
816 if (!write_record_to_block(block, rec)) {
817 Pmsg0(0, _("Error writing record to block.\n"));
820 if (!write_block_to_dev(dcr)) {
821 Pmsg0(0, _("Error writing block to device.\n"));
825 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
827 for (i=1001; i<=2000; i++) {
828 p = (int *)rec->data;
829 for (j=0; j<len; j++) {
832 if (!write_record_to_block(block, rec)) {
833 Pmsg0(0, _("Error writing record to block.\n"));
836 if (!write_block_to_dev(dcr)) {
837 Pmsg0(0, _("Error writing block to device.\n"));
841 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
843 if (dev_cap(dev, CAP_TWOEOF)) {
846 if (!dev->rewind(dcr)) {
847 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
850 Pmsg0(0, _("Rewind OK.\n"));
852 for (i=1; i<=2000; i++) {
854 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
856 if (dev_state(dev, ST_EOF)) {
857 Pmsg0(-1, _("Got EOF on tape.\n"));
862 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
865 memset(rec->data, 0, rec->data_len);
866 if (!read_record_from_block(block, rec)) {
868 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
871 p = (int *)rec->data;
872 for (j=0; j<len; j++) {
874 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
880 if (i == 1000 || i == 2000) {
881 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
884 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
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 int position_test()
899 DEV_BLOCK *block = dcr->block;
905 int file = 0, blk = 0;
907 bool got_eof = false;
909 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
910 "I'm going to write 1000 records and an EOF\n"
911 "then write 1000 records and an EOF, then rewind,\n"
912 "and position to a few blocks and verify that it is correct.\n\n"
913 "This is an *essential* feature ...\n\n"));
916 if (!dev->rewind(dcr)) {
917 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
920 rec->data = check_pool_memory_size(rec->data, block->buf_len);
921 rec->data_len = block->buf_len-100;
922 len = rec->data_len/sizeof(i);
923 for (i=1; i<=1000; i++) {
924 p = (int *)rec->data;
925 for (j=0; j<len; j++) {
928 if (!write_record_to_block(block, rec)) {
929 Pmsg0(0, _("Error writing record to block.\n"));
932 if (!write_block_to_dev(dcr)) {
933 Pmsg0(0, _("Error writing block to device.\n"));
937 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
939 for (i=1001; i<=2000; i++) {
940 p = (int *)rec->data;
941 for (j=0; j<len; j++) {
944 if (!write_record_to_block(block, rec)) {
945 Pmsg0(0, _("Error writing record to block.\n"));
948 if (!write_block_to_dev(dcr)) {
949 Pmsg0(0, _("Error writing block to device.\n"));
953 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
955 if (dev_cap(dev, CAP_TWOEOF)) {
958 if (!dev->rewind(dcr)) {
959 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
962 Pmsg0(0, _("Rewind OK.\n"));
966 /* Set up next item to read based on where we are */
1002 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1003 if (!dev->reposition(dcr, file, blk)) {
1004 Pmsg0(0, _("Reposition error.\n"));
1008 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1010 if (dev_state(dev, ST_EOF)) {
1011 Pmsg0(-1, _("Got EOF on tape.\n"));
1017 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1018 recno, file, blk, be.strerror(dev->dev_errno));
1019 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1020 " set to variable blocking as normally used by Bacula.\n"
1021 " Please see the Tape Testing chapter in the manual and \n"
1022 " look for using mt with defblksize and setoptions\n"
1023 "If your tape drive block size is correct, then perhaps\n"
1024 " your SCSI driver is *really* stupid and does not\n"
1025 " correctly report the file:block after a FSF. In this\n"
1026 " case try setting:\n"
1027 " Fast Forward Space File = no\n"
1028 " in your Device resource.\n"));
1032 memset(rec->data, 0, rec->data_len);
1033 if (!read_record_from_block(block, rec)) {
1035 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1038 p = (int *)rec->data;
1039 for (j=0; j<len; j++) {
1040 if (p[j] != recno) {
1041 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1046 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1048 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1060 * This test writes some records, then writes an end of file,
1061 * rewinds the tape, moves to the end of the data and attepts
1062 * to append to the tape. This function is essential for
1063 * Bacula to be able to write multiple jobs to the tape.
1065 static int append_test()
1067 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1068 "This test is essential to Bacula.\n\n"
1069 "I'm going to write one record in file 0,\n"
1070 " two records in file 1,\n"
1071 " and three records in file 2\n\n"));
1075 weofcmd(); /* end file 0 */
1078 weofcmd(); /* end file 1 */
1082 weofcmd(); /* end file 2 */
1083 if (dev_cap(dev, CAP_TWOEOF)) {
1086 dev->close(); /* release device */
1087 if (!open_the_device()) {
1091 Pmsg0(0, _("Now moving to end of medium.\n"));
1093 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1094 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1096 if (dev->file != 3) {
1100 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1103 if (dev_cap(dev, CAP_TWOEOF)) {
1107 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1108 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1110 Pmsg0(-1, _("End scanning the tape.\n"));
1111 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1112 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1114 if (dev->file != 4) {
1122 * This test exercises the autochanger
1124 static int autochanger_test()
1126 POOLMEM *results, *changer;
1127 int slot, status, loaded;
1128 int timeout = dcr->device->max_changer_wait;
1131 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1132 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1135 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1136 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1140 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1141 "To test the autochanger you must have a blank tape\n"
1142 " that I can write on in Slot 1.\n"));
1143 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1146 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1150 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1152 results = get_pool_memory(PM_MESSAGE);
1153 changer = get_pool_memory(PM_FNAME);
1157 dcr->VolCatInfo.Slot = slot;
1158 /* Find out what is loaded, zero means device is unloaded */
1159 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1160 changer = edit_device_codes(dcr, changer,
1161 dcr->device->changer_command, "loaded");
1162 status = run_program(changer, timeout, results);
1163 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1165 loaded = atoi(results);
1168 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1169 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1173 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1175 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1177 Dmsg1(100, "Results from loaded query=%s\n", results);
1179 dcr->VolCatInfo.Slot = loaded;
1180 /* We are going to load a new tape, so close the device */
1182 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1183 loaded, dev->drive_index);
1184 changer = edit_device_codes(dcr, changer,
1185 dcr->device->changer_command, "unload");
1186 status = run_program(changer, timeout, results);
1187 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1190 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1191 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1200 dcr->VolCatInfo.Slot = slot;
1201 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1202 slot, dev->drive_index);
1203 changer = edit_device_codes(dcr, changer,
1204 dcr->device->changer_command, "load");
1205 Dmsg1(100, "Changer=%s\n", changer);
1207 status = run_program(changer, timeout, results);
1209 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1210 slot, dev->drive_index);
1213 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1214 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1218 if (!open_the_device()) {
1222 * Start with sleep_time 0 then increment by 30 seconds if we get
1225 bmicrosleep(sleep_time, 0);
1226 if (!dev->rewind(dcr) || !dev->weof(1)) {
1227 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1229 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1230 "a longer sleep time in the mtx-script in the load) case.\n"
1231 "Adding a 30 second sleep and trying again ...\n"));
1235 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1238 if (!dev->weof(1)) {
1239 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1242 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1246 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1248 "to your mtx-changer script in the load) case.\n\n"),
1251 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1254 free_pool_memory(changer);
1255 free_pool_memory(results);
1260 free_pool_memory(changer);
1261 free_pool_memory(results);
1262 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1266 static void autochangercmd()
1273 * This test assumes that the append test has been done,
1274 * then it tests the fsf function.
1276 static int fsf_test()
1278 bool set_off = false;
1280 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1281 "This test is essential to Bacula.\n\n"
1282 "I'm going to write five files then test forward spacing\n\n"));
1286 weofcmd(); /* end file 0 */
1289 weofcmd(); /* end file 1 */
1293 weofcmd(); /* end file 2 */
1296 weofcmd(); /* end file 3 */
1298 weofcmd(); /* end file 4 */
1299 if (dev_cap(dev, CAP_TWOEOF)) {
1305 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1307 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1310 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1311 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1313 if (dev->file != 1) {
1317 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1319 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1322 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1323 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1325 if (dev->file != 3) {
1330 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1332 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1335 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1336 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1338 if (dev->file != 4) {
1342 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1343 " Fast Forward Space File = no\n\n"
1344 "to your Device resource for this drive.\n"));
1348 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1350 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1352 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1353 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1354 if (dev->file != 5) {
1357 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1361 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1362 if (dev_cap(dev, CAP_FASTFSF)) {
1363 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1364 "I am turning it off then retrying the test.\n"));
1365 dev->capabilities &= ~CAP_FASTFSF;
1369 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1370 "Some systems, e.g. OpenBSD, require you to set\n"
1371 " Use MTIOCGET= no\n"
1372 "in your device resource. Use with caution.\n"));
1381 * This is a general test of Bacula's functions
1382 * needed to read and write the tape.
1384 static void testcmd()
1388 if (!write_read_test()) {
1391 if (!position_test()) {
1395 stat = append_test();
1396 if (stat == 1) { /* OK get out */
1399 if (stat == -1) { /* first test failed */
1400 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1401 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1402 "Setting \"Hardware End of Medium = no\n"
1403 " and \"Fast Forward Space File = no\n"
1404 "and retrying append test.\n\n"));
1405 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1406 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1407 stat = append_test();
1409 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1410 " Hardware End of Medium = No\n\n"
1411 " Fast Forward Space File = No\n"
1412 "to your Device resource in the Storage conf file.\n"));
1416 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1419 /* Wrong count after append */
1421 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1422 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1423 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
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"
1428 " Fast Forward Space File = No\n"
1429 " BSF at EOM = yes\n\n"
1430 "to your Device resource in the Storage conf file.\n"));
1437 Pmsg0(-1, _("\nAppend test failed.\n\n"
1438 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1439 "Unable to correct the problem. You MUST fix this\n"
1440 "problem before Bacula can use your tape drive correctly\n"
1441 "\nPerhaps running Bacula in fixed block mode will work.\n"
1442 "Do so by setting:\n\n"
1443 "Minimum Block Size = nnn\n"
1444 "Maximum Block Size = nnn\n\n"
1445 "in your Storage daemon's Device definition.\n"
1446 "nnn must match your tape driver's block size, which\n"
1447 "can be determined by reading your tape manufacturers\n"
1448 "information, and the information on your kernel dirver.\n"
1449 "Fixed block sizes, however, are not normally an ideal solution.\n"
1451 "Some systems, e.g. OpenBSD, require you to set\n"
1452 " Use MTIOCGET= no\n"
1453 "in your device resource. Use with caution.\n"));
1458 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1459 "Please double check it ...\n"
1460 "=== Sample correct output ===\n"
1461 "1 block of 64448 bytes in file 1\n"
1462 "End of File mark.\n"
1463 "2 blocks of 64448 bytes in file 2\n"
1464 "End of File mark.\n"
1465 "3 blocks of 64448 bytes in file 3\n"
1466 "End of File mark.\n"
1467 "1 block of 64448 bytes in file 4\n"
1468 "End of File mark.\n"
1469 "Total files=4, blocks=7, bytes = 451,136\n"
1470 "=== End sample correct output ===\n\n"
1471 "If the above scan output is not identical to the\n"
1472 "sample output, you MUST correct the problem\n"
1473 "or Bacula will not be able to write multiple Jobs to \n"
1477 re_read_block_test();
1480 fsf_test(); /* do fast forward space file test */
1482 autochanger_test(); /* do autochanger test */
1486 /* Forward space a file */
1487 static void fsfcmd()
1491 num = atoi(argk[1]);
1496 if (!dev->fsf(num)) {
1497 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1501 Pmsg0(0, _("Forward spaced 1 file.\n"));
1504 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1508 /* Forward space a record */
1509 static void fsrcmd()
1513 num = atoi(argk[1]);
1518 if (!dev->fsr(num)) {
1519 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1523 Pmsg0(0, _("Forward spaced 1 record.\n"));
1526 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1531 * Read a Bacula block from the tape
1535 dev->open(dcr, OPEN_READ_ONLY);
1536 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1540 * Write a Bacula block to the tape
1544 DEV_BLOCK *block = dcr->block;
1545 DEV_RECORD *rec = dcr->rec;
1548 if (!dev->is_open()) {
1551 sm_check(__FILE__, __LINE__, false);
1554 dump_block(block, "test");
1557 i = block->buf_len - 100;
1559 rec->data = check_pool_memory_size(rec->data, i);
1560 memset(rec->data, i & 0xFF, i);
1562 sm_check(__FILE__, __LINE__, false);
1563 if (!write_record_to_block(block, rec)) {
1564 Pmsg0(0, _("Error writing record to block.\n"));
1567 if (!write_block_to_dev(dcr)) {
1568 Pmsg0(0, _("Error writing block to device.\n"));
1571 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1573 Pmsg0(0, _("Wrote block to device.\n"));
1576 sm_check(__FILE__, __LINE__, false);
1577 sm_check(__FILE__, __LINE__, false);
1581 * Read a record from the tape
1588 if (!get_cmd(_("Enter length to read: "))) {
1592 if (len < 0 || len > 1000000) {
1593 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1596 buf = (char *)malloc(len);
1597 stat = read(dev->fd, buf, len);
1598 if (stat > 0 && stat <= len) {
1602 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1603 len, stat, be.strerror());
1609 * Scan tape by reading block by block. Report what is
1610 * on the tape. Note, this command does raw reads, and as such
1611 * will not work with fixed block size devices.
1613 static void scancmd()
1616 int blocks, tot_blocks, tot_files;
1622 blocks = block_size = tot_blocks = 0;
1624 if (dev->state & ST_EOT) {
1625 Pmsg0(0, _("End of tape\n"));
1628 dev->update_pos(dcr);
1629 tot_files = dev->file;
1630 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1632 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1635 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1636 dev->dev_name, be.strerror());
1637 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1640 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1643 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1648 Dmsg1(200, "read status = %d\n", stat);
1650 if (stat != block_size) {
1651 dev->update_pos(dcr);
1654 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1657 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1663 if (stat == 0) { /* EOF */
1664 dev->update_pos(dcr);
1665 printf(_("End of File mark.\n"));
1666 /* Two reads of zero means end of tape */
1667 if (dev->state & ST_EOF)
1668 dev->state |= ST_EOT;
1670 dev->state |= ST_EOF;
1673 if (dev->state & ST_EOT) {
1674 printf(_("End of tape\n"));
1677 } else { /* Got data */
1678 dev->state &= ~ST_EOF;
1684 dev->update_pos(dcr);
1685 tot_files = dev->file - tot_files;
1686 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1687 edit_uint64_with_commas(bytes, ec1));
1692 * Scan tape by reading Bacula block by block. Report what is
1693 * on the tape. This function reads Bacula blocks, so if your
1694 * Device resource is correctly defined, it should work with
1695 * either variable or fixed block sizes.
1697 static void scan_blocks()
1699 int blocks, tot_blocks, tot_files;
1700 uint32_t block_size;
1702 DEV_BLOCK *block = dcr->block;
1704 char buf1[100], buf2[100];
1706 blocks = block_size = tot_blocks = 0;
1710 dev->update_pos(dcr);
1711 tot_files = dev->file;
1713 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1714 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1715 if (dev->state & ST_EOT) {
1718 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1721 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1727 if (dev->state & ST_EOF) {
1730 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1733 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1737 printf(_("End of File mark.\n"));
1740 if (dev->state & ST_SHORT) {
1743 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1746 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1750 printf(_("Short block read.\n"));
1753 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1756 if (block->block_len != block_size) {
1759 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1762 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1766 block_size = block->block_len;
1770 bytes += block->block_len;
1771 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1772 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1773 block->VolSessionId, block->VolSessionTime);
1775 DEV_RECORD *rec = new_record();
1776 read_record_from_block(block, rec);
1777 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1778 block->BlockNumber, dev->block_num, block->block_len,
1779 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1780 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1783 } else if (verbose > 1) {
1784 dump_block(block, "");
1789 tot_files = dev->file - tot_files;
1790 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1791 edit_uint64_with_commas(bytes, ec1));
1795 static void statcmd()
1797 int debug = debug_level;
1799 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1801 dump_volume_label(dev);
1803 debug_level = debug;
1808 * First we label the tape, then we fill
1809 * it with data get a new tape and write a few blocks.
1811 static void fillcmd()
1814 DEV_BLOCK *block = dcr->block;
1816 char buf1[100], buf2[100];
1819 uint32_t min_block_size;
1830 "This command simulates Bacula writing to a tape.\n"
1831 "It requires either one or two blank tapes, which it\n"
1832 "will label and write.\n\n"
1833 "If you have an autochanger configured, it will use\n"
1834 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1835 "be prompted to insert the tapes when necessary.\n\n"
1836 "It will print a status approximately\n"
1837 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1838 "selected the simple test option, after writing the first tape\n"
1839 "it will rewind it and re-read the last block written.\n\n"
1840 "If you have selected the multiple tape test, when the first tape\n"
1841 "fills, it will ask for a second, and after writing a few more \n"
1842 "blocks, it will stop. Then it will begin re-reading the\n"
1844 "This may take a long time -- hours! ...\n\n"));
1846 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1847 "or the complete multiple tape (m) test: (s/m) "));
1848 if (cmd[0] == 's') {
1849 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1851 } else if (cmd[0] == 'm') {
1852 Pmsg0(-1, _("Multiple tape test selected.\n"));
1855 Pmsg0(000, _("Command aborted.\n"));
1859 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1860 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1862 /* Use fixed block size to simplify read back */
1863 min_block_size = dev->min_block_size;
1864 dev->min_block_size = dev->max_block_size;
1865 set_volume_name("TestVolume1", 1);
1866 dir_ask_sysop_to_create_appendable_volume(dcr);
1867 dev->set_append(); /* force volume to be relabeled */
1870 * Acquire output device for writing. Note, after acquiring a
1871 * device, we MUST release it, which is done at the end of this
1874 Dmsg0(100, "just before acquire_device\n");
1875 if (!acquire_device_for_append(dcr)) {
1876 set_jcr_job_status(jcr, JS_ErrorTerminated);
1879 block = jcr->dcr->block;
1881 Dmsg0(100, "Just after acquire_device_for_append\n");
1883 * Write Begin Session Record
1885 if (!write_session_label(dcr, SOS_LABEL)) {
1886 set_jcr_job_status(jcr, JS_ErrorTerminated);
1887 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1891 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1893 memset(&rec, 0, sizeof(rec));
1894 rec.data = get_memory(100000); /* max record size */
1896 #define REC_SIZE 32768
1897 rec.data_len = REC_SIZE;
1900 * Put some random data in the record
1902 fd = open("/dev/urandom", O_RDONLY);
1904 read(fd, rec.data, rec.data_len);
1907 uint32_t *p = (uint32_t *)rec.data;
1908 srandom(time(NULL));
1909 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1915 * Generate data as if from File daemon, write to device
1917 jcr->dcr->VolFirstIndex = 0;
1918 time(&jcr->run_time); /* start counting time for rates */
1919 (void)localtime_r(&jcr->run_time, &tm);
1920 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1922 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1924 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1926 for (file_index = 0; ok && !job_canceled(jcr); ) {
1927 rec.VolSessionId = jcr->VolSessionId;
1928 rec.VolSessionTime = jcr->VolSessionTime;
1929 rec.FileIndex = ++file_index;
1930 rec.Stream = STREAM_FILE_DATA;
1932 /* Mix up the data just a bit */
1933 uint32_t *lp = (uint32_t *)rec.data;
1935 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1939 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1940 rec.FileIndex, rec.VolSessionId,
1941 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1944 while (!write_record_to_block(block, &rec)) {
1946 * When we get here we have just filled a block
1948 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1951 /* Write block to tape */
1952 if (!flush_block(block, 1)) {
1956 /* Every 5000 blocks (approx 322MB) report where we are.
1958 if ((block->BlockNumber % 5000) == 0) {
1960 now -= jcr->run_time;
1962 now = 1; /* prevent divide error */
1964 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1965 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1966 block->BlockNumber, dev->block_num,
1967 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1969 /* Every 32000 blocks (approx 2GB) write an EOF.
1971 if ((block->BlockNumber % 32000) == 0) {
1973 (void)localtime_r(&now, &tm);
1974 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1975 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1976 flush_block(block, 0);
1980 /* Get out after writing 10 blocks to the second tape */
1981 if (++BlockNumber > 10 && stop != 0) { /* get out */
1986 Pmsg0(000, _("Not OK\n"));
1989 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1990 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1991 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1992 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1994 /* Get out after writing 10 blocks to the second tape */
1995 if (BlockNumber > 10 && stop != 0) { /* get out */
1997 Pmsg1(-1, "Done writing %s records ...\n",
1998 edit_uint64_with_commas(write_count, ed1));
2003 Dmsg0(100, "Write_end_session_label()\n");
2004 /* Create Job status for end of session label */
2005 if (!job_canceled(jcr) && ok) {
2006 set_jcr_job_status(jcr, JS_Terminated);
2008 set_jcr_job_status(jcr, JS_ErrorTerminated);
2010 if (!write_session_label(dcr, EOS_LABEL)) {
2011 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2014 /* Write out final block of this session */
2015 if (!write_block_to_device(dcr)) {
2016 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2019 Pmsg0(-1, _("Wrote End of Session label.\n"));
2021 /* Save last block info for second tape */
2022 last_block_num2 = last_block_num;
2023 last_file2 = last_file;
2025 free_block(last_block2);
2027 last_block2 = dup_block(last_block);
2030 sprintf(buf, "%s/btape.state", working_directory);
2031 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2033 write(fd, &btape_state_level, sizeof(btape_state_level));
2034 write(fd, &simple, sizeof(simple));
2035 write(fd, &last_block_num1, sizeof(last_block_num1));
2036 write(fd, &last_block_num2, sizeof(last_block_num2));
2037 write(fd, &last_file1, sizeof(last_file1));
2038 write(fd, &last_file2, sizeof(last_file2));
2039 write(fd, last_block1->buf, last_block1->buf_len);
2040 write(fd, last_block2->buf, last_block2->buf_len);
2041 write(fd, first_block->buf, first_block->buf_len);
2043 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2044 last_block_num1, last_block_num2);
2047 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2052 (void)localtime_r(&now, &tm);
2053 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2055 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2056 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2059 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2060 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2063 jcr->dcr->block = block;
2066 dev->min_block_size = min_block_size;
2067 free_memory(rec.data);
2071 * Read two tapes written by the "fill" command and ensure
2072 * that the data is valid. If stop==1 we simulate full read back
2073 * of two tapes. If stop==-1 we simply read the last block and
2074 * verify that it is correct.
2076 static void unfillcmd()
2080 last_block1 = new_block(dev);
2081 last_block2 = new_block(dev);
2082 first_block = new_block(dev);
2083 sprintf(buf, "%s/btape.state", working_directory);
2084 fd = open(buf, O_RDONLY);
2086 uint32_t state_level;
2087 read(fd, &state_level, sizeof(btape_state_level));
2088 read(fd, &simple, sizeof(simple));
2089 read(fd, &last_block_num1, sizeof(last_block_num1));
2090 read(fd, &last_block_num2, sizeof(last_block_num2));
2091 read(fd, &last_file1, sizeof(last_file1));
2092 read(fd, &last_file2, sizeof(last_file2));
2093 read(fd, last_block1->buf, last_block1->buf_len);
2094 read(fd, last_block2->buf, last_block2->buf_len);
2095 read(fd, first_block->buf, first_block->buf_len);
2097 if (state_level != btape_state_level) {
2098 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2099 "the fill command.\n"));
2104 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2105 "You must redo the fill command.\n"), buf, be.strerror());
2112 static void do_unfill()
2114 DEV_BLOCK *block = dcr->block;
2121 Dmsg0(20, "Enter do_unfill\n");
2122 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2123 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2127 time(&jcr->run_time); /* start counting time for rates */
2131 free_block(last_block);
2134 last_block_num = last_block_num1;
2135 last_file = last_file1;
2136 last_block = last_block1;
2138 free_restore_volume_list(jcr);
2140 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2141 create_restore_volume_list(jcr);
2142 if (jcr->VolList != NULL) {
2143 jcr->VolList->Slot = 1;
2144 if (jcr->VolList->next != NULL) {
2145 jcr->VolList->next->Slot = 2;
2149 set_volume_name("TestVolume1", 1);
2152 /* Multiple Volume tape */
2153 /* Close device so user can use autochanger if desired */
2154 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2157 autochanger = autoload_device(dcr, 1, NULL);
2158 if (autochanger != 1) {
2160 get_cmd(_("Mount first tape. Press enter when ready: "));
2165 dev->num_writers = 0;
2166 if (!acquire_device_for_read(dcr)) {
2167 Pmsg1(-1, "%s", dev->errmsg);
2171 * We now have the first tape mounted.
2172 * Note, re-reading last block may have caused us to
2173 * loose track of where we are (block number unknown).
2175 Pmsg0(-1, _("Rewinding.\n"));
2176 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2179 /* Read the first 10000 records */
2180 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2181 dev->file, dev->block_num);
2183 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2184 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2185 last_file, last_block_num);
2186 if (!dev->reposition(dcr, last_file, last_block_num)) {
2187 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2190 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2191 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2192 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2195 if (compare_blocks(last_block, block)) {
2197 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2199 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2206 /* restore info for last block on second Volume */
2207 last_block_num = last_block_num2;
2208 last_file = last_file2;
2209 last_block = last_block2;
2211 /* Multiple Volume tape */
2212 /* Close device so user can use autochanger if desired */
2213 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2217 set_volume_name("TestVolume2", 2);
2219 autochanger = autoload_device(dcr, 1, NULL);
2220 if (autochanger != 1) {
2222 get_cmd(_("Mount second tape. Press enter when ready: "));
2226 if (!acquire_device_for_read(dcr)) {
2227 Pmsg1(-1, "%s", dev->errmsg);
2231 /* Space to "first" block which is last block not written
2232 * on the previous tape.
2234 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2235 if (!dev->reposition(dcr, 0, 1)) {
2236 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2239 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2240 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2241 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2244 if (compare_blocks(first_block, block)) {
2245 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2248 /* Now find and compare the last block */
2249 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2250 last_file, last_block_num);
2251 if (!dev->reposition(dcr, last_file, last_block_num)) {
2252 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2255 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2256 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2257 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2260 if (compare_blocks(last_block, block)) {
2261 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2265 free_block(last_block1);
2266 free_block(last_block2);
2267 free_block(first_block);
2270 /* Read 10000 records then stop */
2271 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2273 DEVICE *dev = dcr->dev;
2275 if (quickie_count == 10000) {
2276 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2278 return quickie_count < 10000;
2281 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2284 uint32_t CheckSum, block_len;
2287 p = last_block->buf;
2289 unser_begin(q, BLKHDR2_LENGTH);
2290 unser_uint32(CheckSum);
2291 unser_uint32(block_len);
2292 while (q < (block->buf+block_len)) {
2299 dump_block(last_block, _("Last block written"));
2301 dump_block(block, _("Block read back"));
2302 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2303 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2304 "that was read back differ. The test FAILED !!!!\n"
2305 "This must be corrected before you use Bacula\n"
2306 "to write multi-tape Volumes.!!!!\n"));
2310 dump_block(last_block, _("Last block written"));
2311 dump_block(block, _("Block read back"));
2321 * Write current block to tape regardless of whether or
2322 * not it is full. If the tape fills, attempt to
2323 * acquire another tape.
2325 static int flush_block(DEV_BLOCK *block, int dump)
2329 uint32_t this_file, this_block_num;
2333 this_block = new_block(dev);
2336 last_block = new_block(dev);
2339 this_file = dev->file;
2340 this_block_num = dev->block_num;
2341 if (!write_block_to_dev(dcr)) {
2342 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2343 last_file, last_block_num, this_block_num);
2346 * This is 1st tape, so save first tape info separate
2347 * from second tape info
2349 last_block_num1 = last_block_num;
2350 last_file1 = last_file;
2351 last_block1 = dup_block(last_block);
2352 last_block2 = dup_block(last_block);
2353 first_block = dup_block(block); /* first block second tape */
2356 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2357 (unsigned)file_index, block->BlockNumber, block->block_len);
2358 dump_block(last_block, _("Last block written"));
2360 dump_block(block, _("Block not written"));
2363 eot_block = block->BlockNumber;
2364 eot_block_len = block->block_len;
2365 eot_FileIndex = file_index;
2369 now -= jcr->run_time;
2371 now = 1; /* don't divide by zero */
2373 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2374 vol_size = dev->VolCatInfo.VolCatBytes;
2375 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2376 dev->file, dev->block_num,
2377 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2380 stop = -1; /* stop, but do simplified test */
2382 /* Full test in progress */
2383 if (!fixup_device_block_write_error(jcr->dcr)) {
2384 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2389 BlockNumber = 0; /* start counting for second tape */
2392 return 1; /* end of tape reached */
2395 /* Save contents after write so that the header is serialized */
2396 memcpy(this_block->buf, block->buf, this_block->buf_len);
2399 * Note, we always read/write to block, but we toggle
2400 * copying it to one or another of two allocated blocks.
2401 * Switch blocks so that the block just successfully written is
2402 * always in last_block.
2404 tblock = last_block;
2405 last_block = this_block;
2406 this_block = tblock;
2407 last_file = this_file;
2408 last_block_num = this_block_num;
2416 * First we label the tape, then we fill
2417 * it with data get a new tape and write a few blocks.
2419 static void qfillcmd()
2421 DEV_BLOCK *block = dcr->block;
2422 DEV_RECORD *rec = dcr->rec;
2425 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2427 get_cmd(_("How many blocks do you want to write? (1000): "));
2434 sm_check(__FILE__, __LINE__, false);
2436 i = block->buf_len - 100;
2438 rec->data = check_pool_memory_size(rec->data, i);
2439 memset(rec->data, i & 0xFF, i);
2442 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2443 for (i=0; i < count; i++) {
2448 if (!write_record_to_block(block, rec)) {
2449 Pmsg0(0, _("Error writing record to block.\n"));
2452 if (!write_block_to_dev(dcr)) {
2453 Pmsg0(0, _("Error writing block to device.\n"));
2459 if (dev_cap(dev, CAP_TWOEOF)) {
2466 sm_check(__FILE__, __LINE__, false);
2470 * Fill a tape using raw write() command
2472 static void rawfill_cmd()
2474 DEV_BLOCK *block = dcr->block;
2477 uint32_t block_num = 0;
2482 fd = open("/dev/urandom", O_RDONLY);
2484 read(fd, block->buf, block->buf_len);
2487 uint32_t *p = (uint32_t *)block->buf;
2488 srandom(time(NULL));
2489 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2493 p = (uint32_t *)block->buf;
2494 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2497 if (dev->is_tape()) {
2498 stat = tape_write(dev->fd, block->buf, block->buf_len);
2500 stat = write(dev->fd, block->buf, block->buf_len);
2502 if (stat == (int)block->buf_len) {
2503 if ((block_num++ % 100) == 0) {
2508 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2518 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2519 be.strerror(my_errno));
2525 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2526 static struct cmdstruct commands[] = {
2527 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2528 {NT_("bsf"), bsfcmd, _("backspace file")},
2529 {NT_("bsr"), bsrcmd, _("backspace record")},
2530 {NT_("cap"), capcmd, _("list device capabilities")},
2531 {NT_("clear"), clearcmd, _("clear tape errors")},
2532 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2533 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2534 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2535 {NT_("unfill"), unfillcmd, _("read filled tape")},
2536 {NT_("fsf"), fsfcmd, _("forward space a file")},
2537 {NT_("fsr"), fsrcmd, _("forward space a record")},
2538 {NT_("help"), helpcmd, _("print this command")},
2539 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2540 {NT_("load"), loadcmd, _("load a tape")},
2541 {NT_("quit"), quitcmd, _("quit btape")},
2542 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2543 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2544 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2545 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2546 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2547 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2548 {NT_("status"), statcmd, _("print tape status")},
2549 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2550 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2551 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2552 {NT_("rr"), rrcmd, _("read a single record")},
2553 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2554 {NT_("qfill"), qfillcmd, _("quick fill command")}
2556 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2564 while (!quit && get_cmd("*")) {
2565 sm_check(__FILE__, __LINE__, false);
2567 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2568 for (i=0; i<comsize; i++) /* search for command */
2569 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2570 (*commands[i].func)(); /* go execute command */
2575 Pmsg1(0, _("\"%s\" is an illegal command\n"), cmd);
2580 static void helpcmd()
2584 printf(_("Interactive commands:\n"));
2585 printf(_(" Command Description\n ======= ===========\n"));
2586 for (i=0; i<comsize; i++)
2587 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2595 "\nVersion: %s (%s)\n\n"
2596 "Usage: btape <options> <device_name>\n"
2597 " -b <file> specify bootstrap file\n"
2598 " -c <file> set configuration file to file\n"
2599 " -d <nn> set debug level to nn\n"
2600 " -p proceed inspite of I/O errors\n"
2601 " -s turn off signals\n"
2603 " -? print this message.\n"
2604 "\n"), BYEAR, VERSION, BDATE);
2609 * Get next input command from terminal. This
2610 * routine is REALLY primitive, and should be enhanced
2611 * to have correct backspacing, etc.
2614 get_cmd(const char *prompt)
2618 fprintf(stdout, prompt);
2620 /* We really should turn off echoing and pretty this
2624 while ((ch = fgetc(stdin)) != EOF) {
2626 strip_trailing_junk(cmd);
2628 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2641 /* Dummies to replace askdir.c */
2642 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2643 bool dir_send_job_status(JCR *jcr) {return 1;}
2645 bool dir_update_volume_info(DCR *dcr, bool relabel)
2651 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2653 Dmsg0(20, "Enter dir_get_volume_info\n");
2654 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2658 bool dir_create_jobmedia_record(DCR *dcr)
2660 dcr->WroteVol = false;
2665 bool dir_find_next_appendable_volume(DCR *dcr)
2667 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2668 return dcr->VolumeName[0] != 0;
2671 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2673 DEVICE *dev = dcr->dev;
2674 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2675 if (dcr->VolumeName[0] == 0) {
2676 return dir_ask_sysop_to_create_appendable_volume(dcr);
2678 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2679 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2680 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2683 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2684 dcr->VolumeName, dev->print_name());
2691 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2694 DEVICE *dev = dcr->dev;
2695 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2697 set_volume_name("TestVolume1", 1);
2699 set_volume_name("TestVolume2", 2);
2701 /* Close device so user can use autochanger if desired */
2702 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2705 autochanger = autoload_device(dcr, 1, NULL);
2706 if (autochanger != 1) {
2707 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2718 static bool my_mount_next_read_volume(DCR *dcr)
2721 JCR *jcr = dcr->jcr;
2722 DEV_BLOCK *block = dcr->block;
2724 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2725 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2728 if (LastBlock != block->BlockNumber) {
2729 VolBytes += block->block_len;
2731 LastBlock = block->BlockNumber;
2733 now -= jcr->run_time;
2737 kbs = (double)VolBytes / (1000.0 * (double)now);
2738 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2739 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2741 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2746 set_volume_name("TestVolume2", 2);
2749 if (!acquire_device_for_read(dcr)) {
2750 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2753 return true; /* next volume mounted */
2756 static void set_volume_name(const char *VolName, int volnum)
2758 DCR *dcr = jcr->dcr;
2759 VolumeName = VolName;
2761 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2762 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2763 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2764 dcr->VolCatInfo.Slot = volnum;
2765 dcr->VolCatInfo.InChanger = true;