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 Copyright (C) 2000-2006 Kern Sibbald
19 This program is free software; you can redistribute it and/or
20 modify it under the terms of the GNU General Public License
21 version 2 as amended with additional clauses defined in the
22 file LICENSE in the main source directory.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 the file LICENSE for additional details.
35 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
37 /* External subroutines */
38 extern void free_config_resources();
40 /* Exported variables */
43 int bsize = TAPE_BSIZE;
44 char VolName[MAX_NAME_LENGTH];
45 STORES *me = NULL; /* our Global resource */
46 bool forge_on = false; /* proceed inspite of I/O errors */
47 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
48 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
51 * If you change the format of the state file,
52 * increment this value
54 static uint32_t btape_state_level = 2;
58 DEVRES *device = NULL;
61 /* Forward referenced subroutines */
62 static void do_tape_cmds();
63 static void helpcmd();
64 static void scancmd();
65 static void rewindcmd();
66 static void clearcmd();
70 static void fillcmd();
71 static void qfillcmd();
72 static void statcmd();
73 static void unfillcmd();
74 static int flush_block(DEV_BLOCK *block, int dump);
75 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
76 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
77 static bool my_mount_next_read_volume(DCR *dcr);
78 static void scan_blocks();
79 static void set_volume_name(const char *VolName, int volnum);
80 static void rawfill_cmd();
81 static void bfill_cmd();
82 static bool open_the_device();
83 static void autochangercmd();
84 static void do_unfill();
87 /* Static variables */
88 #define CONFIG_FILE "bacula-sd.conf"
89 char *configfile = NULL;
91 #define MAX_CMD_ARGS 30
94 static char *argk[MAX_CMD_ARGS];
95 static char *argv[MAX_CMD_ARGS];
98 static int quickie_count = 0;
99 static uint64_t write_count = 0;
100 static BSR *bsr = NULL;
101 static int signals = TRUE;
104 static uint64_t vol_size;
105 static uint64_t VolBytes;
108 static int32_t file_index;
109 static int end_of_tape = 0;
110 static uint32_t LastBlock = 0;
111 static uint32_t eot_block;
112 static uint32_t eot_block_len;
113 static uint32_t eot_FileIndex;
114 static int dumped = 0;
115 static DEV_BLOCK *last_block1 = NULL;
116 static DEV_BLOCK *last_block2 = NULL;
117 static DEV_BLOCK *last_block = NULL;
118 static DEV_BLOCK *this_block = NULL;
119 static DEV_BLOCK *first_block = NULL;
120 static uint32_t last_file1 = 0;
121 static uint32_t last_file2 = 0;
122 static uint32_t last_file = 0;
123 static uint32_t last_block_num1 = 0;
124 static uint32_t last_block_num2 = 0;
125 static uint32_t last_block_num = 0;
126 static uint32_t BlockNumber = 0;
127 static bool simple = true;
129 static const char *VolumeName = NULL;
130 static int vol_num = 0;
132 static JCR *jcr = NULL;
136 static void terminate_btape(int sig);
137 int get_cmd(const char *prompt);
140 /*********************************************************************
142 * Bacula tape testing program
145 int main(int margc, char *margv[])
152 setlocale(LC_ALL, "");
153 bindtextdomain("bacula", LOCALEDIR);
154 textdomain("bacula");
157 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
158 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
159 TAPE_BSIZE, B_DEV_BSIZE);
161 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
162 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
164 if (sizeof(off_t) < 8) {
165 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n"),
169 bsnprintf(buf, sizeof(buf), "%u", x32);
170 i = bsscanf(buf, "%u", &y32);
171 if (i != 1 || x32 != y32) {
172 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
178 bsnprintf(buf, sizeof(buf), "%" llu, x64);
179 i = bsscanf(buf, "%llu", &y64);
180 if (i != 1 || x64 != y64) {
181 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"), i, x64, y64);
185 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
187 working_directory = "/tmp";
188 my_name_is(margc, margv, "btape");
189 init_msg(NULL, NULL);
193 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
195 case 'b': /* bootstrap file */
196 bsr = parse_bsr(NULL, optarg);
197 // dump_bsr(bsr, true);
200 case 'c': /* specify config file */
201 if (configfile != NULL) {
204 configfile = bstrdup(optarg);
207 case 'd': /* set debug level */
208 debug_level = atoi(optarg);
209 if (debug_level <= 0) {
236 cmd = get_pool_memory(PM_FNAME);
237 args = get_pool_memory(PM_FNAME);
240 init_signals(terminate_btape);
243 if (configfile == NULL) {
244 configfile = bstrdup(CONFIG_FILE);
247 daemon_start_time = time(NULL);
249 parse_config(configfile);
252 /* See if we can open a device */
254 Pmsg0(000, _("No archive name specified.\n"));
257 } else if (margc != 1) {
258 Pmsg0(000, _("Improper number of arguments specified.\n"));
263 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
272 if (!open_the_device()) {
276 Dmsg0(200, "Do tape commands\n");
284 static void terminate_btape(int stat)
287 sm_check(__FILE__, __LINE__, false);
291 free_config_resources();
293 free_pool_memory(args);
297 free_pool_memory(cmd);
314 if (debug_level > 10)
315 print_memory_pool_stats();
318 free_block(this_block);
323 close_memory_pool(); /* free memory in pool */
324 term_last_jobs_list();
330 static bool open_the_device()
334 block = new_block(dev);
336 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
337 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
338 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
343 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
344 dev->set_append(); /* put volume in append mode */
357 * Write a label to the tape
359 static void labelcmd()
362 pm_strcpy(cmd, VolumeName);
364 if (!get_cmd(_("Enter Volume Name: "))) {
369 if (!dev->is_open()) {
370 if (!first_open_device(dcr)) {
371 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
375 write_new_volume_label_to_dev(dcr, cmd, "Default");
376 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
380 * Read the tape label
382 static void readlabelcmd()
384 int save_debug_level = debug_level;
387 stat = read_dev_volume_label(dcr);
390 Pmsg0(0, _("Volume has no label.\n"));
393 Pmsg0(0, _("Volume label read correctly.\n"));
396 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
399 Pmsg0(0, _("Volume name error\n"));
401 case VOL_CREATE_ERROR:
402 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
404 case VOL_VERSION_ERROR:
405 Pmsg0(0, _("Volume version error.\n"));
407 case VOL_LABEL_ERROR:
408 Pmsg0(0, _("Bad Volume label type.\n"));
411 Pmsg0(0, _("Unknown error.\n"));
416 dump_volume_label(dev);
417 debug_level = save_debug_level;
422 * Load the tape should have prevously been taken
423 * off line, otherwise this command is not necessary.
425 static void loadcmd()
428 if (!load_dev(dev)) {
429 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
431 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
437 static void rewindcmd()
439 if (!dev->rewind(dcr)) {
440 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
443 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
448 * Clear any tape error
450 static void clearcmd()
456 * Write and end of file on the tape
458 static void weofcmd()
468 if (!dev->weof(num)) {
469 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
473 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
476 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
482 /* Go to the end of the medium -- raw command
483 * The idea was orginally that the end of the Bacula
484 * medium would be flagged differently. This is not
485 * currently the case. So, this is identical to the
491 Pmsg1(0, "%s", dev->bstrerror());
494 Pmsg0(0, _("Moved to end of medium.\n"));
499 * Go to the end of the medium (either hardware determined
500 * or defined by two eofs.
520 if (!dev->bsf(num)) {
521 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
523 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
539 if (!dev->bsr(num)) {
540 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
542 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
547 * List device capabilities as defined in the
552 printf(_("Configured device capabilities:\n"));
553 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
554 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
555 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
556 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
557 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
558 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
559 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
560 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
561 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
562 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
563 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
564 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
565 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
566 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
567 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
570 printf(_("Device status:\n"));
571 printf("%sOPENED ", dev->is_open() ? "" : "!");
572 printf("%sTAPE ", dev->is_tape() ? "" : "!");
573 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
574 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
575 printf("%sAPPEND ", dev->can_append() ? "" : "!");
576 printf("%sREAD ", dev->can_read() ? "" : "!");
577 printf("%sEOT ", dev->at_eot() ? "" : "!");
578 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
579 printf("%sEOF ", dev->at_eof() ? "" : "!");
580 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
581 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
584 printf(_("Device parameters:\n"));
585 printf("Device name: %s\n", dev->dev_name);
586 printf("File=%u block=%u\n", dev->file, dev->block_num);
587 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
589 printf(_("Status:\n"));
595 * Test writting larger and larger records.
596 * This is a torture test for records.
598 static void rectestcmd()
604 Pmsg0(0, _("Test writting larger and larger records.\n"
605 "This is a torture test for records.\nI am going to write\n"
606 "larger and larger records. It will stop when the record size\n"
607 "plus the header exceeds the block size (by default about 64K)\n"));
610 get_cmd(_("Do you want to continue? (y/n): "));
612 Pmsg0(000, _("Command aborted.\n"));
616 sm_check(__FILE__, __LINE__, false);
617 block = new_block(dev);
620 for (i=1; i<500000; i++) {
621 rec->data = check_pool_memory_size(rec->data, i);
622 memset(rec->data, i & 0xFF, i);
624 sm_check(__FILE__, __LINE__, false);
625 if (write_record_to_block(block, rec)) {
628 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
632 sm_check(__FILE__, __LINE__, false);
636 sm_check(__FILE__, __LINE__, false);
640 * This test attempts to re-read a block written by Bacula
641 * normally at the end of the tape. Bacula will then back up
642 * over the two eof marks, backup over the record and reread
643 * it to make sure it is valid. Bacula can skip this validation
644 * if you set "Backward space record = no"
646 static int re_read_block_test()
648 DEV_BLOCK *block = dcr->block;
653 if (!(dev->capabilities & CAP_BSR)) {
654 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
658 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
659 "I'm going to write three records and an EOF\n"
660 "then backup over the EOF and re-read the last record.\n"
661 "Bacula does this after writing the last block on the\n"
662 "tape to verify that the block was written correctly.\n\n"
663 "This is not an *essential* feature ...\n\n"));
667 rec->data = check_pool_memory_size(rec->data, block->buf_len);
668 len = rec->data_len = block->buf_len-100;
669 memset(rec->data, 1, rec->data_len);
670 if (!write_record_to_block(block, rec)) {
671 Pmsg0(0, _("Error writing record to block.\n"));
674 if (!write_block_to_dev(dcr)) {
675 Pmsg0(0, _("Error writing block to device.\n"));
678 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
680 memset(rec->data, 2, rec->data_len);
681 if (!write_record_to_block(block, rec)) {
682 Pmsg0(0, _("Error writing record to block.\n"));
685 if (!write_block_to_dev(dcr)) {
686 Pmsg0(0, _("Error writing block to device.\n"));
689 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
691 memset(rec->data, 3, rec->data_len);
692 if (!write_record_to_block(block, rec)) {
693 Pmsg0(0, _("Error writing record to block.\n"));
696 if (!write_block_to_dev(dcr)) {
697 Pmsg0(0, _("Error writing block to device.\n"));
700 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
703 if (dev_cap(dev, CAP_TWOEOF)) {
707 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
710 if (dev_cap(dev, CAP_TWOEOF)) {
712 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
716 Pmsg0(0, _("Backspaced over EOF OK.\n"));
718 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
721 Pmsg0(0, _("Backspace record OK.\n"));
722 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
724 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
727 memset(rec->data, 0, rec->data_len);
728 if (!read_record_from_block(block, rec)) {
730 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
733 for (int i=0; i<len; i++) {
734 if (rec->data[i] != 3) {
735 Pmsg0(0, _("Bad data in record. Test failed!\n"));
739 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
740 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
747 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
748 "this function to verify the last block written to the\n"
749 "tape. Bacula will skip the last block verification\n"
751 "Backward Space Record = No\n\n"
752 "to your Storage daemon's Device resource definition.\n"));
759 * This test writes Bacula blocks to the tape in
760 * several files. It then rewinds the tape and attepts
761 * to read these blocks back checking the data.
763 static int write_read_test()
771 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
772 "I'm going to write 1000 records and an EOF\n"
773 "then write 1000 records and an EOF, then rewind,\n"
774 "and re-read the data to verify that it is correct.\n\n"
775 "This is an *essential* feature ...\n\n"));
778 if (!dev->rewind(dcr)) {
779 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
782 rec->data = check_pool_memory_size(rec->data, block->buf_len);
783 rec->data_len = block->buf_len-100;
784 len = rec->data_len/sizeof(i);
785 for (i=1; i<=1000; i++) {
786 p = (int *)rec->data;
787 for (j=0; j<len; j++) {
790 if (!write_record_to_block(block, rec)) {
791 Pmsg0(0, _("Error writing record to block.\n"));
794 if (!write_block_to_dev(dcr)) {
795 Pmsg0(0, _("Error writing block to device.\n"));
799 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
801 for (i=1001; i<=2000; i++) {
802 p = (int *)rec->data;
803 for (j=0; j<len; j++) {
806 if (!write_record_to_block(block, rec)) {
807 Pmsg0(0, _("Error writing record to block.\n"));
810 if (!write_block_to_dev(dcr)) {
811 Pmsg0(0, _("Error writing block to device.\n"));
815 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
817 if (dev_cap(dev, CAP_TWOEOF)) {
820 if (!dev->rewind(dcr)) {
821 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
824 Pmsg0(0, _("Rewind OK.\n"));
826 for (i=1; i<=2000; i++) {
828 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
830 if (dev_state(dev, ST_EOF)) {
831 Pmsg0(-1, _("Got EOF on tape.\n"));
836 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
839 memset(rec->data, 0, rec->data_len);
840 if (!read_record_from_block(block, rec)) {
842 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
845 p = (int *)rec->data;
846 for (j=0; j<len; j++) {
848 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
854 if (i == 1000 || i == 2000) {
855 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
858 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
867 * This test writes Bacula blocks to the tape in
868 * several files. It then rewinds the tape and attepts
869 * to read these blocks back checking the data.
871 static int position_test()
873 DEV_BLOCK *block = dcr->block;
879 int file = 0, blk = 0;
881 bool got_eof = false;
883 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
884 "I'm going to write 1000 records and an EOF\n"
885 "then write 1000 records and an EOF, then rewind,\n"
886 "and position to a few blocks and verify that it is correct.\n\n"
887 "This is an *essential* feature ...\n\n"));
890 if (!dev->rewind(dcr)) {
891 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
894 rec->data = check_pool_memory_size(rec->data, block->buf_len);
895 rec->data_len = block->buf_len-100;
896 len = rec->data_len/sizeof(i);
897 for (i=1; i<=1000; i++) {
898 p = (int *)rec->data;
899 for (j=0; j<len; j++) {
902 if (!write_record_to_block(block, rec)) {
903 Pmsg0(0, _("Error writing record to block.\n"));
906 if (!write_block_to_dev(dcr)) {
907 Pmsg0(0, _("Error writing block to device.\n"));
911 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
913 for (i=1001; i<=2000; i++) {
914 p = (int *)rec->data;
915 for (j=0; j<len; j++) {
918 if (!write_record_to_block(block, rec)) {
919 Pmsg0(0, _("Error writing record to block.\n"));
922 if (!write_block_to_dev(dcr)) {
923 Pmsg0(0, _("Error writing block to device.\n"));
927 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
929 if (dev_cap(dev, CAP_TWOEOF)) {
932 if (!dev->rewind(dcr)) {
933 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
936 Pmsg0(0, _("Rewind OK.\n"));
940 /* Set up next item to read based on where we are */
976 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
977 if (!dev->reposition(file, blk)) {
978 Pmsg0(0, _("Reposition error.\n"));
982 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
984 if (dev_state(dev, ST_EOF)) {
985 Pmsg0(-1, _("Got EOF on tape.\n"));
991 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
992 recno, file, blk, be.strerror(dev->dev_errno));
993 Pmsg0(0, _("This may be because the tape drive block size is not\n"
994 " set to variable blocking as normally used by Bacula.\n"
995 " Please see the Tape Testing chapter in the manual and \n"
996 " look for using mt with defblksize and setoptions\n"
997 "If your tape drive block size is correct, then perhaps\n"
998 " your SCSI driver is *really* stupid and does not\n"
999 " correctly report the file:block after a FSF. In this\n"
1000 " case try setting:\n"
1001 " Fast Forward Space File = no\n"
1002 " in your Device resource.\n"));
1006 memset(rec->data, 0, rec->data_len);
1007 if (!read_record_from_block(block, rec)) {
1009 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1012 p = (int *)rec->data;
1013 for (j=0; j<len; j++) {
1014 if (p[j] != recno) {
1015 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1020 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1022 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1034 * This test writes some records, then writes an end of file,
1035 * rewinds the tape, moves to the end of the data and attepts
1036 * to append to the tape. This function is essential for
1037 * Bacula to be able to write multiple jobs to the tape.
1039 static int append_test()
1041 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1042 "This test is essential to Bacula.\n\n"
1043 "I'm going to write one record in file 0,\n"
1044 " two records in file 1,\n"
1045 " and three records in file 2\n\n"));
1049 weofcmd(); /* end file 0 */
1052 weofcmd(); /* end file 1 */
1056 weofcmd(); /* end file 2 */
1057 if (dev_cap(dev, CAP_TWOEOF)) {
1060 dev->close(); /* release device */
1061 if (!open_the_device()) {
1065 Pmsg0(0, _("Now moving to end of medium.\n"));
1067 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1068 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1070 if (dev->file != 3) {
1074 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1077 if (dev_cap(dev, CAP_TWOEOF)) {
1081 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1082 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1084 Pmsg0(-1, _("End scanning the tape.\n"));
1085 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1086 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1088 if (dev->file != 4) {
1096 * This test exercises the autochanger
1098 static int autochanger_test()
1100 POOLMEM *results, *changer;
1101 int slot, status, loaded;
1102 int timeout = dcr->device->max_changer_wait;
1105 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1106 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1109 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1110 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1114 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1115 "To test the autochanger you must have a blank tape\n"
1116 " that I can write on in Slot 1.\n"));
1117 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1120 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1124 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1126 results = get_pool_memory(PM_MESSAGE);
1127 changer = get_pool_memory(PM_FNAME);
1131 dcr->VolCatInfo.Slot = slot;
1132 /* Find out what is loaded, zero means device is unloaded */
1133 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1134 changer = edit_device_codes(dcr, changer,
1135 dcr->device->changer_command, "loaded");
1136 status = run_program(changer, timeout, results);
1137 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1139 loaded = atoi(results);
1142 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1143 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1147 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1149 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1151 Dmsg1(100, "Results from loaded query=%s\n", results);
1153 dcr->VolCatInfo.Slot = loaded;
1154 /* We are going to load a new tape, so close the device */
1156 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1157 loaded, dev->drive_index);
1158 changer = edit_device_codes(dcr, changer,
1159 dcr->device->changer_command, "unload");
1160 status = run_program(changer, timeout, results);
1161 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1164 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1165 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1174 dcr->VolCatInfo.Slot = slot;
1175 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1176 slot, dev->drive_index);
1177 changer = edit_device_codes(dcr, changer,
1178 dcr->device->changer_command, "load");
1179 Dmsg1(100, "Changer=%s\n", changer);
1181 status = run_program(changer, timeout, results);
1183 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1184 slot, dev->drive_index);
1187 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1188 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1192 if (!open_the_device()) {
1196 * Start with sleep_time 0 then increment by 30 seconds if we get
1199 bmicrosleep(sleep_time, 0);
1200 if (!dev->rewind(dcr) || !dev->weof(1)) {
1201 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1203 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1204 "a longer sleep time in the mtx-script in the load) case.\n"
1205 "Adding a 30 second sleep and trying again ...\n"));
1209 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1212 if (!dev->weof(1)) {
1213 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1216 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1220 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1222 "to your mtx-changer script in the load) case.\n\n"),
1225 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1228 free_pool_memory(changer);
1229 free_pool_memory(results);
1234 free_pool_memory(changer);
1235 free_pool_memory(results);
1236 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1240 static void autochangercmd()
1247 * This test assumes that the append test has been done,
1248 * then it tests the fsf function.
1250 static int fsf_test()
1252 bool set_off = false;
1254 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1255 "This test is essential to Bacula.\n\n"
1256 "I'm going to write five files then test forward spacing\n\n"));
1260 weofcmd(); /* end file 0 */
1263 weofcmd(); /* end file 1 */
1267 weofcmd(); /* end file 2 */
1270 weofcmd(); /* end file 3 */
1272 weofcmd(); /* end file 4 */
1273 if (dev_cap(dev, CAP_TWOEOF)) {
1279 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1281 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1284 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1285 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1287 if (dev->file != 1) {
1291 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1293 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1296 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1297 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1299 if (dev->file != 3) {
1304 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1306 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1309 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1310 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1312 if (dev->file != 4) {
1316 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1317 " Fast Forward Space File = no\n\n"
1318 "to your Device resource for this drive.\n"));
1322 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1324 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1326 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1327 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1328 if (dev->file != 5) {
1331 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1335 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1336 if (dev_cap(dev, CAP_FASTFSF)) {
1337 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1338 "I am turning it off then retrying the test.\n"));
1339 dev->capabilities &= ~CAP_FASTFSF;
1343 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1344 "Some systems, e.g. OpenBSD, require you to set\n"
1345 " Use MTIOCGET= no\n"
1346 "in your device resource. Use with caution.\n"));
1355 * This is a general test of Bacula's functions
1356 * needed to read and write the tape.
1358 static void testcmd()
1362 if (!write_read_test()) {
1365 if (!position_test()) {
1369 stat = append_test();
1370 if (stat == 1) { /* OK get out */
1373 if (stat == -1) { /* first test failed */
1374 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1375 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1376 "Setting \"Hardware End of Medium = no\n"
1377 " and \"Fast Forward Space File = no\n"
1378 "and retrying append test.\n\n"));
1379 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1380 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1381 stat = append_test();
1383 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1384 " Hardware End of Medium = No\n\n"
1385 " Fast Forward Space File = No\n"
1386 "to your Device resource in the Storage conf file.\n"));
1390 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1393 /* Wrong count after append */
1395 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1396 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1397 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1398 stat = append_test();
1400 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1401 " Hardware End of Medium = No\n"
1402 " Fast Forward Space File = No\n"
1403 " BSF at EOM = yes\n\n"
1404 "to your Device resource in the Storage conf file.\n"));
1411 Pmsg0(-1, _("\nAppend test failed.\n\n"
1412 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1413 "Unable to correct the problem. You MUST fix this\n"
1414 "problem before Bacula can use your tape drive correctly\n"
1415 "\nPerhaps running Bacula in fixed block mode will work.\n"
1416 "Do so by setting:\n\n"
1417 "Minimum Block Size = nnn\n"
1418 "Maximum Block Size = nnn\n\n"
1419 "in your Storage daemon's Device definition.\n"
1420 "nnn must match your tape driver's block size, which\n"
1421 "can be determined by reading your tape manufacturers\n"
1422 "information, and the information on your kernel dirver.\n"
1423 "Fixed block sizes, however, are not normally an ideal solution.\n"
1425 "Some systems, e.g. OpenBSD, require you to set\n"
1426 " Use MTIOCGET= no\n"
1427 "in your device resource. Use with caution.\n"));
1432 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1433 "Please double check it ...\n"
1434 "=== Sample correct output ===\n"
1435 "1 block of 64448 bytes in file 1\n"
1436 "End of File mark.\n"
1437 "2 blocks of 64448 bytes in file 2\n"
1438 "End of File mark.\n"
1439 "3 blocks of 64448 bytes in file 3\n"
1440 "End of File mark.\n"
1441 "1 block of 64448 bytes in file 4\n"
1442 "End of File mark.\n"
1443 "Total files=4, blocks=7, bytes = 451,136\n"
1444 "=== End sample correct output ===\n\n"
1445 "If the above scan output is not identical to the\n"
1446 "sample output, you MUST correct the problem\n"
1447 "or Bacula will not be able to write multiple Jobs to \n"
1451 re_read_block_test();
1454 fsf_test(); /* do fast forward space file test */
1456 autochanger_test(); /* do autochanger test */
1460 /* Forward space a file */
1461 static void fsfcmd()
1465 num = atoi(argk[1]);
1470 if (!dev->fsf(num)) {
1471 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1475 Pmsg0(0, _("Forward spaced 1 file.\n"));
1478 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1482 /* Forward space a record */
1483 static void fsrcmd()
1487 num = atoi(argk[1]);
1492 if (!dev->fsr(num)) {
1493 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1497 Pmsg0(0, _("Forward spaced 1 record.\n"));
1500 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1506 * Write a Bacula block to the tape
1510 DEV_BLOCK *block = dcr->block;
1511 DEV_RECORD *rec = dcr->rec;
1514 sm_check(__FILE__, __LINE__, false);
1517 dump_block(block, "test");
1520 i = block->buf_len - 100;
1522 rec->data = check_pool_memory_size(rec->data, i);
1523 memset(rec->data, i & 0xFF, i);
1525 sm_check(__FILE__, __LINE__, false);
1526 if (!write_record_to_block(block, rec)) {
1527 Pmsg0(0, _("Error writing record to block.\n"));
1530 if (!write_block_to_dev(dcr)) {
1531 Pmsg0(0, _("Error writing block to device.\n"));
1534 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1536 Pmsg0(0, _("Wrote block to device.\n"));
1539 sm_check(__FILE__, __LINE__, false);
1540 sm_check(__FILE__, __LINE__, false);
1544 * Read a record from the tape
1551 if (!get_cmd(_("Enter length to read: "))) {
1555 if (len < 0 || len > 1000000) {
1556 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1559 buf = (char *)malloc(len);
1560 stat = read(dev->fd, buf, len);
1561 if (stat > 0 && stat <= len) {
1565 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1566 len, stat, be.strerror());
1572 * Scan tape by reading block by block. Report what is
1573 * on the tape. Note, this command does raw reads, and as such
1574 * will not work with fixed block size devices.
1576 static void scancmd()
1579 int blocks, tot_blocks, tot_files;
1585 blocks = block_size = tot_blocks = 0;
1587 if (dev->state & ST_EOT) {
1588 Pmsg0(0, _("End of tape\n"));
1591 update_pos_dev(dev);
1592 tot_files = dev->file;
1593 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1595 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1598 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1599 dev->dev_name, be.strerror());
1600 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1603 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1606 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1611 Dmsg1(200, "read status = %d\n", stat);
1613 if (stat != block_size) {
1614 update_pos_dev(dev);
1617 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1620 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1626 if (stat == 0) { /* EOF */
1627 update_pos_dev(dev);
1628 printf(_("End of File mark.\n"));
1629 /* Two reads of zero means end of tape */
1630 if (dev->state & ST_EOF)
1631 dev->state |= ST_EOT;
1633 dev->state |= ST_EOF;
1636 if (dev->state & ST_EOT) {
1637 printf(_("End of tape\n"));
1640 } else { /* Got data */
1641 dev->state &= ~ST_EOF;
1647 update_pos_dev(dev);
1648 tot_files = dev->file - tot_files;
1649 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1650 edit_uint64_with_commas(bytes, ec1));
1655 * Scan tape by reading Bacula block by block. Report what is
1656 * on the tape. This function reads Bacula blocks, so if your
1657 * Device resource is correctly defined, it should work with
1658 * either variable or fixed block sizes.
1660 static void scan_blocks()
1662 int blocks, tot_blocks, tot_files;
1663 uint32_t block_size;
1665 DEV_BLOCK *block = dcr->block;
1667 char buf1[100], buf2[100];
1669 blocks = block_size = tot_blocks = 0;
1673 update_pos_dev(dev);
1674 tot_files = dev->file;
1676 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1677 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1678 if (dev->state & ST_EOT) {
1681 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1684 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1690 if (dev->state & ST_EOF) {
1693 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1696 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1700 printf(_("End of File mark.\n"));
1703 if (dev->state & ST_SHORT) {
1706 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1709 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1713 printf(_("Short block read.\n"));
1716 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1719 if (block->block_len != block_size) {
1722 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1725 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1729 block_size = block->block_len;
1733 bytes += block->block_len;
1734 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1735 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1736 block->VolSessionId, block->VolSessionTime);
1738 DEV_RECORD *rec = new_record();
1739 read_record_from_block(block, rec);
1740 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1741 block->BlockNumber, dev->block_num, block->block_len,
1742 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1743 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1746 } else if (verbose > 1) {
1747 dump_block(block, "");
1752 tot_files = dev->file - tot_files;
1753 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1754 edit_uint64_with_commas(bytes, ec1));
1758 static void statcmd()
1760 int debug = debug_level;
1762 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1764 dump_volume_label(dev);
1766 debug_level = debug;
1771 * First we label the tape, then we fill
1772 * it with data get a new tape and write a few blocks.
1774 static void fillcmd()
1777 DEV_BLOCK *block = dcr->block;
1779 char buf1[100], buf2[100];
1782 uint32_t min_block_size;
1793 "This command simulates Bacula writing to a tape.\n"
1794 "It requires either one or two blank tapes, which it\n"
1795 "will label and write.\n\n"
1796 "If you have an autochanger configured, it will use\n"
1797 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1798 "be prompted to insert the tapes when necessary.\n\n"
1799 "It will print a status approximately\n"
1800 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1801 "selected the simple test option, after writing the first tape\n"
1802 "it will rewind it and re-read the last block written.\n\n"
1803 "If you have selected the multiple tape test, when the first tape\n"
1804 "fills, it will ask for a second, and after writing a few more \n"
1805 "blocks, it will stop. Then it will begin re-reading the\n"
1807 "This may take a long time -- hours! ...\n\n"));
1809 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1810 "or the complete multiple tape (m) test: (s/m) "));
1811 if (cmd[0] == 's') {
1812 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1814 } else if (cmd[0] == 'm') {
1815 Pmsg0(-1, _("Multiple tape test selected.\n"));
1818 Pmsg0(000, _("Command aborted.\n"));
1822 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1823 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1825 /* Use fixed block size to simplify read back */
1826 min_block_size = dev->min_block_size;
1827 dev->min_block_size = dev->max_block_size;
1828 set_volume_name("TestVolume1", 1);
1830 if (!dev->rewind(dcr)) {
1831 Pmsg0(000, _("Rewind failed.\n"));
1833 if (!dev->weof(1)) {
1834 Pmsg0(000, _("Write EOF failed.\n"));
1837 dev->set_append(); /* force volume to be relabeled */
1840 * Acquire output device for writing. Note, after acquiring a
1841 * device, we MUST release it, which is done at the end of this
1844 Dmsg0(100, "just before acquire_device\n");
1845 if (!acquire_device_for_append(dcr)) {
1846 set_jcr_job_status(jcr, JS_ErrorTerminated);
1849 block = jcr->dcr->block;
1851 Dmsg0(100, "Just after acquire_device_for_append\n");
1853 * Write Begin Session Record
1855 if (!write_session_label(dcr, SOS_LABEL)) {
1856 set_jcr_job_status(jcr, JS_ErrorTerminated);
1857 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1861 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1863 memset(&rec, 0, sizeof(rec));
1864 rec.data = get_memory(100000); /* max record size */
1866 #define REC_SIZE 32768
1867 rec.data_len = REC_SIZE;
1870 * Put some random data in the record
1872 fd = open("/dev/urandom", O_RDONLY);
1874 read(fd, rec.data, rec.data_len);
1877 uint32_t *p = (uint32_t *)rec.data;
1878 srandom(time(NULL));
1879 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1885 * Generate data as if from File daemon, write to device
1887 jcr->dcr->VolFirstIndex = 0;
1888 time(&jcr->run_time); /* start counting time for rates */
1889 (void)localtime_r(&jcr->run_time, &tm);
1890 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1892 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1894 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1896 for (file_index = 0; ok && !job_canceled(jcr); ) {
1897 rec.VolSessionId = jcr->VolSessionId;
1898 rec.VolSessionTime = jcr->VolSessionTime;
1899 rec.FileIndex = ++file_index;
1900 rec.Stream = STREAM_FILE_DATA;
1902 /* Mix up the data just a bit */
1903 uint32_t *lp = (uint32_t *)rec.data;
1905 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1909 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1910 rec.FileIndex, rec.VolSessionId,
1911 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1914 while (!write_record_to_block(block, &rec)) {
1916 * When we get here we have just filled a block
1918 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1921 /* Write block to tape */
1922 if (!flush_block(block, 1)) {
1926 /* Every 5000 blocks (approx 322MB) report where we are.
1928 if ((block->BlockNumber % 5000) == 0) {
1930 now -= jcr->run_time;
1932 now = 1; /* prevent divide error */
1934 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1935 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1936 block->BlockNumber, dev->block_num,
1937 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1939 /* Every 32000 blocks (approx 2GB) write an EOF.
1941 if ((block->BlockNumber % 32000) == 0) {
1943 (void)localtime_r(&now, &tm);
1944 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1945 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1946 flush_block(block, 0);
1950 /* Get out after writing 10 blocks to the second tape */
1951 if (++BlockNumber > 10 && stop != 0) { /* get out */
1956 Pmsg0(000, _("Not OK\n"));
1959 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1960 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1961 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1962 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1964 /* Get out after writing 10 blocks to the second tape */
1965 if (BlockNumber > 10 && stop != 0) { /* get out */
1967 Pmsg1(-1, "Done writing %s records ...\n",
1968 edit_uint64_with_commas(write_count, ed1));
1973 Dmsg0(100, "Write_end_session_label()\n");
1974 /* Create Job status for end of session label */
1975 if (!job_canceled(jcr) && ok) {
1976 set_jcr_job_status(jcr, JS_Terminated);
1978 set_jcr_job_status(jcr, JS_ErrorTerminated);
1980 if (!write_session_label(dcr, EOS_LABEL)) {
1981 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
1984 /* Write out final block of this session */
1985 if (!write_block_to_device(dcr)) {
1986 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1989 Pmsg0(-1, _("Wrote End of Session label.\n"));
1991 /* Save last block info for second tape */
1992 last_block_num2 = last_block_num;
1993 last_file2 = last_file;
1995 free_block(last_block2);
1997 last_block2 = dup_block(last_block);
2000 sprintf(buf, "%s/btape.state", working_directory);
2001 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2003 write(fd, &btape_state_level, sizeof(btape_state_level));
2004 write(fd, &simple, sizeof(simple));
2005 write(fd, &last_block_num1, sizeof(last_block_num1));
2006 write(fd, &last_block_num2, sizeof(last_block_num2));
2007 write(fd, &last_file1, sizeof(last_file1));
2008 write(fd, &last_file2, sizeof(last_file2));
2009 write(fd, last_block1->buf, last_block1->buf_len);
2010 write(fd, last_block2->buf, last_block2->buf_len);
2011 write(fd, first_block->buf, first_block->buf_len);
2013 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2014 last_block_num1, last_block_num2);
2017 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2022 (void)localtime_r(&now, &tm);
2023 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2025 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2026 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2029 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2030 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2033 jcr->dcr->block = block;
2036 dev->min_block_size = min_block_size;
2037 free_memory(rec.data);
2041 * Read two tapes written by the "fill" command and ensure
2042 * that the data is valid. If stop==1 we simulate full read back
2043 * of two tapes. If stop==-1 we simply read the last block and
2044 * verify that it is correct.
2046 static void unfillcmd()
2050 last_block1 = new_block(dev);
2051 last_block2 = new_block(dev);
2052 first_block = new_block(dev);
2053 sprintf(buf, "%s/btape.state", working_directory);
2054 fd = open(buf, O_RDONLY);
2056 uint32_t state_level;
2057 read(fd, &state_level, sizeof(btape_state_level));
2058 read(fd, &simple, sizeof(simple));
2059 read(fd, &last_block_num1, sizeof(last_block_num1));
2060 read(fd, &last_block_num2, sizeof(last_block_num2));
2061 read(fd, &last_file1, sizeof(last_file1));
2062 read(fd, &last_file2, sizeof(last_file2));
2063 read(fd, last_block1->buf, last_block1->buf_len);
2064 read(fd, last_block2->buf, last_block2->buf_len);
2065 read(fd, first_block->buf, first_block->buf_len);
2067 if (state_level != btape_state_level) {
2068 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2069 "the fill command.\n"));
2074 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2075 "You must redo the fill command.\n"), buf, be.strerror());
2082 static void do_unfill()
2084 DEV_BLOCK *block = dcr->block;
2091 Dmsg0(20, "Enter do_unfill\n");
2092 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2093 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2097 time(&jcr->run_time); /* start counting time for rates */
2101 free_block(last_block);
2104 last_block_num = last_block_num1;
2105 last_file = last_file1;
2106 last_block = last_block1;
2109 /* Multiple Volume tape */
2110 /* Close device so user can use autochanger if desired */
2111 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2114 autochanger = autoload_device(dcr, 1, NULL);
2117 get_cmd(_("Mount first tape. Press enter when ready: "));
2121 free_restore_volume_list(jcr);
2122 jcr->dcr = new_dcr(jcr, dev);
2123 set_volume_name("TestVolume1", 1);
2125 create_restore_volume_list(jcr);
2127 dev->num_writers = 0;
2128 if (!acquire_device_for_read(dcr)) {
2129 Pmsg1(-1, "%s", dev->errmsg);
2133 * We now have the first tape mounted.
2134 * Note, re-reading last block may have caused us to
2135 * loose track of where we are (block number unknown).
2137 Pmsg0(-1, _("Rewinding.\n"));
2138 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2141 /* Read the first 10000 records */
2142 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2143 dev->file, dev->block_num);
2145 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2146 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2147 last_file, last_block_num);
2148 if (!dev->reposition(last_file, last_block_num)) {
2149 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2152 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2153 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2154 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2157 if (compare_blocks(last_block, block)) {
2159 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2161 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2168 /* restore info for last block on second Volume */
2169 last_block_num = last_block_num2;
2170 last_file = last_file2;
2171 last_block = last_block2;
2173 /* Multiple Volume tape */
2174 /* Close device so user can use autochanger if desired */
2175 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2179 free_restore_volume_list(jcr);
2180 set_volume_name("TestVolume2", 2);
2182 create_restore_volume_list(jcr);
2183 autochanger = autoload_device(dcr, 1, NULL);
2186 get_cmd(_("Mount second tape. Press enter when ready: "));
2190 if (!acquire_device_for_read(dcr)) {
2191 Pmsg1(-1, "%s", dev->errmsg);
2195 /* Space to "first" block which is last block not written
2196 * on the previous tape.
2198 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2199 if (!dev->reposition(0, 1)) {
2200 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2203 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2204 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2205 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2208 if (compare_blocks(first_block, block)) {
2209 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2212 /* Now find and compare the last block */
2213 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2214 last_file, last_block_num);
2215 if (!dev->reposition(last_file, last_block_num)) {
2216 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2219 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2220 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2221 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2224 if (compare_blocks(last_block, block)) {
2225 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2229 free_block(last_block1);
2230 free_block(last_block2);
2231 free_block(first_block);
2234 /* Read 10000 records then stop */
2235 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2237 DEVICE *dev = dcr->dev;
2239 if (quickie_count == 10000) {
2240 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2242 return quickie_count < 10000;
2245 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2248 uint32_t CheckSum, block_len;
2251 p = last_block->buf;
2253 unser_begin(q, BLKHDR2_LENGTH);
2254 unser_uint32(CheckSum);
2255 unser_uint32(block_len);
2256 while (q < (block->buf+block_len)) {
2263 dump_block(last_block, _("Last block written"));
2265 dump_block(block, _("Block read back"));
2266 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2267 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2268 "that was read back differ. The test FAILED !!!!\n"
2269 "This must be corrected before you use Bacula\n"
2270 "to write multi-tape Volumes.!!!!\n"));
2274 dump_block(last_block, _("Last block written"));
2275 dump_block(block, _("Block read back"));
2285 * Write current block to tape regardless of whether or
2286 * not it is full. If the tape fills, attempt to
2287 * acquire another tape.
2289 static int flush_block(DEV_BLOCK *block, int dump)
2293 uint32_t this_file, this_block_num;
2297 this_block = new_block(dev);
2300 last_block = new_block(dev);
2303 this_file = dev->file;
2304 this_block_num = dev->block_num;
2305 if (!write_block_to_dev(dcr)) {
2306 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2307 last_file, last_block_num, this_block_num);
2310 * This is 1st tape, so save first tape info separate
2311 * from second tape info
2313 last_block_num1 = last_block_num;
2314 last_file1 = last_file;
2315 last_block1 = dup_block(last_block);
2316 last_block2 = dup_block(last_block);
2317 first_block = dup_block(block); /* first block second tape */
2320 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2321 (unsigned)file_index, block->BlockNumber, block->block_len);
2322 dump_block(last_block, _("Last block written"));
2324 dump_block(block, _("Block not written"));
2327 eot_block = block->BlockNumber;
2328 eot_block_len = block->block_len;
2329 eot_FileIndex = file_index;
2333 now -= jcr->run_time;
2335 now = 1; /* don't divide by zero */
2337 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2338 vol_size = dev->VolCatInfo.VolCatBytes;
2339 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2340 dev->file, dev->block_num,
2341 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2344 stop = -1; /* stop, but do simplified test */
2346 /* Full test in progress */
2347 if (!fixup_device_block_write_error(jcr->dcr)) {
2348 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2353 BlockNumber = 0; /* start counting for second tape */
2356 return 1; /* end of tape reached */
2359 /* Save contents after write so that the header is serialized */
2360 memcpy(this_block->buf, block->buf, this_block->buf_len);
2363 * Note, we always read/write to block, but we toggle
2364 * copying it to one or another of two allocated blocks.
2365 * Switch blocks so that the block just successfully written is
2366 * always in last_block.
2368 tblock = last_block;
2369 last_block = this_block;
2370 this_block = tblock;
2371 last_file = this_file;
2372 last_block_num = this_block_num;
2380 * First we label the tape, then we fill
2381 * it with data get a new tape and write a few blocks.
2383 static void qfillcmd()
2385 DEV_BLOCK *block = dcr->block;
2386 DEV_RECORD *rec = dcr->rec;
2389 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2391 get_cmd(_("How many blocks do you want to write? (1000): "));
2398 sm_check(__FILE__, __LINE__, false);
2400 i = block->buf_len - 100;
2402 rec->data = check_pool_memory_size(rec->data, i);
2403 memset(rec->data, i & 0xFF, i);
2406 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2407 for (i=0; i < count; i++) {
2412 if (!write_record_to_block(block, rec)) {
2413 Pmsg0(0, _("Error writing record to block.\n"));
2416 if (!write_block_to_dev(dcr)) {
2417 Pmsg0(0, _("Error writing block to device.\n"));
2423 if (dev_cap(dev, CAP_TWOEOF)) {
2430 sm_check(__FILE__, __LINE__, false);
2434 * Fill a tape using raw write() command
2436 static void rawfill_cmd()
2438 DEV_BLOCK *block = dcr->block;
2441 uint32_t block_num = 0;
2446 fd = open("/dev/urandom", O_RDONLY);
2448 read(fd, block->buf, block->buf_len);
2451 uint32_t *p = (uint32_t *)block->buf;
2452 srandom(time(NULL));
2453 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2457 p = (uint32_t *)block->buf;
2458 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2461 if (dev->is_tape()) {
2462 stat = tape_write(dev->fd, block->buf, block->buf_len);
2464 stat = write(dev->fd, block->buf, block->buf_len);
2466 if (stat == (int)block->buf_len) {
2467 if ((block_num++ % 100) == 0) {
2472 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2482 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2483 be.strerror(my_errno));
2489 * Fill a tape using Bacula block writes
2491 static void bfill_cmd()
2493 DEV_BLOCK *block = dcr->block;
2494 uint32_t block_num = 0;
2500 fd = open("/dev/urandom", O_RDONLY);
2502 read(fd, block->buf, block->buf_len);
2505 uint32_t *p = (uint32_t *)block->buf;
2506 srandom(time(NULL));
2507 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2511 p = (uint32_t *)block->buf;
2512 Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2515 block->binbuf = block->buf_len;
2516 block->bufp = block->buf + block->binbuf;
2517 if (!write_block_to_dev(dcr)) {
2520 if ((block_num++ % 100) == 0) {
2525 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2531 printf(_("Write failed at block %u.\n"), block_num);
2536 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2537 static struct cmdstruct commands[] = {
2538 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2539 {NT_("bsf"), bsfcmd, _("backspace file")},
2540 {NT_("bsr"), bsrcmd, _("backspace record")},
2541 {NT_("bfill"), bfill_cmd, _("fill tape using Bacula writes")},
2542 {NT_("cap"), capcmd, _("list device capabilities")},
2543 {NT_("clear"), clearcmd, _("clear tape errors")},
2544 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2545 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2546 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2547 {NT_("unfill"), unfillcmd, _("read filled tape")},
2548 {NT_("fsf"), fsfcmd, _("forward space a file")},
2549 {NT_("fsr"), fsrcmd, _("forward space a record")},
2550 {NT_("help"), helpcmd, _("print this command")},
2551 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2552 {NT_("load"), loadcmd, _("load a tape")},
2553 {NT_("quit"), quitcmd, _("quit btape")},
2554 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2555 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2556 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2557 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2558 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2559 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2560 {NT_("status"), statcmd, _("print tape status")},
2561 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2562 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2563 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2564 {NT_("rr"), rrcmd, _("read a single record")},
2565 {NT_("qfill"), qfillcmd, _("quick fill command")}
2567 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2575 while (get_cmd("*")) {
2576 sm_check(__FILE__, __LINE__, false);
2578 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2579 for (i=0; i<comsize; i++) /* search for command */
2580 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2581 (*commands[i].func)(); /* go execute command */
2586 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2592 static void helpcmd()
2596 printf(_("Interactive commands:\n"));
2597 printf(_(" Command Description\n ======= ===========\n"));
2598 for (i=0; i<comsize; i++)
2599 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2606 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2607 "\nVersion: %s (%s)\n\n"
2608 "Usage: btape <options> <device_name>\n"
2609 " -b <file> specify bootstrap file\n"
2610 " -c <file> set configuration file to file\n"
2611 " -d <nn> set debug level to nn\n"
2612 " -p proceed inspite of I/O errors\n"
2613 " -s turn off signals\n"
2615 " -? print this message.\n"
2616 "\n"), VERSION, BDATE);
2621 * Get next input command from terminal. This
2622 * routine is REALLY primitive, and should be enhanced
2623 * to have correct backspacing, etc.
2626 get_cmd(const char *prompt)
2630 fprintf(stdout, prompt);
2632 /* We really should turn off echoing and pretty this
2636 while ((ch = fgetc(stdin)) != EOF) {
2638 strip_trailing_junk(cmd);
2640 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2653 /* Dummies to replace askdir.c */
2654 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2655 bool dir_send_job_status(JCR *jcr) {return 1;}
2657 bool dir_update_volume_info(DCR *dcr, bool relabel)
2663 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2665 Dmsg0(20, "Enter dir_get_volume_info\n");
2666 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2670 bool dir_create_jobmedia_record(DCR *dcr)
2672 dcr->WroteVol = false;
2677 bool dir_find_next_appendable_volume(DCR *dcr)
2679 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2680 return dcr->VolumeName[0] != 0;
2683 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2685 DEVICE *dev = dcr->dev;
2686 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2687 if (dcr->VolumeName[0] == 0) {
2688 return dir_ask_sysop_to_create_appendable_volume(dcr);
2691 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2692 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2693 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2696 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2697 dcr->VolumeName, dev->print_name());
2703 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2706 DEVICE *dev = dcr->dev;
2707 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2709 set_volume_name("TestVolume1", 1);
2711 set_volume_name("TestVolume2", 2);
2713 /* Close device so user can use autochanger if desired */
2714 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2717 autochanger = autoload_device(dcr, 1, NULL);
2720 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2731 static bool my_mount_next_read_volume(DCR *dcr)
2734 JCR *jcr = dcr->jcr;
2735 DEV_BLOCK *block = dcr->block;
2737 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2738 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2741 if (LastBlock != block->BlockNumber) {
2742 VolBytes += block->block_len;
2744 LastBlock = block->BlockNumber;
2746 now -= jcr->run_time;
2750 kbs = (double)VolBytes / (1000.0 * (double)now);
2751 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2752 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2754 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2759 free_restore_volume_list(jcr);
2760 set_volume_name("TestVolume2", 2);
2762 create_restore_volume_list(jcr);
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;