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, "%lu", &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"),
186 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
188 working_directory = "/tmp";
189 my_name_is(margc, margv, "btape");
190 init_msg(NULL, NULL);
194 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
196 case 'b': /* bootstrap file */
197 bsr = parse_bsr(NULL, optarg);
198 // dump_bsr(bsr, true);
201 case 'c': /* specify config file */
202 if (configfile != NULL) {
205 configfile = bstrdup(optarg);
208 case 'd': /* set debug level */
209 debug_level = atoi(optarg);
210 if (debug_level <= 0) {
237 cmd = get_pool_memory(PM_FNAME);
238 args = get_pool_memory(PM_FNAME);
241 init_signals(terminate_btape);
244 if (configfile == NULL) {
245 configfile = bstrdup(CONFIG_FILE);
248 daemon_start_time = time(NULL);
250 parse_config(configfile);
253 /* See if we can open a device */
255 Pmsg0(000, _("No archive name specified.\n"));
258 } else if (margc != 1) {
259 Pmsg0(000, _("Improper number of arguments specified.\n"));
264 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
273 if (!open_the_device()) {
277 Dmsg0(200, "Do tape commands\n");
285 static void terminate_btape(int stat)
288 sm_check(__FILE__, __LINE__, false);
292 free_config_resources();
294 free_pool_memory(args);
298 free_pool_memory(cmd);
315 if (debug_level > 10)
316 print_memory_pool_stats();
319 free_block(this_block);
324 close_memory_pool(); /* free memory in pool */
325 term_last_jobs_list();
331 static bool open_the_device()
335 block = new_block(dev);
337 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
338 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
339 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
344 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
345 dev->set_append(); /* put volume in append mode */
358 * Write a label to the tape
360 static void labelcmd()
363 pm_strcpy(cmd, VolumeName);
365 if (!get_cmd(_("Enter Volume Name: "))) {
370 if (!dev->is_open()) {
371 if (!first_open_device(dcr)) {
372 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
376 write_new_volume_label_to_dev(dcr, cmd, "Default", true /* label dvd now */);
377 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
381 * Read the tape label
383 static void readlabelcmd()
385 int save_debug_level = debug_level;
388 stat = read_dev_volume_label(dcr);
391 Pmsg0(0, _("Volume has no label.\n"));
394 Pmsg0(0, _("Volume label read correctly.\n"));
397 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
400 Pmsg0(0, _("Volume name error\n"));
402 case VOL_CREATE_ERROR:
403 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
405 case VOL_VERSION_ERROR:
406 Pmsg0(0, _("Volume version error.\n"));
408 case VOL_LABEL_ERROR:
409 Pmsg0(0, _("Bad Volume label type.\n"));
412 Pmsg0(0, _("Unknown error.\n"));
417 dump_volume_label(dev);
418 debug_level = save_debug_level;
423 * Load the tape should have prevously been taken
424 * off line, otherwise this command is not necessary.
426 static void loadcmd()
429 if (!load_dev(dev)) {
430 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
432 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
438 static void rewindcmd()
440 if (!dev->rewind(dcr)) {
441 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
444 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
449 * Clear any tape error
451 static void clearcmd()
457 * Write and end of file on the tape
459 static void weofcmd()
469 if (!dev->weof(num)) {
470 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
474 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
477 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
483 /* Go to the end of the medium -- raw command
484 * The idea was orginally that the end of the Bacula
485 * medium would be flagged differently. This is not
486 * currently the case. So, this is identical to the
492 Pmsg1(0, "%s", dev->bstrerror());
495 Pmsg0(0, _("Moved to end of medium.\n"));
500 * Go to the end of the medium (either hardware determined
501 * or defined by two eofs.
521 if (!dev->bsf(num)) {
522 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
524 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
540 if (!dev->bsr(num)) {
541 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
543 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
548 * List device capabilities as defined in the
553 printf(_("Configured device capabilities:\n"));
554 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
555 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
556 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
557 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
558 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
559 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
560 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
561 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
562 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
563 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
564 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
565 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
566 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
567 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
568 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
571 printf(_("Device status:\n"));
572 printf("%sOPENED ", dev->is_open() ? "" : "!");
573 printf("%sTAPE ", dev->is_tape() ? "" : "!");
574 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
575 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
576 printf("%sAPPEND ", dev->can_append() ? "" : "!");
577 printf("%sREAD ", dev->can_read() ? "" : "!");
578 printf("%sEOT ", dev->at_eot() ? "" : "!");
579 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
580 printf("%sEOF ", dev->at_eof() ? "" : "!");
581 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
582 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
585 printf(_("Device parameters:\n"));
586 printf("Device name: %s\n", dev->dev_name);
587 printf("File=%u block=%u\n", dev->file, dev->block_num);
588 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
590 printf(_("Status:\n"));
596 * Test writting larger and larger records.
597 * This is a torture test for records.
599 static void rectestcmd()
605 Pmsg0(0, _("Test writting larger and larger records.\n"
606 "This is a torture test for records.\nI am going to write\n"
607 "larger and larger records. It will stop when the record size\n"
608 "plus the header exceeds the block size (by default about 64K)\n"));
611 get_cmd(_("Do you want to continue? (y/n): "));
613 Pmsg0(000, _("Command aborted.\n"));
617 sm_check(__FILE__, __LINE__, false);
618 block = new_block(dev);
621 for (i=1; i<500000; i++) {
622 rec->data = check_pool_memory_size(rec->data, i);
623 memset(rec->data, i & 0xFF, i);
625 sm_check(__FILE__, __LINE__, false);
626 if (write_record_to_block(block, rec)) {
629 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
633 sm_check(__FILE__, __LINE__, false);
637 sm_check(__FILE__, __LINE__, false);
641 * This test attempts to re-read a block written by Bacula
642 * normally at the end of the tape. Bacula will then back up
643 * over the two eof marks, backup over the record and reread
644 * it to make sure it is valid. Bacula can skip this validation
645 * if you set "Backward space record = no"
647 static int re_read_block_test()
649 DEV_BLOCK *block = dcr->block;
654 if (!(dev->capabilities & CAP_BSR)) {
655 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
659 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
660 "I'm going to write three records and an EOF\n"
661 "then backup over the EOF and re-read the last record.\n"
662 "Bacula does this after writing the last block on the\n"
663 "tape to verify that the block was written correctly.\n\n"
664 "This is not an *essential* feature ...\n\n"));
668 rec->data = check_pool_memory_size(rec->data, block->buf_len);
669 len = rec->data_len = block->buf_len-100;
670 memset(rec->data, 1, rec->data_len);
671 if (!write_record_to_block(block, rec)) {
672 Pmsg0(0, _("Error writing record to block.\n"));
675 if (!write_block_to_dev(dcr)) {
676 Pmsg0(0, _("Error writing block to device.\n"));
679 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
681 memset(rec->data, 2, rec->data_len);
682 if (!write_record_to_block(block, rec)) {
683 Pmsg0(0, _("Error writing record to block.\n"));
686 if (!write_block_to_dev(dcr)) {
687 Pmsg0(0, _("Error writing block to device.\n"));
690 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
692 memset(rec->data, 3, rec->data_len);
693 if (!write_record_to_block(block, rec)) {
694 Pmsg0(0, _("Error writing record to block.\n"));
697 if (!write_block_to_dev(dcr)) {
698 Pmsg0(0, _("Error writing block to device.\n"));
701 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
704 if (dev_cap(dev, CAP_TWOEOF)) {
708 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
711 if (dev_cap(dev, CAP_TWOEOF)) {
713 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
717 Pmsg0(0, _("Backspaced over EOF OK.\n"));
719 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
722 Pmsg0(0, _("Backspace record OK.\n"));
723 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
725 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
728 memset(rec->data, 0, rec->data_len);
729 if (!read_record_from_block(block, rec)) {
731 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
734 for (int i=0; i<len; i++) {
735 if (rec->data[i] != 3) {
736 Pmsg0(0, _("Bad data in record. Test failed!\n"));
740 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
741 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
748 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
749 "this function to verify the last block written to the\n"
750 "tape. Bacula will skip the last block verification\n"
752 "Backward Space Record = No\n\n"
753 "to your Storage daemon's Device resource definition.\n"));
760 * This test writes Bacula blocks to the tape in
761 * several files. It then rewinds the tape and attepts
762 * to read these blocks back checking the data.
764 static int write_read_test()
772 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
773 "I'm going to write 1000 records and an EOF\n"
774 "then write 1000 records and an EOF, then rewind,\n"
775 "and re-read the data to verify that it is correct.\n\n"
776 "This is an *essential* feature ...\n\n"));
779 if (!dev->rewind(dcr)) {
780 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
783 rec->data = check_pool_memory_size(rec->data, block->buf_len);
784 rec->data_len = block->buf_len-100;
785 len = rec->data_len/sizeof(i);
786 for (i=1; i<=1000; i++) {
787 p = (int *)rec->data;
788 for (j=0; j<len; j++) {
791 if (!write_record_to_block(block, rec)) {
792 Pmsg0(0, _("Error writing record to block.\n"));
795 if (!write_block_to_dev(dcr)) {
796 Pmsg0(0, _("Error writing block to device.\n"));
800 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
802 for (i=1001; i<=2000; i++) {
803 p = (int *)rec->data;
804 for (j=0; j<len; j++) {
807 if (!write_record_to_block(block, rec)) {
808 Pmsg0(0, _("Error writing record to block.\n"));
811 if (!write_block_to_dev(dcr)) {
812 Pmsg0(0, _("Error writing block to device.\n"));
816 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
818 if (dev_cap(dev, CAP_TWOEOF)) {
821 if (!dev->rewind(dcr)) {
822 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
825 Pmsg0(0, _("Rewind OK.\n"));
827 for (i=1; i<=2000; i++) {
829 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
831 if (dev_state(dev, ST_EOF)) {
832 Pmsg0(-1, _("Got EOF on tape.\n"));
837 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
840 memset(rec->data, 0, rec->data_len);
841 if (!read_record_from_block(block, rec)) {
843 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
846 p = (int *)rec->data;
847 for (j=0; j<len; j++) {
849 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
855 if (i == 1000 || i == 2000) {
856 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
859 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
868 * This test writes Bacula blocks to the tape in
869 * several files. It then rewinds the tape and attepts
870 * to read these blocks back checking the data.
872 static int position_test()
874 DEV_BLOCK *block = dcr->block;
880 int file = 0, blk = 0;
882 bool got_eof = false;
884 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
885 "I'm going to write 1000 records and an EOF\n"
886 "then write 1000 records and an EOF, then rewind,\n"
887 "and position to a few blocks and verify that it is correct.\n\n"
888 "This is an *essential* feature ...\n\n"));
891 if (!dev->rewind(dcr)) {
892 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
895 rec->data = check_pool_memory_size(rec->data, block->buf_len);
896 rec->data_len = block->buf_len-100;
897 len = rec->data_len/sizeof(i);
898 for (i=1; i<=1000; i++) {
899 p = (int *)rec->data;
900 for (j=0; j<len; j++) {
903 if (!write_record_to_block(block, rec)) {
904 Pmsg0(0, _("Error writing record to block.\n"));
907 if (!write_block_to_dev(dcr)) {
908 Pmsg0(0, _("Error writing block to device.\n"));
912 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
914 for (i=1001; i<=2000; i++) {
915 p = (int *)rec->data;
916 for (j=0; j<len; j++) {
919 if (!write_record_to_block(block, rec)) {
920 Pmsg0(0, _("Error writing record to block.\n"));
923 if (!write_block_to_dev(dcr)) {
924 Pmsg0(0, _("Error writing block to device.\n"));
928 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
930 if (dev_cap(dev, CAP_TWOEOF)) {
933 if (!dev->rewind(dcr)) {
934 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
937 Pmsg0(0, _("Rewind OK.\n"));
941 /* Set up next item to read based on where we are */
977 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
978 if (!dev->reposition(file, blk)) {
979 Pmsg0(0, _("Reposition error.\n"));
983 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
985 if (dev_state(dev, ST_EOF)) {
986 Pmsg0(-1, _("Got EOF on tape.\n"));
992 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
993 recno, file, blk, be.strerror(dev->dev_errno));
994 Pmsg0(0, _("This may be because the tape drive block size is not\n"
995 " set to variable blocking as normally used by Bacula.\n"
996 " Please see the Tape Testing chapter in the manual and \n"
997 " look for using mt with defblksize and setoptions\n"
998 "If your tape drive block size is correct, then perhaps\n"
999 " your SCSI driver is *really* stupid and does not\n"
1000 " correctly report the file:block after a FSF. In this\n"
1001 " case try setting:\n"
1002 " Fast Forward Space File = no\n"
1003 " in your Device resource.\n"));
1007 memset(rec->data, 0, rec->data_len);
1008 if (!read_record_from_block(block, rec)) {
1010 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1013 p = (int *)rec->data;
1014 for (j=0; j<len; j++) {
1015 if (p[j] != recno) {
1016 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1021 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1023 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1035 * This test writes some records, then writes an end of file,
1036 * rewinds the tape, moves to the end of the data and attepts
1037 * to append to the tape. This function is essential for
1038 * Bacula to be able to write multiple jobs to the tape.
1040 static int append_test()
1042 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1043 "This test is essential to Bacula.\n\n"
1044 "I'm going to write one record in file 0,\n"
1045 " two records in file 1,\n"
1046 " and three records in file 2\n\n"));
1050 weofcmd(); /* end file 0 */
1053 weofcmd(); /* end file 1 */
1057 weofcmd(); /* end file 2 */
1058 if (dev_cap(dev, CAP_TWOEOF)) {
1061 dev->close(); /* release device */
1062 if (!open_the_device()) {
1066 Pmsg0(0, _("Now moving to end of medium.\n"));
1068 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1069 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1071 if (dev->file != 3) {
1075 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1078 if (dev_cap(dev, CAP_TWOEOF)) {
1082 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1083 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1085 Pmsg0(-1, _("End scanning the tape.\n"));
1086 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1087 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1089 if (dev->file != 4) {
1097 * This test exercises the autochanger
1099 static int autochanger_test()
1101 POOLMEM *results, *changer;
1102 int slot, status, loaded;
1103 int timeout = dcr->device->max_changer_wait;
1106 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1107 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1110 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1111 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1115 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1116 "To test the autochanger you must have a blank tape\n"
1117 " that I can write on in Slot 1.\n"));
1118 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1121 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1125 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1127 results = get_pool_memory(PM_MESSAGE);
1128 changer = get_pool_memory(PM_FNAME);
1132 dcr->VolCatInfo.Slot = slot;
1133 /* Find out what is loaded, zero means device is unloaded */
1134 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1135 changer = edit_device_codes(dcr, changer,
1136 dcr->device->changer_command, "loaded");
1137 status = run_program(changer, timeout, results);
1138 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1140 loaded = atoi(results);
1143 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1144 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1148 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1150 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1152 Dmsg1(100, "Results from loaded query=%s\n", results);
1154 dcr->VolCatInfo.Slot = loaded;
1155 /* We are going to load a new tape, so close the device */
1157 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1158 loaded, dev->drive_index);
1159 changer = edit_device_codes(dcr, changer,
1160 dcr->device->changer_command, "unload");
1161 status = run_program(changer, timeout, results);
1162 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1165 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1166 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1175 dcr->VolCatInfo.Slot = slot;
1176 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1177 slot, dev->drive_index);
1178 changer = edit_device_codes(dcr, changer,
1179 dcr->device->changer_command, "load");
1180 Dmsg1(100, "Changer=%s\n", changer);
1182 status = run_program(changer, timeout, results);
1184 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1185 slot, dev->drive_index);
1188 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1189 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1193 if (!open_the_device()) {
1197 * Start with sleep_time 0 then increment by 30 seconds if we get
1200 bmicrosleep(sleep_time, 0);
1201 if (!dev->rewind(dcr) || !dev->weof(1)) {
1202 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1204 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1205 "a longer sleep time in the mtx-script in the load) case.\n"
1206 "Adding a 30 second sleep and trying again ...\n"));
1210 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1213 if (!dev->weof(1)) {
1214 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1217 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1221 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1223 "to your mtx-changer script in the load) case.\n\n"),
1226 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1229 free_pool_memory(changer);
1230 free_pool_memory(results);
1235 free_pool_memory(changer);
1236 free_pool_memory(results);
1237 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1241 static void autochangercmd()
1248 * This test assumes that the append test has been done,
1249 * then it tests the fsf function.
1251 static int fsf_test()
1253 bool set_off = false;
1255 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1256 "This test is essential to Bacula.\n\n"
1257 "I'm going to write five files then test forward spacing\n\n"));
1261 weofcmd(); /* end file 0 */
1264 weofcmd(); /* end file 1 */
1268 weofcmd(); /* end file 2 */
1271 weofcmd(); /* end file 3 */
1273 weofcmd(); /* end file 4 */
1274 if (dev_cap(dev, CAP_TWOEOF)) {
1280 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1282 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1285 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1286 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1288 if (dev->file != 1) {
1292 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1294 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1297 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1298 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1300 if (dev->file != 3) {
1305 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1307 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1310 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1311 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1313 if (dev->file != 4) {
1317 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1318 " Fast Forward Space File = no\n\n"
1319 "to your Device resource for this drive.\n"));
1323 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1325 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1327 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1328 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1329 if (dev->file != 5) {
1332 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1336 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1337 if (dev_cap(dev, CAP_FASTFSF)) {
1338 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1339 "I am turning it off then retrying the test.\n"));
1340 dev->capabilities &= ~CAP_FASTFSF;
1344 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1345 "Some systems, e.g. OpenBSD, require you to set\n"
1346 " Use MTIOCGET= no\n"
1347 "in your device resource. Use with caution.\n"));
1356 * This is a general test of Bacula's functions
1357 * needed to read and write the tape.
1359 static void testcmd()
1363 if (!write_read_test()) {
1366 if (!position_test()) {
1370 stat = append_test();
1371 if (stat == 1) { /* OK get out */
1374 if (stat == -1) { /* first test failed */
1375 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1376 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1377 "Setting \"Hardware End of Medium = no\n"
1378 " and \"Fast Forward Space File = no\n"
1379 "and retrying append test.\n\n"));
1380 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1381 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1382 stat = append_test();
1384 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1385 " Hardware End of Medium = No\n\n"
1386 " Fast Forward Space File = No\n"
1387 "to your Device resource in the Storage conf file.\n"));
1391 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1394 /* Wrong count after append */
1396 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1397 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1398 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1399 stat = append_test();
1401 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1402 " Hardware End of Medium = No\n"
1403 " Fast Forward Space File = No\n"
1404 " BSF at EOM = yes\n\n"
1405 "to your Device resource in the Storage conf file.\n"));
1412 Pmsg0(-1, _("\nAppend test failed.\n\n"
1413 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1414 "Unable to correct the problem. You MUST fix this\n"
1415 "problem before Bacula can use your tape drive correctly\n"
1416 "\nPerhaps running Bacula in fixed block mode will work.\n"
1417 "Do so by setting:\n\n"
1418 "Minimum Block Size = nnn\n"
1419 "Maximum Block Size = nnn\n\n"
1420 "in your Storage daemon's Device definition.\n"
1421 "nnn must match your tape driver's block size, which\n"
1422 "can be determined by reading your tape manufacturers\n"
1423 "information, and the information on your kernel dirver.\n"
1424 "Fixed block sizes, however, are not normally an ideal solution.\n"
1426 "Some systems, e.g. OpenBSD, require you to set\n"
1427 " Use MTIOCGET= no\n"
1428 "in your device resource. Use with caution.\n"));
1433 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1434 "Please double check it ...\n"
1435 "=== Sample correct output ===\n"
1436 "1 block of 64448 bytes in file 1\n"
1437 "End of File mark.\n"
1438 "2 blocks of 64448 bytes in file 2\n"
1439 "End of File mark.\n"
1440 "3 blocks of 64448 bytes in file 3\n"
1441 "End of File mark.\n"
1442 "1 block of 64448 bytes in file 4\n"
1443 "End of File mark.\n"
1444 "Total files=4, blocks=7, bytes = 451,136\n"
1445 "=== End sample correct output ===\n\n"
1446 "If the above scan output is not identical to the\n"
1447 "sample output, you MUST correct the problem\n"
1448 "or Bacula will not be able to write multiple Jobs to \n"
1452 re_read_block_test();
1455 fsf_test(); /* do fast forward space file test */
1457 autochanger_test(); /* do autochanger test */
1461 /* Forward space a file */
1462 static void fsfcmd()
1466 num = atoi(argk[1]);
1471 if (!dev->fsf(num)) {
1472 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1476 Pmsg0(0, _("Forward spaced 1 file.\n"));
1479 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1483 /* Forward space a record */
1484 static void fsrcmd()
1488 num = atoi(argk[1]);
1493 if (!dev->fsr(num)) {
1494 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1498 Pmsg0(0, _("Forward spaced 1 record.\n"));
1501 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1507 * Write a Bacula block to the tape
1511 DEV_BLOCK *block = dcr->block;
1512 DEV_RECORD *rec = dcr->rec;
1515 sm_check(__FILE__, __LINE__, false);
1518 dump_block(block, "test");
1521 i = block->buf_len - 100;
1523 rec->data = check_pool_memory_size(rec->data, i);
1524 memset(rec->data, i & 0xFF, i);
1526 sm_check(__FILE__, __LINE__, false);
1527 if (!write_record_to_block(block, rec)) {
1528 Pmsg0(0, _("Error writing record to block.\n"));
1531 if (!write_block_to_dev(dcr)) {
1532 Pmsg0(0, _("Error writing block to device.\n"));
1535 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1537 Pmsg0(0, _("Wrote block to device.\n"));
1540 sm_check(__FILE__, __LINE__, false);
1541 sm_check(__FILE__, __LINE__, false);
1545 * Read a record from the tape
1552 if (!get_cmd(_("Enter length to read: "))) {
1556 if (len < 0 || len > 1000000) {
1557 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1560 buf = (char *)malloc(len);
1561 stat = read(dev->fd, buf, len);
1562 if (stat > 0 && stat <= len) {
1566 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1567 len, stat, be.strerror());
1573 * Scan tape by reading block by block. Report what is
1574 * on the tape. Note, this command does raw reads, and as such
1575 * will not work with fixed block size devices.
1577 static void scancmd()
1580 int blocks, tot_blocks, tot_files;
1586 blocks = block_size = tot_blocks = 0;
1588 if (dev->state & ST_EOT) {
1589 Pmsg0(0, _("End of tape\n"));
1592 update_pos_dev(dev);
1593 tot_files = dev->file;
1594 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1596 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1599 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1600 dev->dev_name, be.strerror());
1601 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1604 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1607 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1612 Dmsg1(200, "read status = %d\n", stat);
1614 if (stat != block_size) {
1615 update_pos_dev(dev);
1618 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1621 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1627 if (stat == 0) { /* EOF */
1628 update_pos_dev(dev);
1629 printf(_("End of File mark.\n"));
1630 /* Two reads of zero means end of tape */
1631 if (dev->state & ST_EOF)
1632 dev->state |= ST_EOT;
1634 dev->state |= ST_EOF;
1637 if (dev->state & ST_EOT) {
1638 printf(_("End of tape\n"));
1641 } else { /* Got data */
1642 dev->state &= ~ST_EOF;
1648 update_pos_dev(dev);
1649 tot_files = dev->file - tot_files;
1650 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1651 edit_uint64_with_commas(bytes, ec1));
1656 * Scan tape by reading Bacula block by block. Report what is
1657 * on the tape. This function reads Bacula blocks, so if your
1658 * Device resource is correctly defined, it should work with
1659 * either variable or fixed block sizes.
1661 static void scan_blocks()
1663 int blocks, tot_blocks, tot_files;
1664 uint32_t block_size;
1666 DEV_BLOCK *block = dcr->block;
1668 char buf1[100], buf2[100];
1670 blocks = block_size = tot_blocks = 0;
1674 update_pos_dev(dev);
1675 tot_files = dev->file;
1677 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1678 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1679 if (dev->state & ST_EOT) {
1682 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1685 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1691 if (dev->state & ST_EOF) {
1694 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1697 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1701 printf(_("End of File mark.\n"));
1704 if (dev->state & ST_SHORT) {
1707 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1710 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1714 printf(_("Short block read.\n"));
1717 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1720 if (block->block_len != block_size) {
1723 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1726 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1730 block_size = block->block_len;
1734 bytes += block->block_len;
1735 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1736 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1737 block->VolSessionId, block->VolSessionTime);
1739 DEV_RECORD *rec = new_record();
1740 read_record_from_block(block, rec);
1741 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1742 block->BlockNumber, dev->block_num, block->block_len,
1743 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1744 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1747 } else if (verbose > 1) {
1748 dump_block(block, "");
1753 tot_files = dev->file - tot_files;
1754 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1755 edit_uint64_with_commas(bytes, ec1));
1759 static void statcmd()
1761 int debug = debug_level;
1763 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1765 dump_volume_label(dev);
1767 debug_level = debug;
1772 * First we label the tape, then we fill
1773 * it with data get a new tape and write a few blocks.
1775 static void fillcmd()
1778 DEV_BLOCK *block = dcr->block;
1780 char buf1[100], buf2[100];
1783 uint32_t min_block_size;
1794 "This command simulates Bacula writing to a tape.\n"
1795 "It requires either one or two blank tapes, which it\n"
1796 "will label and write.\n\n"
1797 "If you have an autochanger configured, it will use\n"
1798 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1799 "be prompted to insert the tapes when necessary.\n\n"
1800 "It will print a status approximately\n"
1801 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1802 "selected the simple test option, after writing the first tape\n"
1803 "it will rewind it and re-read the last block written.\n\n"
1804 "If you have selected the multiple tape test, when the first tape\n"
1805 "fills, it will ask for a second, and after writing a few more \n"
1806 "blocks, it will stop. Then it will begin re-reading the\n"
1808 "This may take a long time -- hours! ...\n\n"));
1810 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1811 "or the complete multiple tape (m) test: (s/m) "));
1812 if (cmd[0] == 's') {
1813 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1815 } else if (cmd[0] == 'm') {
1816 Pmsg0(-1, _("Multiple tape test selected.\n"));
1819 Pmsg0(000, _("Command aborted.\n"));
1823 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1824 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1826 /* Use fixed block size to simplify read back */
1827 min_block_size = dev->min_block_size;
1828 dev->min_block_size = dev->max_block_size;
1829 set_volume_name("TestVolume1", 1);
1831 if (!dev->rewind(dcr)) {
1832 Pmsg0(000, _("Rewind failed.\n"));
1834 if (!dev->weof(1)) {
1835 Pmsg0(000, _("Write EOF failed.\n"));
1838 dev->set_append(); /* force volume to be relabeled */
1841 * Acquire output device for writing. Note, after acquiring a
1842 * device, we MUST release it, which is done at the end of this
1845 Dmsg0(100, "just before acquire_device\n");
1846 if (!acquire_device_for_append(dcr)) {
1847 set_jcr_job_status(jcr, JS_ErrorTerminated);
1850 block = jcr->dcr->block;
1852 Dmsg0(100, "Just after acquire_device_for_append\n");
1854 * Write Begin Session Record
1856 if (!write_session_label(dcr, SOS_LABEL)) {
1857 set_jcr_job_status(jcr, JS_ErrorTerminated);
1858 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1862 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1864 memset(&rec, 0, sizeof(rec));
1865 rec.data = get_memory(100000); /* max record size */
1867 #define REC_SIZE 32768
1868 rec.data_len = REC_SIZE;
1871 * Put some random data in the record
1873 fd = open("/dev/urandom", O_RDONLY);
1875 read(fd, rec.data, rec.data_len);
1878 uint32_t *p = (uint32_t *)rec.data;
1879 srandom(time(NULL));
1880 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1886 * Generate data as if from File daemon, write to device
1888 jcr->dcr->VolFirstIndex = 0;
1889 time(&jcr->run_time); /* start counting time for rates */
1890 (void)localtime_r(&jcr->run_time, &tm);
1891 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1893 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1895 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1897 for (file_index = 0; ok && !job_canceled(jcr); ) {
1898 rec.VolSessionId = jcr->VolSessionId;
1899 rec.VolSessionTime = jcr->VolSessionTime;
1900 rec.FileIndex = ++file_index;
1901 rec.Stream = STREAM_FILE_DATA;
1903 /* Mix up the data just a bit */
1904 uint32_t *lp = (uint32_t *)rec.data;
1906 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1910 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1911 rec.FileIndex, rec.VolSessionId,
1912 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1915 while (!write_record_to_block(block, &rec)) {
1917 * When we get here we have just filled a block
1919 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1922 /* Write block to tape */
1923 if (!flush_block(block, 1)) {
1927 /* Every 5000 blocks (approx 322MB) report where we are.
1929 if ((block->BlockNumber % 5000) == 0) {
1931 now -= jcr->run_time;
1933 now = 1; /* prevent divide error */
1935 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1936 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1937 block->BlockNumber, dev->block_num,
1938 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1940 /* Every 32000 blocks (approx 2GB) write an EOF.
1942 if ((block->BlockNumber % 32000) == 0) {
1944 (void)localtime_r(&now, &tm);
1945 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1946 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1947 flush_block(block, 0);
1951 /* Get out after writing 10 blocks to the second tape */
1952 if (++BlockNumber > 10 && stop != 0) { /* get out */
1957 Pmsg0(000, _("Not OK\n"));
1960 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1961 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1962 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1963 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1965 /* Get out after writing 10 blocks to the second tape */
1966 if (BlockNumber > 10 && stop != 0) { /* get out */
1968 Pmsg1(-1, "Done writing %s records ...\n",
1969 edit_uint64_with_commas(write_count, ed1));
1974 Dmsg0(100, "Write_end_session_label()\n");
1975 /* Create Job status for end of session label */
1976 if (!job_canceled(jcr) && ok) {
1977 set_jcr_job_status(jcr, JS_Terminated);
1979 set_jcr_job_status(jcr, JS_ErrorTerminated);
1981 if (!write_session_label(dcr, EOS_LABEL)) {
1982 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
1985 /* Write out final block of this session */
1986 if (!write_block_to_device(dcr)) {
1987 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1990 Pmsg0(-1, _("Wrote End of Session label.\n"));
1992 /* Save last block info for second tape */
1993 last_block_num2 = last_block_num;
1994 last_file2 = last_file;
1996 free_block(last_block2);
1998 last_block2 = dup_block(last_block);
2001 sprintf(buf, "%s/btape.state", working_directory);
2002 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2004 write(fd, &btape_state_level, sizeof(btape_state_level));
2005 write(fd, &simple, sizeof(simple));
2006 write(fd, &last_block_num1, sizeof(last_block_num1));
2007 write(fd, &last_block_num2, sizeof(last_block_num2));
2008 write(fd, &last_file1, sizeof(last_file1));
2009 write(fd, &last_file2, sizeof(last_file2));
2010 write(fd, last_block1->buf, last_block1->buf_len);
2011 write(fd, last_block2->buf, last_block2->buf_len);
2012 write(fd, first_block->buf, first_block->buf_len);
2014 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2015 last_block_num1, last_block_num2);
2018 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2023 (void)localtime_r(&now, &tm);
2024 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2026 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2027 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2030 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2031 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2034 jcr->dcr->block = block;
2037 dev->min_block_size = min_block_size;
2038 free_memory(rec.data);
2042 * Read two tapes written by the "fill" command and ensure
2043 * that the data is valid. If stop==1 we simulate full read back
2044 * of two tapes. If stop==-1 we simply read the last block and
2045 * verify that it is correct.
2047 static void unfillcmd()
2051 last_block1 = new_block(dev);
2052 last_block2 = new_block(dev);
2053 first_block = new_block(dev);
2054 sprintf(buf, "%s/btape.state", working_directory);
2055 fd = open(buf, O_RDONLY);
2057 uint32_t state_level;
2058 read(fd, &state_level, sizeof(btape_state_level));
2059 read(fd, &simple, sizeof(simple));
2060 read(fd, &last_block_num1, sizeof(last_block_num1));
2061 read(fd, &last_block_num2, sizeof(last_block_num2));
2062 read(fd, &last_file1, sizeof(last_file1));
2063 read(fd, &last_file2, sizeof(last_file2));
2064 read(fd, last_block1->buf, last_block1->buf_len);
2065 read(fd, last_block2->buf, last_block2->buf_len);
2066 read(fd, first_block->buf, first_block->buf_len);
2068 if (state_level != btape_state_level) {
2069 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2070 "the fill command.\n"));
2075 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2076 "You must redo the fill command.\n"), buf, be.strerror());
2083 static void do_unfill()
2085 DEV_BLOCK *block = dcr->block;
2092 Dmsg0(20, "Enter do_unfill\n");
2093 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2094 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2098 time(&jcr->run_time); /* start counting time for rates */
2102 free_block(last_block);
2105 last_block_num = last_block_num1;
2106 last_file = last_file1;
2107 last_block = last_block1;
2110 /* Multiple Volume tape */
2111 /* Close device so user can use autochanger if desired */
2112 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2115 autochanger = autoload_device(dcr, 1, NULL);
2118 get_cmd(_("Mount first tape. Press enter when ready: "));
2122 free_restore_volume_list(jcr);
2123 jcr->dcr = new_dcr(jcr, dev);
2124 set_volume_name("TestVolume1", 1);
2126 create_restore_volume_list(jcr);
2128 dev->num_writers = 0;
2129 if (!acquire_device_for_read(dcr)) {
2130 Pmsg1(-1, "%s", dev->errmsg);
2134 * We now have the first tape mounted.
2135 * Note, re-reading last block may have caused us to
2136 * loose track of where we are (block number unknown).
2138 Pmsg0(-1, _("Rewinding.\n"));
2139 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2142 /* Read the first 10000 records */
2143 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2144 dev->file, dev->block_num);
2146 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2147 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2148 last_file, last_block_num);
2149 if (!dev->reposition(last_file, last_block_num)) {
2150 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2153 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2154 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2155 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2158 if (compare_blocks(last_block, block)) {
2160 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2162 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2169 /* restore info for last block on second Volume */
2170 last_block_num = last_block_num2;
2171 last_file = last_file2;
2172 last_block = last_block2;
2174 /* Multiple Volume tape */
2175 /* Close device so user can use autochanger if desired */
2176 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2180 free_restore_volume_list(jcr);
2181 set_volume_name("TestVolume2", 2);
2183 create_restore_volume_list(jcr);
2184 autochanger = autoload_device(dcr, 1, NULL);
2187 get_cmd(_("Mount second tape. Press enter when ready: "));
2191 if (!acquire_device_for_read(dcr)) {
2192 Pmsg1(-1, "%s", dev->errmsg);
2196 /* Space to "first" block which is last block not written
2197 * on the previous tape.
2199 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2200 if (!dev->reposition(0, 1)) {
2201 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2204 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2205 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2206 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2209 if (compare_blocks(first_block, block)) {
2210 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2213 /* Now find and compare the last block */
2214 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2215 last_file, last_block_num);
2216 if (!dev->reposition(last_file, last_block_num)) {
2217 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2220 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2221 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2222 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2225 if (compare_blocks(last_block, block)) {
2226 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2230 free_block(last_block1);
2231 free_block(last_block2);
2232 free_block(first_block);
2235 /* Read 10000 records then stop */
2236 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2238 DEVICE *dev = dcr->dev;
2240 if (quickie_count == 10000) {
2241 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2243 return quickie_count < 10000;
2246 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2249 uint32_t CheckSum, block_len;
2252 p = last_block->buf;
2254 unser_begin(q, BLKHDR2_LENGTH);
2255 unser_uint32(CheckSum);
2256 unser_uint32(block_len);
2257 while (q < (block->buf+block_len)) {
2264 dump_block(last_block, _("Last block written"));
2266 dump_block(block, _("Block read back"));
2267 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2268 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2269 "that was read back differ. The test FAILED !!!!\n"
2270 "This must be corrected before you use Bacula\n"
2271 "to write multi-tape Volumes.!!!!\n"));
2275 dump_block(last_block, _("Last block written"));
2276 dump_block(block, _("Block read back"));
2286 * Write current block to tape regardless of whether or
2287 * not it is full. If the tape fills, attempt to
2288 * acquire another tape.
2290 static int flush_block(DEV_BLOCK *block, int dump)
2294 uint32_t this_file, this_block_num;
2298 this_block = new_block(dev);
2301 last_block = new_block(dev);
2304 this_file = dev->file;
2305 this_block_num = dev->block_num;
2306 if (!write_block_to_dev(dcr)) {
2307 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2308 last_file, last_block_num, this_block_num);
2311 * This is 1st tape, so save first tape info separate
2312 * from second tape info
2314 last_block_num1 = last_block_num;
2315 last_file1 = last_file;
2316 last_block1 = dup_block(last_block);
2317 last_block2 = dup_block(last_block);
2318 first_block = dup_block(block); /* first block second tape */
2321 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2322 (unsigned)file_index, block->BlockNumber, block->block_len);
2323 dump_block(last_block, _("Last block written"));
2325 dump_block(block, _("Block not written"));
2328 eot_block = block->BlockNumber;
2329 eot_block_len = block->block_len;
2330 eot_FileIndex = file_index;
2334 now -= jcr->run_time;
2336 now = 1; /* don't divide by zero */
2338 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2339 vol_size = dev->VolCatInfo.VolCatBytes;
2340 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2341 dev->file, dev->block_num,
2342 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2345 stop = -1; /* stop, but do simplified test */
2347 /* Full test in progress */
2348 if (!fixup_device_block_write_error(jcr->dcr)) {
2349 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2354 BlockNumber = 0; /* start counting for second tape */
2357 return 1; /* end of tape reached */
2360 /* Save contents after write so that the header is serialized */
2361 memcpy(this_block->buf, block->buf, this_block->buf_len);
2364 * Note, we always read/write to block, but we toggle
2365 * copying it to one or another of two allocated blocks.
2366 * Switch blocks so that the block just successfully written is
2367 * always in last_block.
2369 tblock = last_block;
2370 last_block = this_block;
2371 this_block = tblock;
2372 last_file = this_file;
2373 last_block_num = this_block_num;
2381 * First we label the tape, then we fill
2382 * it with data get a new tape and write a few blocks.
2384 static void qfillcmd()
2386 DEV_BLOCK *block = dcr->block;
2387 DEV_RECORD *rec = dcr->rec;
2390 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2392 get_cmd(_("How many blocks do you want to write? (1000): "));
2399 sm_check(__FILE__, __LINE__, false);
2401 i = block->buf_len - 100;
2403 rec->data = check_pool_memory_size(rec->data, i);
2404 memset(rec->data, i & 0xFF, i);
2407 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2408 for (i=0; i < count; i++) {
2413 if (!write_record_to_block(block, rec)) {
2414 Pmsg0(0, _("Error writing record to block.\n"));
2417 if (!write_block_to_dev(dcr)) {
2418 Pmsg0(0, _("Error writing block to device.\n"));
2424 if (dev_cap(dev, CAP_TWOEOF)) {
2431 sm_check(__FILE__, __LINE__, false);
2435 * Fill a tape using raw write() command
2437 static void rawfill_cmd()
2439 DEV_BLOCK *block = dcr->block;
2442 uint32_t block_num = 0;
2447 fd = open("/dev/urandom", O_RDONLY);
2449 read(fd, block->buf, block->buf_len);
2452 uint32_t *p = (uint32_t *)block->buf;
2453 srandom(time(NULL));
2454 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2458 p = (uint32_t *)block->buf;
2459 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2462 if (dev->is_tape()) {
2463 stat = tape_write(dev->fd, block->buf, block->buf_len);
2465 stat = write(dev->fd, block->buf, block->buf_len);
2467 if (stat == (int)block->buf_len) {
2468 if ((block_num++ % 100) == 0) {
2473 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2483 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2484 be.strerror(my_errno));
2490 * Fill a tape using Bacula block writes
2492 static void bfill_cmd()
2494 DEV_BLOCK *block = dcr->block;
2495 uint32_t block_num = 0;
2501 fd = open("/dev/urandom", O_RDONLY);
2503 read(fd, block->buf, block->buf_len);
2506 uint32_t *p = (uint32_t *)block->buf;
2507 srandom(time(NULL));
2508 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2512 p = (uint32_t *)block->buf;
2513 Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2516 block->binbuf = block->buf_len;
2517 block->bufp = block->buf + block->binbuf;
2518 if (!write_block_to_dev(dcr)) {
2521 if ((block_num++ % 100) == 0) {
2526 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2532 printf(_("Write failed at block %u.\n"), block_num);
2537 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2538 static struct cmdstruct commands[] = {
2539 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2540 {NT_("bsf"), bsfcmd, _("backspace file")},
2541 {NT_("bsr"), bsrcmd, _("backspace record")},
2542 {NT_("bfill"), bfill_cmd, _("fill tape using Bacula writes")},
2543 {NT_("cap"), capcmd, _("list device capabilities")},
2544 {NT_("clear"), clearcmd, _("clear tape errors")},
2545 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2546 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2547 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2548 {NT_("unfill"), unfillcmd, _("read filled tape")},
2549 {NT_("fsf"), fsfcmd, _("forward space a file")},
2550 {NT_("fsr"), fsrcmd, _("forward space a record")},
2551 {NT_("help"), helpcmd, _("print this command")},
2552 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2553 {NT_("load"), loadcmd, _("load a tape")},
2554 {NT_("quit"), quitcmd, _("quit btape")},
2555 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2556 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2557 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2558 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2559 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2560 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2561 {NT_("status"), statcmd, _("print tape status")},
2562 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2563 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2564 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2565 {NT_("rr"), rrcmd, _("read a single record")},
2566 {NT_("qfill"), qfillcmd, _("quick fill command")}
2568 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2576 while (!quit && get_cmd("*")) {
2577 sm_check(__FILE__, __LINE__, false);
2579 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2580 for (i=0; i<comsize; i++) /* search for command */
2581 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2582 (*commands[i].func)(); /* go execute command */
2587 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-%s 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"), BYEAR, 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;