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 BSR *bsr = NULL;
100 static int signals = TRUE;
103 static uint64_t vol_size;
104 static uint64_t VolBytes;
107 static int32_t file_index;
108 static int end_of_tape = 0;
109 static uint32_t LastBlock = 0;
110 static uint32_t eot_block;
111 static uint32_t eot_block_len;
112 static uint32_t eot_FileIndex;
113 static int dumped = 0;
114 static DEV_BLOCK *last_block1 = NULL;
115 static DEV_BLOCK *last_block2 = NULL;
116 static DEV_BLOCK *last_block = NULL;
117 static DEV_BLOCK *this_block = NULL;
118 static DEV_BLOCK *first_block = NULL;
119 static uint32_t last_file1 = 0;
120 static uint32_t last_file2 = 0;
121 static uint32_t last_file = 0;
122 static uint32_t last_block_num1 = 0;
123 static uint32_t last_block_num2 = 0;
124 static uint32_t last_block_num = 0;
125 static uint32_t BlockNumber = 0;
126 static bool simple = true;
128 static const char *VolumeName = NULL;
129 static int vol_num = 0;
131 static JCR *jcr = NULL;
135 static void terminate_btape(int sig);
136 int get_cmd(const char *prompt);
139 /*********************************************************************
141 * Bacula tape testing program
144 int main(int margc, char *margv[])
151 setlocale(LC_ALL, "");
152 bindtextdomain("bacula", LOCALEDIR);
153 textdomain("bacula");
156 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
157 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
158 TAPE_BSIZE, B_DEV_BSIZE);
160 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
161 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
163 if (sizeof(off_t) < 8) {
164 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n"),
168 bsnprintf(buf, sizeof(buf), "%u", x32);
169 i = bsscanf(buf, "%u", &y32);
170 if (i != 1 || x32 != y32) {
171 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
177 bsnprintf(buf, sizeof(buf), "%" llu, x64);
178 i = bsscanf(buf, "%llu", &y64);
179 if (i != 1 || x64 != y64) {
180 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"), i, x64, y64);
184 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
186 working_directory = "/tmp";
187 my_name_is(margc, margv, "btape");
188 init_msg(NULL, NULL);
190 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
192 case 'b': /* bootstrap file */
193 bsr = parse_bsr(NULL, optarg);
194 // dump_bsr(bsr, true);
197 case 'c': /* specify config file */
198 if (configfile != NULL) {
201 configfile = bstrdup(optarg);
204 case 'd': /* set debug level */
205 debug_level = atoi(optarg);
206 if (debug_level <= 0) {
233 cmd = get_pool_memory(PM_FNAME);
234 args = get_pool_memory(PM_FNAME);
237 init_signals(terminate_btape);
240 if (configfile == NULL) {
241 configfile = bstrdup(CONFIG_FILE);
244 daemon_start_time = time(NULL);
246 parse_config(configfile);
249 /* See if we can open a device */
251 Pmsg0(000, _("No archive name specified.\n"));
254 } else if (margc != 1) {
255 Pmsg0(000, _("Improper number of arguments specified.\n"));
260 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
269 if (!open_the_device()) {
273 Dmsg0(200, "Do tape commands\n");
281 static void terminate_btape(int stat)
284 sm_check(__FILE__, __LINE__, false);
288 free_config_resources();
290 free_pool_memory(args);
294 free_pool_memory(cmd);
309 if (debug_level > 10)
310 print_memory_pool_stats();
313 free_block(this_block);
318 close_memory_pool(); /* free memory in pool */
319 term_last_jobs_list();
325 static bool open_the_device()
329 block = new_block(dev);
331 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
332 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
333 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
338 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
339 dev->set_append(); /* put volume in append mode */
352 * Write a label to the tape
354 static void labelcmd()
357 pm_strcpy(cmd, VolumeName);
359 if (!get_cmd(_("Enter Volume Name: "))) {
364 if (!dev->is_open()) {
365 if (!first_open_device(dcr)) {
366 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
370 write_new_volume_label_to_dev(dcr, cmd, "Default");
371 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
375 * Read the tape label
377 static void readlabelcmd()
379 int save_debug_level = debug_level;
382 stat = read_dev_volume_label(dcr);
385 Pmsg0(0, _("Volume has no label.\n"));
388 Pmsg0(0, _("Volume label read correctly.\n"));
391 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
394 Pmsg0(0, _("Volume name error\n"));
396 case VOL_CREATE_ERROR:
397 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
399 case VOL_VERSION_ERROR:
400 Pmsg0(0, _("Volume version error.\n"));
402 case VOL_LABEL_ERROR:
403 Pmsg0(0, _("Bad Volume label type.\n"));
406 Pmsg0(0, _("Unknown error.\n"));
411 dump_volume_label(dev);
412 debug_level = save_debug_level;
417 * Load the tape should have prevously been taken
418 * off line, otherwise this command is not necessary.
420 static void loadcmd()
423 if (!load_dev(dev)) {
424 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
426 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
432 static void rewindcmd()
434 if (!dev->rewind(dcr)) {
435 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
438 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
443 * Clear any tape error
445 static void clearcmd()
451 * Write and end of file on the tape
453 static void weofcmd()
463 if (!dev->weof(num)) {
464 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
468 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
471 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
477 /* Go to the end of the medium -- raw command
478 * The idea was orginally that the end of the Bacula
479 * medium would be flagged differently. This is not
480 * currently the case. So, this is identical to the
486 Pmsg1(0, "%s", dev->bstrerror());
489 Pmsg0(0, _("Moved to end of medium.\n"));
494 * Go to the end of the medium (either hardware determined
495 * or defined by two eofs.
515 if (!dev->bsf(num)) {
516 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
518 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
534 if (!dev->bsr(num)) {
535 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
537 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
542 * List device capabilities as defined in the
547 printf(_("Configured device capabilities:\n"));
548 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
549 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
550 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
551 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
552 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
553 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
554 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
555 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
556 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
557 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
558 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
559 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
560 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
561 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
562 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
565 printf(_("Device status:\n"));
566 printf("%sOPENED ", dev->is_open() ? "" : "!");
567 printf("%sTAPE ", dev->is_tape() ? "" : "!");
568 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
569 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
570 printf("%sAPPEND ", dev->can_append() ? "" : "!");
571 printf("%sREAD ", dev->can_read() ? "" : "!");
572 printf("%sEOT ", dev->at_eot() ? "" : "!");
573 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
574 printf("%sEOF ", dev->at_eof() ? "" : "!");
575 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
576 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
579 printf(_("Device parameters:\n"));
580 printf("Device name: %s\n", dev->dev_name);
581 printf("File=%u block=%u\n", dev->file, dev->block_num);
582 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
584 printf(_("Status:\n"));
590 * Test writting larger and larger records.
591 * This is a torture test for records.
593 static void rectestcmd()
599 Pmsg0(0, _("Test writting larger and larger records.\n"
600 "This is a torture test for records.\nI am going to write\n"
601 "larger and larger records. It will stop when the record size\n"
602 "plus the header exceeds the block size (by default about 64K)\n"));
605 get_cmd(_("Do you want to continue? (y/n): "));
607 Pmsg0(000, _("Command aborted.\n"));
611 sm_check(__FILE__, __LINE__, false);
612 block = new_block(dev);
615 for (i=1; i<500000; i++) {
616 rec->data = check_pool_memory_size(rec->data, i);
617 memset(rec->data, i & 0xFF, i);
619 sm_check(__FILE__, __LINE__, false);
620 if (write_record_to_block(block, rec)) {
623 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
627 sm_check(__FILE__, __LINE__, false);
631 sm_check(__FILE__, __LINE__, false);
635 * This test attempts to re-read a block written by Bacula
636 * normally at the end of the tape. Bacula will then back up
637 * over the two eof marks, backup over the record and reread
638 * it to make sure it is valid. Bacula can skip this validation
639 * if you set "Backward space record = no"
641 static int re_read_block_test()
643 DEV_BLOCK *block = dcr->block;
648 if (!(dev->capabilities & CAP_BSR)) {
649 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
653 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
654 "I'm going to write three records and an EOF\n"
655 "then backup over the EOF and re-read the last record.\n"
656 "Bacula does this after writing the last block on the\n"
657 "tape to verify that the block was written correctly.\n\n"
658 "This is not an *essential* feature ...\n\n"));
662 rec->data = check_pool_memory_size(rec->data, block->buf_len);
663 len = rec->data_len = block->buf_len-100;
664 memset(rec->data, 1, rec->data_len);
665 if (!write_record_to_block(block, rec)) {
666 Pmsg0(0, _("Error writing record to block.\n"));
669 if (!write_block_to_dev(dcr)) {
670 Pmsg0(0, _("Error writing block to device.\n"));
673 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
675 memset(rec->data, 2, rec->data_len);
676 if (!write_record_to_block(block, rec)) {
677 Pmsg0(0, _("Error writing record to block.\n"));
680 if (!write_block_to_dev(dcr)) {
681 Pmsg0(0, _("Error writing block to device.\n"));
684 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
686 memset(rec->data, 3, rec->data_len);
687 if (!write_record_to_block(block, rec)) {
688 Pmsg0(0, _("Error writing record to block.\n"));
691 if (!write_block_to_dev(dcr)) {
692 Pmsg0(0, _("Error writing block to device.\n"));
695 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
698 if (dev_cap(dev, CAP_TWOEOF)) {
702 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
705 if (dev_cap(dev, CAP_TWOEOF)) {
707 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
711 Pmsg0(0, _("Backspaced over EOF OK.\n"));
713 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
716 Pmsg0(0, _("Backspace record OK.\n"));
717 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
719 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
722 memset(rec->data, 0, rec->data_len);
723 if (!read_record_from_block(block, rec)) {
725 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
728 for (int i=0; i<len; i++) {
729 if (rec->data[i] != 3) {
730 Pmsg0(0, _("Bad data in record. Test failed!\n"));
734 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
735 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
742 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
743 "this function to verify the last block written to the\n"
744 "tape. Bacula will skip the last block verification\n"
746 "Backward Space Record = No\n\n"
747 "to your Storage daemon's Device resource definition.\n"));
754 * This test writes Bacula blocks to the tape in
755 * several files. It then rewinds the tape and attepts
756 * to read these blocks back checking the data.
758 static int write_read_test()
766 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
767 "I'm going to write 1000 records and an EOF\n"
768 "then write 1000 records and an EOF, then rewind,\n"
769 "and re-read the data to verify that it is correct.\n\n"
770 "This is an *essential* feature ...\n\n"));
773 if (!dev->rewind(dcr)) {
774 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
777 rec->data = check_pool_memory_size(rec->data, block->buf_len);
778 rec->data_len = block->buf_len-100;
779 len = rec->data_len/sizeof(i);
780 for (i=1; i<=1000; i++) {
781 p = (int *)rec->data;
782 for (j=0; j<len; j++) {
785 if (!write_record_to_block(block, rec)) {
786 Pmsg0(0, _("Error writing record to block.\n"));
789 if (!write_block_to_dev(dcr)) {
790 Pmsg0(0, _("Error writing block to device.\n"));
794 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
796 for (i=1001; i<=2000; i++) {
797 p = (int *)rec->data;
798 for (j=0; j<len; j++) {
801 if (!write_record_to_block(block, rec)) {
802 Pmsg0(0, _("Error writing record to block.\n"));
805 if (!write_block_to_dev(dcr)) {
806 Pmsg0(0, _("Error writing block to device.\n"));
810 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
812 if (dev_cap(dev, CAP_TWOEOF)) {
815 if (!dev->rewind(dcr)) {
816 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
819 Pmsg0(0, _("Rewind OK.\n"));
821 for (i=1; i<=2000; i++) {
823 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
825 if (dev_state(dev, ST_EOF)) {
826 Pmsg0(-1, _("Got EOF on tape.\n"));
831 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
834 memset(rec->data, 0, rec->data_len);
835 if (!read_record_from_block(block, rec)) {
837 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
840 p = (int *)rec->data;
841 for (j=0; j<len; j++) {
843 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
849 if (i == 1000 || i == 2000) {
850 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
853 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
862 * This test writes Bacula blocks to the tape in
863 * several files. It then rewinds the tape and attepts
864 * to read these blocks back checking the data.
866 static int position_test()
868 DEV_BLOCK *block = dcr->block;
874 int file = 0, blk = 0;
876 bool got_eof = false;
878 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
879 "I'm going to write 1000 records and an EOF\n"
880 "then write 1000 records and an EOF, then rewind,\n"
881 "and position to a few blocks and verify that it is correct.\n\n"
882 "This is an *essential* feature ...\n\n"));
885 if (!dev->rewind(dcr)) {
886 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
889 rec->data = check_pool_memory_size(rec->data, block->buf_len);
890 rec->data_len = block->buf_len-100;
891 len = rec->data_len/sizeof(i);
892 for (i=1; i<=1000; i++) {
893 p = (int *)rec->data;
894 for (j=0; j<len; j++) {
897 if (!write_record_to_block(block, rec)) {
898 Pmsg0(0, _("Error writing record to block.\n"));
901 if (!write_block_to_dev(dcr)) {
902 Pmsg0(0, _("Error writing block to device.\n"));
906 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
908 for (i=1001; i<=2000; i++) {
909 p = (int *)rec->data;
910 for (j=0; j<len; j++) {
913 if (!write_record_to_block(block, rec)) {
914 Pmsg0(0, _("Error writing record to block.\n"));
917 if (!write_block_to_dev(dcr)) {
918 Pmsg0(0, _("Error writing block to device.\n"));
922 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
924 if (dev_cap(dev, CAP_TWOEOF)) {
927 if (!dev->rewind(dcr)) {
928 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
931 Pmsg0(0, _("Rewind OK.\n"));
935 /* Set up next item to read based on where we are */
971 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
972 if (!dev->reposition(file, blk)) {
973 Pmsg0(0, _("Reposition error.\n"));
977 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
979 if (dev_state(dev, ST_EOF)) {
980 Pmsg0(-1, _("Got EOF on tape.\n"));
986 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
987 recno, file, blk, be.strerror(dev->dev_errno));
988 Pmsg0(0, _("This may be because the tape drive block size is not\n"
989 " set to variable blocking as normally used by Bacula.\n"
990 " Please see the Tape Testing chapter in the manual and \n"
991 " look for using mt with defblksize and setoptions\n"
992 "If your tape drive block size is correct, then perhaps\n"
993 " your SCSI driver is *really* stupid and does not\n"
994 " correctly report the file:block after a FSF. In this\n"
995 " case try setting:\n"
996 " Fast Forward Space File = no\n"
997 " in your Device resource.\n"));
1001 memset(rec->data, 0, rec->data_len);
1002 if (!read_record_from_block(block, rec)) {
1004 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1007 p = (int *)rec->data;
1008 for (j=0; j<len; j++) {
1009 if (p[j] != recno) {
1010 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1015 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1017 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1029 * This test writes some records, then writes an end of file,
1030 * rewinds the tape, moves to the end of the data and attepts
1031 * to append to the tape. This function is essential for
1032 * Bacula to be able to write multiple jobs to the tape.
1034 static int append_test()
1036 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1037 "This test is essential to Bacula.\n\n"
1038 "I'm going to write one record in file 0,\n"
1039 " two records in file 1,\n"
1040 " and three records in file 2\n\n"));
1044 weofcmd(); /* end file 0 */
1047 weofcmd(); /* end file 1 */
1051 weofcmd(); /* end file 2 */
1052 if (dev_cap(dev, CAP_TWOEOF)) {
1055 dev->close(); /* release device */
1056 if (!open_the_device()) {
1060 Pmsg0(0, _("Now moving to end of medium.\n"));
1062 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1063 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1065 if (dev->file != 3) {
1069 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1072 if (dev_cap(dev, CAP_TWOEOF)) {
1076 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1077 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1079 Pmsg0(-1, _("End scanning the tape.\n"));
1080 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1081 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1083 if (dev->file != 4) {
1091 * This test exercises the autochanger
1093 static int autochanger_test()
1095 POOLMEM *results, *changer;
1096 int slot, status, loaded;
1097 int timeout = dcr->device->max_changer_wait;
1100 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1101 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1104 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1105 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1109 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1110 "To test the autochanger you must have a blank tape\n"
1111 " that I can write on in Slot 1.\n"));
1112 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1115 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1119 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1121 results = get_pool_memory(PM_MESSAGE);
1122 changer = get_pool_memory(PM_FNAME);
1126 dcr->VolCatInfo.Slot = slot;
1127 /* Find out what is loaded, zero means device is unloaded */
1128 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1129 changer = edit_device_codes(dcr, changer,
1130 dcr->device->changer_command, "loaded");
1131 status = run_program(changer, timeout, results);
1132 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1134 loaded = atoi(results);
1137 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1138 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1142 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1144 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1146 Dmsg1(100, "Results from loaded query=%s\n", results);
1148 dcr->VolCatInfo.Slot = loaded;
1149 /* We are going to load a new tape, so close the device */
1151 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1152 loaded, dev->drive_index);
1153 changer = edit_device_codes(dcr, changer,
1154 dcr->device->changer_command, "unload");
1155 status = run_program(changer, timeout, results);
1156 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1159 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1160 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1169 dcr->VolCatInfo.Slot = slot;
1170 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1171 slot, dev->drive_index);
1172 changer = edit_device_codes(dcr, changer,
1173 dcr->device->changer_command, "load");
1174 Dmsg1(100, "Changer=%s\n", changer);
1176 status = run_program(changer, timeout, results);
1178 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1179 slot, dev->drive_index);
1182 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1183 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1187 if (!open_the_device()) {
1191 * Start with sleep_time 0 then increment by 30 seconds if we get
1194 bmicrosleep(sleep_time, 0);
1195 if (!dev->rewind(dcr) || !dev->weof(1)) {
1196 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1198 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1199 "a longer sleep time in the mtx-script in the load) case.\n"
1200 "Adding a 30 second sleep and trying again ...\n"));
1204 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1207 if (!dev->weof(1)) {
1208 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1211 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1215 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1217 "to your mtx-changer script in the load) case.\n\n"),
1220 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1223 free_pool_memory(changer);
1224 free_pool_memory(results);
1229 free_pool_memory(changer);
1230 free_pool_memory(results);
1231 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1235 static void autochangercmd()
1242 * This test assumes that the append test has been done,
1243 * then it tests the fsf function.
1245 static int fsf_test()
1247 bool set_off = false;
1249 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1250 "This test is essential to Bacula.\n\n"
1251 "I'm going to write five files then test forward spacing\n\n"));
1255 weofcmd(); /* end file 0 */
1258 weofcmd(); /* end file 1 */
1262 weofcmd(); /* end file 2 */
1265 weofcmd(); /* end file 3 */
1267 weofcmd(); /* end file 4 */
1268 if (dev_cap(dev, CAP_TWOEOF)) {
1274 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1276 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1279 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1280 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1282 if (dev->file != 1) {
1286 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1288 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1291 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1292 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1294 if (dev->file != 3) {
1299 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1301 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1304 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1305 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1307 if (dev->file != 4) {
1311 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1312 " Fast Forward Space File = no\n\n"
1313 "to your Device resource for this drive.\n"));
1317 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1319 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1321 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1322 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1323 if (dev->file != 5) {
1326 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1330 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1331 if (dev_cap(dev, CAP_FASTFSF)) {
1332 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1333 "I am turning it off then retrying the test.\n"));
1334 dev->capabilities &= ~CAP_FASTFSF;
1338 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1339 "Some systems, e.g. OpenBSD, require you to set\n"
1340 " Use MTIOCGET= no\n"
1341 "in your device resource. Use with caution.\n"));
1350 * This is a general test of Bacula's functions
1351 * needed to read and write the tape.
1353 static void testcmd()
1357 if (!write_read_test()) {
1360 if (!position_test()) {
1364 stat = append_test();
1365 if (stat == 1) { /* OK get out */
1368 if (stat == -1) { /* first test failed */
1369 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1370 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1371 "Setting \"Hardware End of Medium = no\n"
1372 " and \"Fast Forward Space File = no\n"
1373 "and retrying append test.\n\n"));
1374 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1375 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1376 stat = append_test();
1378 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1379 " Hardware End of Medium = No\n\n"
1380 " Fast Forward Space File = No\n"
1381 "to your Device resource in the Storage conf file.\n"));
1385 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1388 /* Wrong count after append */
1390 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1391 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1392 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1393 stat = append_test();
1395 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1396 " Hardware End of Medium = No\n"
1397 " Fast Forward Space File = No\n"
1398 " BSF at EOM = yes\n\n"
1399 "to your Device resource in the Storage conf file.\n"));
1406 Pmsg0(-1, _("\nAppend test failed.\n\n"
1407 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1408 "Unable to correct the problem. You MUST fix this\n"
1409 "problem before Bacula can use your tape drive correctly\n"
1410 "\nPerhaps running Bacula in fixed block mode will work.\n"
1411 "Do so by setting:\n\n"
1412 "Minimum Block Size = nnn\n"
1413 "Maximum Block Size = nnn\n\n"
1414 "in your Storage daemon's Device definition.\n"
1415 "nnn must match your tape driver's block size, which\n"
1416 "can be determined by reading your tape manufacturers\n"
1417 "information, and the information on your kernel dirver.\n"
1418 "Fixed block sizes, however, are not normally an ideal solution.\n"
1420 "Some systems, e.g. OpenBSD, require you to set\n"
1421 " Use MTIOCGET= no\n"
1422 "in your device resource. Use with caution.\n"));
1427 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1428 "Please double check it ...\n"
1429 "=== Sample correct output ===\n"
1430 "1 block of 64448 bytes in file 1\n"
1431 "End of File mark.\n"
1432 "2 blocks of 64448 bytes in file 2\n"
1433 "End of File mark.\n"
1434 "3 blocks of 64448 bytes in file 3\n"
1435 "End of File mark.\n"
1436 "1 block of 64448 bytes in file 4\n"
1437 "End of File mark.\n"
1438 "Total files=4, blocks=7, bytes = 451,136\n"
1439 "=== End sample correct output ===\n\n"
1440 "If the above scan output is not identical to the\n"
1441 "sample output, you MUST correct the problem\n"
1442 "or Bacula will not be able to write multiple Jobs to \n"
1446 re_read_block_test();
1449 fsf_test(); /* do fast forward space file test */
1451 autochanger_test(); /* do autochanger test */
1455 /* Forward space a file */
1456 static void fsfcmd()
1460 num = atoi(argk[1]);
1465 if (!dev->fsf(num)) {
1466 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1470 Pmsg0(0, _("Forward spaced 1 file.\n"));
1473 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1477 /* Forward space a record */
1478 static void fsrcmd()
1482 num = atoi(argk[1]);
1487 if (!dev->fsr(num)) {
1488 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1492 Pmsg0(0, _("Forward spaced 1 record.\n"));
1495 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1501 * Write a Bacula block to the tape
1505 DEV_BLOCK *block = dcr->block;
1506 DEV_RECORD *rec = dcr->rec;
1509 sm_check(__FILE__, __LINE__, false);
1512 dump_block(block, "test");
1515 i = block->buf_len - 100;
1517 rec->data = check_pool_memory_size(rec->data, i);
1518 memset(rec->data, i & 0xFF, i);
1520 sm_check(__FILE__, __LINE__, false);
1521 if (!write_record_to_block(block, rec)) {
1522 Pmsg0(0, _("Error writing record to block.\n"));
1525 if (!write_block_to_dev(dcr)) {
1526 Pmsg0(0, _("Error writing block to device.\n"));
1529 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1531 Pmsg0(0, _("Wrote block to device.\n"));
1534 sm_check(__FILE__, __LINE__, false);
1535 sm_check(__FILE__, __LINE__, false);
1539 * Read a record from the tape
1546 if (!get_cmd(_("Enter length to read: "))) {
1550 if (len < 0 || len > 1000000) {
1551 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1554 buf = (char *)malloc(len);
1555 stat = read(dev->fd, buf, len);
1556 if (stat > 0 && stat <= len) {
1560 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1561 len, stat, be.strerror());
1567 * Scan tape by reading block by block. Report what is
1568 * on the tape. Note, this command does raw reads, and as such
1569 * will not work with fixed block size devices.
1571 static void scancmd()
1574 int blocks, tot_blocks, tot_files;
1580 blocks = block_size = tot_blocks = 0;
1582 if (dev->state & ST_EOT) {
1583 Pmsg0(0, _("End of tape\n"));
1586 update_pos_dev(dev);
1587 tot_files = dev->file;
1588 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1590 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1593 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1594 dev->dev_name, be.strerror());
1595 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1598 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1601 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1606 Dmsg1(200, "read status = %d\n", stat);
1608 if (stat != block_size) {
1609 update_pos_dev(dev);
1612 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1615 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1621 if (stat == 0) { /* EOF */
1622 update_pos_dev(dev);
1623 printf(_("End of File mark.\n"));
1624 /* Two reads of zero means end of tape */
1625 if (dev->state & ST_EOF)
1626 dev->state |= ST_EOT;
1628 dev->state |= ST_EOF;
1631 if (dev->state & ST_EOT) {
1632 printf(_("End of tape\n"));
1635 } else { /* Got data */
1636 dev->state &= ~ST_EOF;
1642 update_pos_dev(dev);
1643 tot_files = dev->file - tot_files;
1644 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1645 edit_uint64_with_commas(bytes, ec1));
1650 * Scan tape by reading Bacula block by block. Report what is
1651 * on the tape. This function reads Bacula blocks, so if your
1652 * Device resource is correctly defined, it should work with
1653 * either variable or fixed block sizes.
1655 static void scan_blocks()
1657 int blocks, tot_blocks, tot_files;
1658 uint32_t block_size;
1660 DEV_BLOCK *block = dcr->block;
1662 char buf1[100], buf2[100];
1664 blocks = block_size = tot_blocks = 0;
1668 update_pos_dev(dev);
1669 tot_files = dev->file;
1671 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1672 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1673 if (dev->state & ST_EOT) {
1676 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1679 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1685 if (dev->state & ST_EOF) {
1688 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1691 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1695 printf(_("End of File mark.\n"));
1698 if (dev->state & ST_SHORT) {
1701 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1704 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1708 printf(_("Short block read.\n"));
1711 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1714 if (block->block_len != block_size) {
1717 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1720 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1724 block_size = block->block_len;
1728 bytes += block->block_len;
1729 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1730 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1731 block->VolSessionId, block->VolSessionTime);
1733 DEV_RECORD *rec = new_record();
1734 read_record_from_block(block, rec);
1735 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1736 block->BlockNumber, dev->block_num, block->block_len,
1737 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1738 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1741 } else if (verbose > 1) {
1742 dump_block(block, "");
1747 tot_files = dev->file - tot_files;
1748 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1749 edit_uint64_with_commas(bytes, ec1));
1753 static void statcmd()
1755 int debug = debug_level;
1757 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1759 dump_volume_label(dev);
1761 debug_level = debug;
1766 * First we label the tape, then we fill
1767 * it with data get a new tape and write a few blocks.
1769 static void fillcmd()
1772 DEV_BLOCK *block = dcr->block;
1774 char buf1[100], buf2[100];
1777 uint32_t min_block_size;
1788 "This command simulates Bacula writing to a tape.\n"
1789 "It requires either one or two blank tapes, which it\n"
1790 "will label and write.\n\n"
1791 "If you have an autochanger configured, it will use\n"
1792 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1793 "be prompted to insert the tapes when necessary.\n\n"
1794 "It will print a status approximately\n"
1795 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1796 "selected the simple test option, after writing the first tape\n"
1797 "it will rewind it and re-read the last block written.\n\n"
1798 "If you have selected the multiple tape test, when the first tape\n"
1799 "fills, it will ask for a second, and after writing a few more \n"
1800 "blocks, it will stop. Then it will begin re-reading the\n"
1802 "This may take a long time -- hours! ...\n\n"));
1804 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1805 "or the complete multiple tape (m) test: (s/m) "));
1806 if (cmd[0] == 's') {
1807 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1809 } else if (cmd[0] == 'm') {
1810 Pmsg0(-1, _("Multiple tape test selected.\n"));
1813 Pmsg0(000, _("Command aborted.\n"));
1817 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1818 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1820 /* Use fixed block size to simplify read back */
1821 min_block_size = dev->min_block_size;
1822 dev->min_block_size = dev->max_block_size;
1823 set_volume_name("TestVolume1", 1);
1825 if (!dev->rewind(dcr)) {
1826 Pmsg0(000, _("Rewind failed.\n"));
1828 if (!dev->weof(1)) {
1829 Pmsg0(000, _("Write EOF failed.\n"));
1832 dev->set_append(); /* force volume to be relabeled */
1835 * Acquire output device for writing. Note, after acquiring a
1836 * device, we MUST release it, which is done at the end of this
1839 Dmsg0(100, "just before acquire_device\n");
1840 if (!acquire_device_for_append(dcr)) {
1841 set_jcr_job_status(jcr, JS_ErrorTerminated);
1844 block = jcr->dcr->block;
1846 Dmsg0(100, "Just after acquire_device_for_append\n");
1848 * Write Begin Session Record
1850 if (!write_session_label(dcr, SOS_LABEL)) {
1851 set_jcr_job_status(jcr, JS_ErrorTerminated);
1852 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1856 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1858 memset(&rec, 0, sizeof(rec));
1859 rec.data = get_memory(100000); /* max record size */
1861 #define REC_SIZE 32768
1862 rec.data_len = REC_SIZE;
1865 * Put some random data in the record
1867 fd = open("/dev/urandom", O_RDONLY);
1869 read(fd, rec.data, rec.data_len);
1872 uint32_t *p = (uint32_t *)rec.data;
1873 srandom(time(NULL));
1874 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1880 * Generate data as if from File daemon, write to device
1882 jcr->dcr->VolFirstIndex = 0;
1883 time(&jcr->run_time); /* start counting time for rates */
1884 localtime_r(&jcr->run_time, &tm);
1885 strftime(buf1, sizeof(buf1), "%T", &tm);
1887 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1889 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1891 for (file_index = 0; ok && !job_canceled(jcr); ) {
1892 rec.VolSessionId = jcr->VolSessionId;
1893 rec.VolSessionTime = jcr->VolSessionTime;
1894 rec.FileIndex = ++file_index;
1895 rec.Stream = STREAM_FILE_DATA;
1897 /* Mix up the data just a bit */
1898 uint32_t *lp = (uint32_t *)rec.data;
1900 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1904 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1905 rec.FileIndex, rec.VolSessionId,
1906 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1909 while (!write_record_to_block(block, &rec)) {
1911 * When we get here we have just filled a block
1913 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1916 /* Write block to tape */
1917 if (!flush_block(block, 1)) {
1921 /* Every 5000 blocks (approx 322MB) report where we are.
1923 if ((block->BlockNumber % 5000) == 0) {
1925 now -= jcr->run_time;
1927 now = 1; /* prevent divide error */
1929 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1930 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1931 block->BlockNumber, dev->block_num,
1932 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1934 /* Every 32000 blocks (approx 2GB) write an EOF.
1936 if ((block->BlockNumber % 32000) == 0) {
1938 localtime_r(&now, &tm);
1939 strftime(buf1, sizeof(buf1), "%T", &tm);
1940 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1941 flush_block(block, 0);
1945 /* Get out after writing 10 blocks to the second tape */
1946 if (++BlockNumber > 10 && stop != 0) { /* get out */
1951 Pmsg0(000, _("Not OK\n"));
1954 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1955 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1956 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1957 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1959 /* Get out after writing 10 blocks to the second tape */
1960 if (BlockNumber > 10 && stop != 0) { /* get out */
1961 Pmsg0(-1, "Done writing ...\n");
1966 Dmsg0(100, "Write_end_session_label()\n");
1967 /* Create Job status for end of session label */
1968 if (!job_canceled(jcr) && ok) {
1969 set_jcr_job_status(jcr, JS_Terminated);
1971 set_jcr_job_status(jcr, JS_ErrorTerminated);
1973 if (!write_session_label(dcr, EOS_LABEL)) {
1974 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
1977 /* Write out final block of this session */
1978 if (!write_block_to_device(dcr)) {
1979 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1982 Pmsg0(-1, _("Wrote End of Session label.\n"));
1984 /* Save last block info for second tape */
1985 last_block_num2 = last_block_num;
1986 last_file2 = last_file;
1988 free_block(last_block2);
1990 last_block2 = dup_block(last_block);
1993 sprintf(buf, "%s/btape.state", working_directory);
1994 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1996 write(fd, &btape_state_level, sizeof(btape_state_level));
1997 write(fd, &simple, sizeof(simple));
1998 write(fd, &last_block_num1, sizeof(last_block_num1));
1999 write(fd, &last_block_num2, sizeof(last_block_num2));
2000 write(fd, &last_file1, sizeof(last_file1));
2001 write(fd, &last_file2, sizeof(last_file2));
2002 write(fd, last_block1->buf, last_block1->buf_len);
2003 write(fd, last_block2->buf, last_block2->buf_len);
2004 write(fd, first_block->buf, first_block->buf_len);
2006 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2007 last_block_num1, last_block_num2);
2010 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2015 localtime_r(&now, &tm);
2016 strftime(buf1, sizeof(buf1), "%T", &tm);
2018 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2019 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2022 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2023 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2026 jcr->dcr->block = block;
2029 dev->min_block_size = min_block_size;
2030 free_memory(rec.data);
2034 * Read two tapes written by the "fill" command and ensure
2035 * that the data is valid. If stop==1 we simulate full read back
2036 * of two tapes. If stop==-1 we simply read the last block and
2037 * verify that it is correct.
2039 static void unfillcmd()
2043 last_block1 = new_block(dev);
2044 last_block2 = new_block(dev);
2045 first_block = new_block(dev);
2046 sprintf(buf, "%s/btape.state", working_directory);
2047 fd = open(buf, O_RDONLY);
2049 uint32_t state_level;
2050 read(fd, &state_level, sizeof(btape_state_level));
2051 read(fd, &simple, sizeof(simple));
2052 read(fd, &last_block_num1, sizeof(last_block_num1));
2053 read(fd, &last_block_num2, sizeof(last_block_num2));
2054 read(fd, &last_file1, sizeof(last_file1));
2055 read(fd, &last_file2, sizeof(last_file2));
2056 read(fd, last_block1->buf, last_block1->buf_len);
2057 read(fd, last_block2->buf, last_block2->buf_len);
2058 read(fd, first_block->buf, first_block->buf_len);
2060 if (state_level != btape_state_level) {
2061 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2062 "the fill command.\n"));
2067 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2068 "You must redo the fill command.\n"), buf, be.strerror());
2075 static void do_unfill()
2077 DEV_BLOCK *block = dcr->block;
2084 Dmsg0(20, "Enter do_unfill\n");
2085 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2086 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2090 time(&jcr->run_time); /* start counting time for rates */
2094 free_block(last_block);
2096 last_block_num = last_block_num1;
2097 last_file = last_file1;
2098 last_block = last_block1;
2101 /* Multiple Volume tape */
2102 /* Close device so user can use autochanger if desired */
2103 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2106 autochanger = autoload_device(dcr, 1, NULL);
2109 get_cmd(_("Mount first tape. Press enter when ready: "));
2111 free_restore_volume_list(jcr);
2112 jcr->dcr = new_dcr(jcr, dev);
2113 set_volume_name("TestVolume1", 1);
2115 create_restore_volume_list(jcr);
2117 dev->num_writers = 0;
2118 if (!acquire_device_for_read(dcr)) {
2119 Pmsg1(-1, "%s", dev->errmsg);
2124 * We now have the first tape mounted.
2125 * Note, re-reading last block may have caused us to
2126 * loose track of where we are (block number unknown).
2128 Pmsg0(-1, _("Rewinding.\n"));
2129 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2132 /* Read the first 10000 records */
2133 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2134 dev->file, dev->block_num);
2136 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2137 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2138 last_file, last_block_num);
2139 if (!dev->reposition(last_file, last_block_num)) {
2140 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2143 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2144 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2145 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2148 if (compare_blocks(last_block, block)) {
2150 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2152 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2159 /* restore info for last block on second Volume */
2160 last_block_num = last_block_num2;
2161 last_file = last_file2;
2162 last_block = last_block2;
2164 /* Multiple Volume tape */
2165 /* Close device so user can use autochanger if desired */
2166 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2170 free_restore_volume_list(jcr);
2171 set_volume_name("TestVolume2", 2);
2173 create_restore_volume_list(jcr);
2174 autochanger = autoload_device(dcr, 1, NULL);
2177 get_cmd(_("Mount second tape. Press enter when ready: "));
2181 if (!acquire_device_for_read(dcr)) {
2182 Pmsg1(-1, "%s", dev->errmsg);
2186 /* Space to "first" block which is last block not written
2187 * on the previous tape.
2189 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2190 if (!dev->reposition(0, 1)) {
2191 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2194 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2195 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2196 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2199 if (compare_blocks(first_block, block)) {
2200 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2203 /* Now find and compare the last block */
2204 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2205 last_file, last_block_num);
2206 if (!dev->reposition(last_file, last_block_num)) {
2207 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2210 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2211 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2212 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2215 if (compare_blocks(last_block, block)) {
2216 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2220 free_block(last_block1);
2221 free_block(last_block2);
2222 free_block(first_block);
2225 /* Read 10000 records then stop */
2226 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2228 DEVICE *dev = dcr->dev;
2230 if (quickie_count == 10000) {
2231 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2233 return quickie_count < 10000;
2236 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2239 uint32_t CheckSum, block_len;
2242 p = last_block->buf;
2244 unser_begin(q, BLKHDR2_LENGTH);
2245 unser_uint32(CheckSum);
2246 unser_uint32(block_len);
2247 while (q < (block->buf+block_len)) {
2254 dump_block(last_block, _("Last block written"));
2256 dump_block(block, _("Block read back"));
2257 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2258 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2259 "that was read back differ. The test FAILED !!!!\n"
2260 "This must be corrected before you use Bacula\n"
2261 "to write multi-tape Volumes.!!!!\n"));
2265 dump_block(last_block, _("Last block written"));
2266 dump_block(block, _("Block read back"));
2276 * Write current block to tape regardless of whether or
2277 * not it is full. If the tape fills, attempt to
2278 * acquire another tape.
2280 static int flush_block(DEV_BLOCK *block, int dump)
2284 uint32_t this_file, this_block_num;
2288 this_block = new_block(dev);
2291 last_block = new_block(dev);
2294 this_file = dev->file;
2295 this_block_num = dev->block_num;
2296 if (!write_block_to_dev(dcr)) {
2297 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2298 last_file, last_block_num, this_block_num);
2301 * This is 1st tape, so save first tape info separate
2302 * from second tape info
2304 last_block_num1 = last_block_num;
2305 last_file1 = last_file;
2306 last_block1 = dup_block(last_block);
2307 last_block2 = dup_block(last_block);
2308 first_block = dup_block(block); /* first block second tape */
2311 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2312 (unsigned)file_index, block->BlockNumber, block->block_len);
2313 dump_block(last_block, _("Last block written"));
2315 dump_block(block, _("Block not written"));
2318 eot_block = block->BlockNumber;
2319 eot_block_len = block->block_len;
2320 eot_FileIndex = file_index;
2324 now -= jcr->run_time;
2326 now = 1; /* don't divide by zero */
2328 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2329 vol_size = dev->VolCatInfo.VolCatBytes;
2330 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2331 dev->file, dev->block_num,
2332 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2335 stop = -1; /* stop, but do simplified test */
2337 /* Full test in progress */
2338 if (!fixup_device_block_write_error(jcr->dcr)) {
2339 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2344 BlockNumber = 0; /* start counting for second tape */
2347 return 1; /* end of tape reached */
2350 /* Save contents after write so that the header is serialized */
2351 memcpy(this_block->buf, block->buf, this_block->buf_len);
2354 * Note, we always read/write to block, but we toggle
2355 * copying it to one or another of two allocated blocks.
2356 * Switch blocks so that the block just successfully written is
2357 * always in last_block.
2359 tblock = last_block;
2360 last_block = this_block;
2361 this_block = tblock;
2362 last_file = this_file;
2363 last_block_num = this_block_num;
2371 * First we label the tape, then we fill
2372 * it with data get a new tape and write a few blocks.
2374 static void qfillcmd()
2376 DEV_BLOCK *block = dcr->block;
2377 DEV_RECORD *rec = dcr->rec;
2380 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2382 get_cmd(_("How many blocks do you want to write? (1000): "));
2389 sm_check(__FILE__, __LINE__, false);
2391 i = block->buf_len - 100;
2393 rec->data = check_pool_memory_size(rec->data, i);
2394 memset(rec->data, i & 0xFF, i);
2397 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2398 for (i=0; i < count; i++) {
2403 if (!write_record_to_block(block, rec)) {
2404 Pmsg0(0, _("Error writing record to block.\n"));
2407 if (!write_block_to_dev(dcr)) {
2408 Pmsg0(0, _("Error writing block to device.\n"));
2414 if (dev_cap(dev, CAP_TWOEOF)) {
2421 sm_check(__FILE__, __LINE__, false);
2425 * Fill a tape using raw write() command
2427 static void rawfill_cmd()
2429 DEV_BLOCK *block = dcr->block;
2432 uint32_t block_num = 0;
2437 fd = open("/dev/urandom", O_RDONLY);
2439 read(fd, block->buf, block->buf_len);
2442 uint32_t *p = (uint32_t *)block->buf;
2443 srandom(time(NULL));
2444 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2448 p = (uint32_t *)block->buf;
2449 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2452 stat = write(dev->fd, block->buf, block->buf_len);
2453 if (stat == (int)block->buf_len) {
2454 if ((block_num++ % 100) == 0) {
2459 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2469 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2470 be.strerror(my_errno));
2476 * Fill a tape using Bacula block writes
2478 static void bfill_cmd()
2480 DEV_BLOCK *block = dcr->block;
2481 uint32_t block_num = 0;
2487 fd = open("/dev/urandom", O_RDONLY);
2489 read(fd, block->buf, block->buf_len);
2492 uint32_t *p = (uint32_t *)block->buf;
2493 srandom(time(NULL));
2494 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2498 p = (uint32_t *)block->buf;
2499 Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2502 block->binbuf = block->buf_len;
2503 block->bufp = block->buf + block->binbuf;
2504 if (!write_block_to_dev(dcr)) {
2507 if ((block_num++ % 100) == 0) {
2512 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2518 printf(_("Write failed at block %u.\n"), block_num);
2523 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2524 static struct cmdstruct commands[] = {
2525 {N_("autochanger"),autochangercmd, _("test autochanger")},
2526 {N_("bsf"), bsfcmd, _("backspace file")},
2527 {N_("bsr"), bsrcmd, _("backspace record")},
2528 {N_("bfill"), bfill_cmd, _("fill tape using Bacula writes")},
2529 {N_("cap"), capcmd, _("list device capabilities")},
2530 {N_("clear"), clearcmd, _("clear tape errors")},
2531 {N_("eod"), eodcmd, _("go to end of Bacula data for append")},
2532 {N_("eom"), eomcmd, _("go to the physical end of medium")},
2533 {N_("fill"), fillcmd, _("fill tape, write onto second volume")},
2534 {N_("unfill"), unfillcmd, _("read filled tape")},
2535 {N_("fsf"), fsfcmd, _("forward space a file")},
2536 {N_("fsr"), fsrcmd, _("forward space a record")},
2537 {N_("help"), helpcmd, _("print this command")},
2538 {N_("label"), labelcmd, _("write a Bacula label to the tape")},
2539 {N_("load"), loadcmd, _("load a tape")},
2540 {N_("quit"), quitcmd, _("quit btape")},
2541 {N_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2542 {N_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2543 {N_("rectest"), rectestcmd, _("test record handling functions")},
2544 {N_("rewind"), rewindcmd, _("rewind the tape")},
2545 {N_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2546 {N_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2547 {N_("status"), statcmd, _("print tape status")},
2548 {N_("test"), testcmd, _("General test Bacula tape functions")},
2549 {N_("weof"), weofcmd, _("write an EOF on the tape")},
2550 {N_("wr"), wrcmd, _("write a single Bacula block")},
2551 {N_("rr"), rrcmd, _("read a single record")},
2552 {N_("qfill"), qfillcmd, _("quick fill command")}
2554 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2562 while (get_cmd("*")) {
2563 sm_check(__FILE__, __LINE__, false);
2565 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2566 for (i=0; i<comsize; i++) /* search for command */
2567 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2568 (*commands[i].func)(); /* go execute command */
2573 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2579 static void helpcmd()
2583 printf(_("Interactive commands:\n"));
2584 printf(_(" Command Description\n ======= ===========\n"));
2585 for (i=0; i<comsize; i++)
2586 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2593 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2594 "\nVersion: %s (%s)\n\n"
2595 "Usage: btape <options> <device_name>\n"
2596 " -b <file> specify bootstrap file\n"
2597 " -c <file> set configuration file to file\n"
2598 " -d <nn> set debug level to nn\n"
2599 " -p proceed inspite of I/O errors\n"
2600 " -s turn off signals\n"
2602 " -? print this message.\n"
2603 "\n"), VERSION, BDATE);
2608 * Get next input command from terminal. This
2609 * routine is REALLY primitive, and should be enhanced
2610 * to have correct backspacing, etc.
2613 get_cmd(const char *prompt)
2617 fprintf(stdout, prompt);
2619 /* We really should turn off echoing and pretty this
2623 while ((ch = fgetc(stdin)) != EOF) {
2625 strip_trailing_junk(cmd);
2627 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2640 /* Dummies to replace askdir.c */
2641 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2642 bool dir_send_job_status(JCR *jcr) {return 1;}
2644 bool dir_update_volume_info(DCR *dcr, bool relabel)
2650 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2652 Dmsg0(20, "Enter dir_get_volume_info\n");
2653 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2657 bool dir_create_jobmedia_record(DCR *dcr)
2659 dcr->WroteVol = false;
2664 bool dir_find_next_appendable_volume(DCR *dcr)
2666 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2667 return dcr->VolumeName[0] != 0;
2670 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2672 DEVICE *dev = dcr->dev;
2673 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2674 if (dcr->VolumeName[0] == 0) {
2675 return dir_ask_sysop_to_create_appendable_volume(dcr);
2678 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2679 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2680 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2683 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2684 dcr->VolumeName, dev->print_name());
2690 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2693 DEVICE *dev = dcr->dev;
2694 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2696 set_volume_name("TestVolume1", 1);
2698 set_volume_name("TestVolume2", 2);
2700 /* Close device so user can use autochanger if desired */
2701 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2704 autochanger = autoload_device(dcr, 1, NULL);
2707 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2718 static bool my_mount_next_read_volume(DCR *dcr)
2721 JCR *jcr = dcr->jcr;
2722 DEV_BLOCK *block = dcr->block;
2724 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2725 Pmsg1(000, _("End of Volume \"%s\"\n"), dcr->VolumeName);
2727 if (LastBlock != block->BlockNumber) {
2728 VolBytes += block->block_len;
2730 LastBlock = block->BlockNumber;
2732 now -= jcr->run_time;
2736 kbs = (double)VolBytes / (1000.0 * (double)now);
2737 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2738 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2740 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2745 free_restore_volume_list(jcr);
2746 set_volume_name("TestVolume2", 2);
2748 create_restore_volume_list(jcr);
2750 if (!acquire_device_for_read(dcr)) {
2751 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2754 return true; /* next volume mounted */
2757 static void set_volume_name(const char *VolName, int volnum)
2759 DCR *dcr = jcr->dcr;
2760 VolumeName = VolName;
2762 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2763 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2764 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2765 dcr->VolCatInfo.Slot = volnum;