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-2005 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 as
21 published by the Free Software Foundation; either version 2 of
22 the License, or (at your option) any later version.
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 GNU
27 General Public License for more details.
29 You should have received a copy of the GNU General Public
30 License along with this program; if not, write to the Free
31 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
40 /* External subroutines */
41 extern void free_config_resources();
43 /* Exported variables */
46 int bsize = TAPE_BSIZE;
47 char VolName[MAX_NAME_LENGTH];
48 STORES *me = NULL; /* our Global resource */
49 bool forge_on = false; /* proceed inspite of I/O errors */
50 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
51 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
54 * If you change the format of the state file,
55 * increment this value
57 static uint32_t btape_state_level = 2;
61 DEVRES *device = NULL;
64 /* Forward referenced subroutines */
65 static void do_tape_cmds();
66 static void helpcmd();
67 static void scancmd();
68 static void rewindcmd();
69 static void clearcmd();
73 static void fillcmd();
74 static void qfillcmd();
75 static void statcmd();
76 static void unfillcmd();
77 static int flush_block(DEV_BLOCK *block, int dump);
78 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
79 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
80 static bool my_mount_next_read_volume(DCR *dcr);
81 static void scan_blocks();
82 static void set_volume_name(const char *VolName, int volnum);
83 static void rawfill_cmd();
84 static void bfill_cmd();
85 static bool open_the_device();
86 static void autochangercmd();
87 static void do_unfill();
90 /* Static variables */
91 #define CONFIG_FILE "bacula-sd.conf"
94 #define MAX_CMD_ARGS 30
97 static char *argk[MAX_CMD_ARGS];
98 static char *argv[MAX_CMD_ARGS];
101 static int quickie_count = 0;
102 static BSR *bsr = NULL;
103 static int signals = TRUE;
106 static uint64_t vol_size;
107 static uint64_t VolBytes;
110 static int32_t file_index;
111 static int end_of_tape = 0;
112 static uint32_t LastBlock = 0;
113 static uint32_t eot_block;
114 static uint32_t eot_block_len;
115 static uint32_t eot_FileIndex;
116 static int dumped = 0;
117 static DEV_BLOCK *last_block1 = NULL;
118 static DEV_BLOCK *last_block2 = NULL;
119 static DEV_BLOCK *last_block = NULL;
120 static DEV_BLOCK *this_block = NULL;
121 static DEV_BLOCK *first_block = NULL;
122 static uint32_t last_file1 = 0;
123 static uint32_t last_file2 = 0;
124 static uint32_t last_file = 0;
125 static uint32_t last_block_num1 = 0;
126 static uint32_t last_block_num2 = 0;
127 static uint32_t last_block_num = 0;
128 static uint32_t BlockNumber = 0;
129 static bool simple = true;
131 static const char *VolumeName = NULL;
132 static int vol_num = 0;
134 static JCR *jcr = NULL;
138 static void terminate_btape(int sig);
139 int get_cmd(const char *prompt);
142 /*********************************************************************
144 * Main Bacula Pool Creation Program
147 int main(int margc, char *margv[])
155 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
156 Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
157 TAPE_BSIZE, B_DEV_BSIZE);
159 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
160 Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE);
162 if (sizeof(off_t) < 8) {
163 Pmsg1(-1, "\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n",
167 bsnprintf(buf, sizeof(buf), "%u", x32);
168 i = bsscanf(buf, "%u", &y32);
169 if (i != 1 || x32 != y32) {
170 Pmsg3(-1, "32 bit printf/scanf problem. i=%d x32=%u y32=%u\n", i, x32, y32);
176 bsnprintf(buf, sizeof(buf), "%" llu, x64);
177 i = bsscanf(buf, "%llu", &y64);
178 if (i != 1 || x64 != y64) {
179 Pmsg3(-1, "64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n", i, x64, y64);
183 printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
185 working_directory = "/tmp";
186 my_name_is(margc, margv, "btape");
187 init_msg(NULL, NULL);
189 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
191 case 'b': /* bootstrap file */
192 bsr = parse_bsr(NULL, optarg);
193 // dump_bsr(bsr, true);
196 case 'c': /* specify config file */
197 if (configfile != NULL) {
200 configfile = bstrdup(optarg);
203 case 'd': /* set debug level */
204 debug_level = atoi(optarg);
205 if (debug_level <= 0) {
232 cmd = get_pool_memory(PM_FNAME);
233 args = get_pool_memory(PM_FNAME);
236 init_signals(terminate_btape);
239 if (configfile == NULL) {
240 configfile = bstrdup(CONFIG_FILE);
243 daemon_start_time = time(NULL);
245 parse_config(configfile);
248 /* See if we can open a device */
250 Pmsg0(000, "No archive name specified.\n");
253 } else if (margc != 1) {
254 Pmsg0(000, "Improper number of arguments specified.\n");
259 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
268 if (!open_the_device()) {
272 Dmsg0(200, "Do tape commands\n");
280 static void terminate_btape(int stat)
283 sm_check(__FILE__, __LINE__, false);
287 free_config_resources();
289 free_pool_memory(args);
293 free_pool_memory(cmd);
308 if (debug_level > 10)
309 print_memory_pool_stats();
312 free_block(this_block);
317 close_memory_pool(); /* free memory in pool */
323 static bool open_the_device()
327 block = new_block(dev);
329 if (!dev->is_open()) {
330 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
331 if (open_dev(dev, dcr->VolumeName, OPEN_READ_WRITE) < 0) {
332 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
338 Pmsg1(000, "open_dev %s OK\n", dev->print_name());
339 dev->state |= ST_APPEND;
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(dev)) {
366 Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
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", strerror_dev(dev));
394 Pmsg0(0, "Volume name error\n");
396 case VOL_CREATE_ERROR:
397 Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
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", strerror_dev(dev));
426 Pmsg1(0, "Loaded %s\n", dev->print_name());
432 static void rewindcmd()
434 if (!rewind_dev(dev)) {
435 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
436 clrerror_dev(dev, -1);
438 Pmsg1(0, "Rewound %s\n", dev->print_name());
443 * Clear any tape error
445 static void clearcmd()
447 clrerror_dev(dev, -1);
451 * Write and end of file on the tape
453 static void weofcmd()
464 if ((stat = weof_dev(dev, num)) < 0) {
465 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
468 Pmsg3(0, "Wrote %d EOF%s to %s\n", num, num==1?"":"s", dev->print_name());
473 /* Go to the end of the medium -- raw command
474 * The idea was orginally that the end of the Bacula
475 * medium would be flagged differently. This is not
476 * currently the case. So, this is identical to the
482 Pmsg1(0, "%s", strerror_dev(dev));
485 Pmsg0(0, _("Moved to end of medium.\n"));
490 * Go to the end of the medium (either hardware determined
491 * or defined by two eofs.
511 if (!bsf_dev(dev, num)) {
512 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
514 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
530 if (!bsr_dev(dev, num)) {
531 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
533 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
538 * List device capabilities as defined in the
543 printf(_("Configured device capabilities:\n"));
544 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
545 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
546 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
547 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
548 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
549 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
550 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
551 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
552 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
553 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
554 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
555 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
556 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
557 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
558 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
561 printf(_("Device status:\n"));
562 printf("%sOPENED ", dev->is_open() ? "" : "!");
563 printf("%sTAPE ", dev->is_tape() ? "" : "!");
564 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
565 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
566 printf("%sAPPEND ", dev->can_append() ? "" : "!");
567 printf("%sREAD ", dev->can_read() ? "" : "!");
568 printf("%sEOT ", dev->at_eot() ? "" : "!");
569 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
570 printf("%sEOF ", dev->at_eof() ? "" : "!");
571 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
572 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
575 printf(_("Device parameters:\n"));
576 printf("Device name: %s\n", dev->dev_name);
577 printf("File=%u block=%u\n", dev->file, dev->block_num);
578 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
586 * Test writting larger and larger records.
587 * This is a torture test for records.
589 static void rectestcmd()
595 Pmsg0(0, "Test writting larger and larger records.\n"
596 "This is a torture test for records.\nI am going to write\n"
597 "larger and larger records. It will stop when the record size\n"
598 "plus the header exceeds the block size (by default about 64K)\n");
601 get_cmd("Do you want to continue? (y/n): ");
603 Pmsg0(000, "Command aborted.\n");
607 sm_check(__FILE__, __LINE__, false);
608 block = new_block(dev);
611 for (i=1; i<500000; i++) {
612 rec->data = check_pool_memory_size(rec->data, i);
613 memset(rec->data, i & 0xFF, i);
615 sm_check(__FILE__, __LINE__, false);
616 if (write_record_to_block(block, rec)) {
619 Pmsg2(0, "Block %d i=%d\n", blkno, i);
623 sm_check(__FILE__, __LINE__, false);
627 sm_check(__FILE__, __LINE__, false);
631 * This test attempts to re-read a block written by Bacula
632 * normally at the end of the tape. Bacula will then back up
633 * over the two eof marks, backup over the record and reread
634 * it to make sure it is valid. Bacula can skip this validation
635 * if you set "Backward space record = no"
637 static int re_read_block_test()
639 DEV_BLOCK *block = dcr->block;
644 if (!(dev->capabilities & CAP_BSR)) {
645 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
649 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
650 "I'm going to write three records and an EOF\n"
651 "then backup over the EOF and re-read the last record.\n"
652 "Bacula does this after writing the last block on the\n"
653 "tape to verify that the block was written correctly.\n\n"
654 "This is not an *essential* feature ...\n\n"));
658 rec->data = check_pool_memory_size(rec->data, block->buf_len);
659 len = rec->data_len = block->buf_len-100;
660 memset(rec->data, 1, rec->data_len);
661 if (!write_record_to_block(block, rec)) {
662 Pmsg0(0, _("Error writing record to block.\n"));
665 if (!write_block_to_dev(dcr)) {
666 Pmsg0(0, _("Error writing block to device.\n"));
669 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
671 memset(rec->data, 2, rec->data_len);
672 if (!write_record_to_block(block, rec)) {
673 Pmsg0(0, _("Error writing record to block.\n"));
676 if (!write_block_to_dev(dcr)) {
677 Pmsg0(0, _("Error writing block to device.\n"));
680 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
682 memset(rec->data, 3, rec->data_len);
683 if (!write_record_to_block(block, rec)) {
684 Pmsg0(0, _("Error writing record to block.\n"));
687 if (!write_block_to_dev(dcr)) {
688 Pmsg0(0, _("Error writing block to device.\n"));
691 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
694 if (dev_cap(dev, CAP_TWOEOF)) {
697 if (!bsf_dev(dev, 1)) {
698 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
701 if (dev_cap(dev, CAP_TWOEOF)) {
702 if (!bsf_dev(dev, 1)) {
703 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
707 Pmsg0(0, "Backspaced over EOF OK.\n");
708 if (!bsr_dev(dev, 1)) {
709 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
712 Pmsg0(0, "Backspace record OK.\n");
713 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
715 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
718 memset(rec->data, 0, rec->data_len);
719 if (!read_record_from_block(block, rec)) {
721 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
724 for (int i=0; i<len; i++) {
725 if (rec->data[i] != 3) {
726 Pmsg0(0, _("Bad data in record. Test failed!\n"));
730 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
731 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
738 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
739 "this function to verify the last block written to the\n"
740 "tape. Bacula will skip the last block verification\n"
742 "Backward Space Record = No\n\n"
743 "to your Storage daemon's Device resource definition.\n"));
750 * This test writes Bacula blocks to the tape in
751 * several files. It then rewinds the tape and attepts
752 * to read these blocks back checking the data.
754 static int write_read_test()
762 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
763 "I'm going to write 1000 records and an EOF\n"
764 "then write 1000 records and an EOF, then rewind,\n"
765 "and re-read the data to verify that it is correct.\n\n"
766 "This is an *essential* feature ...\n\n"));
769 if (!rewind_dev(dev)) {
770 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
773 rec->data = check_pool_memory_size(rec->data, block->buf_len);
774 rec->data_len = block->buf_len-100;
775 len = rec->data_len/sizeof(i);
776 for (i=1; i<=1000; i++) {
777 p = (int *)rec->data;
778 for (j=0; j<len; j++) {
781 if (!write_record_to_block(block, rec)) {
782 Pmsg0(0, _("Error writing record to block.\n"));
785 if (!write_block_to_dev(dcr)) {
786 Pmsg0(0, _("Error writing block to device.\n"));
790 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
792 for (i=1001; i<=2000; i++) {
793 p = (int *)rec->data;
794 for (j=0; j<len; j++) {
797 if (!write_record_to_block(block, rec)) {
798 Pmsg0(0, _("Error writing record to block.\n"));
801 if (!write_block_to_dev(dcr)) {
802 Pmsg0(0, _("Error writing block to device.\n"));
806 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
808 if (dev_cap(dev, CAP_TWOEOF)) {
811 if (!rewind_dev(dev)) {
812 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
815 Pmsg0(0, "Rewind OK.\n");
817 for (i=1; i<=2000; i++) {
819 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
821 if (dev_state(dev, ST_EOF)) {
822 Pmsg0(-1, _("Got EOF on tape.\n"));
827 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
830 memset(rec->data, 0, rec->data_len);
831 if (!read_record_from_block(block, rec)) {
833 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
836 p = (int *)rec->data;
837 for (j=0; j<len; j++) {
839 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
845 if (i == 1000 || i == 2000) {
846 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
849 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
858 * This test writes Bacula blocks to the tape in
859 * several files. It then rewinds the tape and attepts
860 * to read these blocks back checking the data.
862 static int position_test()
864 DEV_BLOCK *block = dcr->block;
870 int file = 0, blk = 0;
872 bool got_eof = false;
874 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
875 "I'm going to write 1000 records and an EOF\n"
876 "then write 1000 records and an EOF, then rewind,\n"
877 "and position to a few blocks and verify that it is correct.\n\n"
878 "This is an *essential* feature ...\n\n"));
881 if (!rewind_dev(dev)) {
882 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
885 rec->data = check_pool_memory_size(rec->data, block->buf_len);
886 rec->data_len = block->buf_len-100;
887 len = rec->data_len/sizeof(i);
888 for (i=1; i<=1000; i++) {
889 p = (int *)rec->data;
890 for (j=0; j<len; j++) {
893 if (!write_record_to_block(block, rec)) {
894 Pmsg0(0, _("Error writing record to block.\n"));
897 if (!write_block_to_dev(dcr)) {
898 Pmsg0(0, _("Error writing block to device.\n"));
902 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
904 for (i=1001; i<=2000; i++) {
905 p = (int *)rec->data;
906 for (j=0; j<len; j++) {
909 if (!write_record_to_block(block, rec)) {
910 Pmsg0(0, _("Error writing record to block.\n"));
913 if (!write_block_to_dev(dcr)) {
914 Pmsg0(0, _("Error writing block to device.\n"));
918 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
920 if (dev_cap(dev, CAP_TWOEOF)) {
923 if (!rewind_dev(dev)) {
924 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
927 Pmsg0(0, "Rewind OK.\n");
931 /* Set up next item to read based on where we are */
967 Pmsg2(-1, "Reposition to file:block %d:%d\n", file, blk);
968 if (!reposition_dev(dev, file, blk)) {
969 Pmsg0(0, "Reposition error.\n");
973 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
975 if (dev_state(dev, ST_EOF)) {
976 Pmsg0(-1, _("Got EOF on tape.\n"));
982 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
983 recno, file, blk, be.strerror(dev->dev_errno));
984 Pmsg0(0, _("This may be because the tape drive block size is not\n"
985 " set to variable blocking as normally used by Bacula.\n"
986 " Please see the Tape Testing chapter in the manual and \n"
987 " look for using mt with defblksize and setoptions\n"
988 "If your tape drive block size is correct, then perhaps\n"
989 " your SCSI driver is *really* stupid and does not\n"
990 " correctly report the file:block after a FSF. In this\n"
991 " case try setting:\n"
992 " Fast Forward Space File = no\n"
993 " in your Device resource.\n"));
997 memset(rec->data, 0, rec->data_len);
998 if (!read_record_from_block(block, rec)) {
1000 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1003 p = (int *)rec->data;
1004 for (j=0; j<len; j++) {
1005 if (p[j] != recno) {
1006 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1011 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1013 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1025 * This test writes some records, then writes an end of file,
1026 * rewinds the tape, moves to the end of the data and attepts
1027 * to append to the tape. This function is essential for
1028 * Bacula to be able to write multiple jobs to the tape.
1030 static int append_test()
1032 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1033 "This test is essential to Bacula.\n\n"
1034 "I'm going to write one record in file 0,\n"
1035 " two records in file 1,\n"
1036 " and three records in file 2\n\n"));
1040 weofcmd(); /* end file 0 */
1043 weofcmd(); /* end file 1 */
1047 weofcmd(); /* end file 2 */
1048 if (dev_cap(dev, CAP_TWOEOF)) {
1051 force_close_dev(dev); /* release device */
1052 if (!open_the_device()) {
1056 Pmsg0(0, _("Now moving to end of medium.\n"));
1058 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1059 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1061 if (dev->file != 3) {
1065 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1068 if (dev_cap(dev, CAP_TWOEOF)) {
1072 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1073 Pmsg0(-1, "Doing Bacula scan of blocks:\n");
1075 Pmsg0(-1, _("End scanning the tape.\n"));
1076 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1077 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1079 if (dev->file != 4) {
1087 * This test exercises the autochanger
1089 static int autochanger_test()
1091 POOLMEM *results, *changer;
1092 int slot, status, loaded;
1093 int timeout = dcr->device->max_changer_wait;
1096 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1097 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1100 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1101 Pmsg0(-1, "\nAutochanger enabled, but no name or no command device specified.\n");
1105 Pmsg0(-1, "\nAh, I see you have an autochanger configured.\n"
1106 "To test the autochanger you must have a blank tape\n"
1107 " that I can write on in Slot 1.\n");
1108 if (!get_cmd("\nDo you wish to continue with the Autochanger test? (y/n): ")) {
1111 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1115 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1117 results = get_pool_memory(PM_MESSAGE);
1118 changer = get_pool_memory(PM_FNAME);
1122 dcr->VolCatInfo.Slot = slot;
1123 /* Find out what is loaded, zero means device is unloaded */
1124 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1125 changer = edit_device_codes(dcr, changer, "loaded");
1126 status = run_program(changer, timeout, results);
1127 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1129 loaded = atoi(results);
1132 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1133 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1137 Pmsg1(-1, "Slot %d loaded. I am going to unload it.\n", loaded);
1139 Pmsg0(-1, "Nothing loaded in the drive. OK.\n");
1141 Dmsg1(100, "Results from loaded query=%s\n", results);
1143 dcr->VolCatInfo.Slot = loaded;
1144 offline_or_rewind_dev(dev);
1145 /* We are going to load a new tape, so close the device */
1146 force_close_dev(dev);
1147 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1148 loaded, dev->drive_index);
1149 changer = edit_device_codes(dcr, changer, "unload");
1150 status = run_program(changer, timeout, results);
1151 Pmsg2(-1, "unload status=%s %d\n", status==0?"OK":"Bad", status);
1154 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1155 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1164 dcr->VolCatInfo.Slot = slot;
1165 Pmsg2(-1, _("3303 Issuing autochanger \"load slot %d %d\" command.\n"),
1166 slot, dev->drive_index);
1167 changer = edit_device_codes(dcr, changer, "load");
1168 Dmsg1(100, "Changer=%s\n", changer);
1169 force_close_dev(dev);
1170 status = run_program(changer, timeout, results);
1172 Pmsg2(-1, _("3303 Autochanger \"load slot %d %d\" status is OK.\n"),
1173 slot, dev->drive_index);
1176 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1177 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1181 if (!open_the_device()) {
1185 * Start with sleep_time 0 then increment by 30 seconds if we get
1188 bmicrosleep(sleep_time, 0);
1189 if (!rewind_dev(dev) || weof_dev(dev,1) < 0) {
1190 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
1191 clrerror_dev(dev, -1);
1192 Pmsg0(-1, "\nThe test failed, probably because you need to put\n"
1193 "a longer sleep time in the mtx-script in the load) case.\n"
1194 "Adding a 30 second sleep and trying again ...\n");
1198 Pmsg1(0, "Rewound %s\n", dev->print_name());
1201 if ((status = weof_dev(dev, 1)) < 0) {
1202 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", status, strerror_dev(dev));
1205 Pmsg1(0, "Wrote EOF to %s\n", dev->print_name());
1209 Pmsg1(-1, "\nThe test worked this time. Please add:\n\n"
1211 "to your mtx-changer script in the load) case.\n\n",
1214 Pmsg0(-1, "\nThe test autochanger worked!!\n\n");
1217 free_pool_memory(changer);
1218 free_pool_memory(results);
1223 free_pool_memory(changer);
1224 free_pool_memory(results);
1225 Pmsg0(-1, "You must correct this error or the Autochanger will not work.\n");
1229 static void autochangercmd()
1236 * This test assumes that the append test has been done,
1237 * then it tests the fsf function.
1239 static int fsf_test()
1241 bool set_off = false;
1243 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1244 "This test is essential to Bacula.\n\n"
1245 "I'm going to write five files then test forward spacing\n\n"));
1249 weofcmd(); /* end file 0 */
1252 weofcmd(); /* end file 1 */
1256 weofcmd(); /* end file 2 */
1259 weofcmd(); /* end file 3 */
1261 weofcmd(); /* end file 4 */
1262 if (dev_cap(dev, CAP_TWOEOF)) {
1268 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1269 if (!fsf_dev(dev, 1)) {
1270 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1273 Pmsg2(-1, _("We should be in file 1. I am at file %d. This is %s\n"),
1274 dev->file, dev->file == 1 ? "correct!" : "NOT correct!!!!");
1276 if (dev->file != 1) {
1280 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1281 if (!fsf_dev(dev, 2)) {
1282 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1285 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1286 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1288 if (dev->file != 3) {
1293 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1294 if (!fsf_dev(dev, 4)) {
1295 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1298 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1299 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1301 if (dev->file != 4) {
1305 Pmsg0(-1, "The test worked this time. Please add:\n\n"
1306 " Fast Forward Space File = no\n\n"
1307 "to your Device resource for this drive.\n");
1311 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1312 if (!fsf_dev(dev, 1)) {
1313 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1315 Pmsg2(-1, _("We should be in file 5. I am at file %d. This is %s\n"),
1316 dev->file, dev->file == 5 ? "correct!" : "NOT correct!!!!");
1317 if (dev->file != 5) {
1320 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1324 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1325 if (dev_cap(dev, CAP_FASTFSF)) {
1326 Pmsg0(-1, "You have Fast Forward Space File enabled.\n"
1327 "I am turning it off then retrying the test.\n");
1328 dev->capabilities &= ~CAP_FASTFSF;
1332 Pmsg0(-1, "You must correct this error or Bacula will not work.\n"
1333 "Some systems, e.g. OpenBSD, require you to set\n"
1334 " Use MTIOCGET= no\n"
1335 "in your device resource. Use with caution.\n");
1344 * This is a general test of Bacula's functions
1345 * needed to read and write the tape.
1347 static void testcmd()
1351 if (!write_read_test()) {
1354 if (!position_test()) {
1358 stat = append_test();
1359 if (stat == 1) { /* OK get out */
1362 if (stat == -1) { /* first test failed */
1363 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1364 Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
1365 "Setting \"Hardware End of Medium = no\n"
1366 " and \"Fast Forward Space File = no\n"
1367 "and retrying append test.\n\n");
1368 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1369 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1370 stat = append_test();
1372 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1373 " Hardware End of Medium = No\n\n"
1374 " Fast Forward Space File = No\n"
1375 "to your Device resource in the Storage conf file.\n");
1379 Pmsg0(-1, "\n\nThat appears *NOT* to have corrected the problem.\n");
1382 /* Wrong count after append */
1384 Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
1385 "Setting \"BSF at EOM = yes\" and retrying append test.\n");
1386 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1387 stat = append_test();
1389 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1390 " Hardware End of Medium = No\n"
1391 " Fast Forward Space File = No\n"
1392 " BSF at EOM = yes\n\n"
1393 "to your Device resource in the Storage conf file.\n");
1400 Pmsg0(-1, "\nAppend test failed.\n\n");
1401 Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1402 "Unable to correct the problem. You MUST fix this\n"
1403 "problem before Bacula can use your tape drive correctly\n");
1404 Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
1405 "Do so by setting:\n\n"
1406 "Minimum Block Size = nnn\n"
1407 "Maximum Block Size = nnn\n\n"
1408 "in your Storage daemon's Device definition.\n"
1409 "nnn must match your tape driver's block size, which\n"
1410 "can be determined by reading your tape manufacturers\n"
1411 "information, and the information on your kernel dirver.\n"
1412 "Fixed block sizes, however, are not normally an ideal solution.\n"
1414 "Some systems, e.g. OpenBSD, require you to set\n"
1415 " Use MTIOCGET= no\n"
1416 "in your device resource. Use with caution.\n");
1421 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1422 "Please double check it ...\n"
1423 "=== Sample correct output ===\n"
1424 "1 block of 64448 bytes in file 1\n"
1425 "End of File mark.\n"
1426 "2 blocks of 64448 bytes in file 2\n"
1427 "End of File mark.\n"
1428 "3 blocks of 64448 bytes in file 3\n"
1429 "End of File mark.\n"
1430 "1 block of 64448 bytes in file 4\n"
1431 "End of File mark.\n"
1432 "Total files=4, blocks=7, bytes = 451,136\n"
1433 "=== End sample correct output ===\n\n"));
1435 Pmsg0(-1, _("If the above scan output is not identical to the\n"
1436 "sample output, you MUST correct the problem\n"
1437 "or Bacula will not be able to write multiple Jobs to \n"
1441 re_read_block_test();
1444 fsf_test(); /* do fast forward space file test */
1446 autochanger_test(); /* do autochanger test */
1450 /* Forward space a file */
1451 static void fsfcmd()
1455 num = atoi(argk[1]);
1460 if (!fsf_dev(dev, num)) {
1461 Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
1464 Pmsg2(0, "Forward spaced %d file%s.\n", num, num==1?"":"s");
1467 /* Forward space a record */
1468 static void fsrcmd()
1472 num = atoi(argk[1]);
1477 if (!fsr_dev(dev, num)) {
1478 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1481 Pmsg2(0, "Forward spaced %d record%s.\n", num, num==1?"":"s");
1486 * Write a Bacula block to the tape
1490 DEV_BLOCK *block = dcr->block;
1491 DEV_RECORD *rec = dcr->rec;
1494 sm_check(__FILE__, __LINE__, false);
1497 dump_block(block, "test");
1500 i = block->buf_len - 100;
1502 rec->data = check_pool_memory_size(rec->data, i);
1503 memset(rec->data, i & 0xFF, i);
1505 sm_check(__FILE__, __LINE__, false);
1506 if (!write_record_to_block(block, rec)) {
1507 Pmsg0(0, _("Error writing record to block.\n"));
1510 if (!write_block_to_dev(dcr)) {
1511 Pmsg0(0, _("Error writing block to device.\n"));
1514 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1516 Pmsg0(0, _("Wrote block to device.\n"));
1519 sm_check(__FILE__, __LINE__, false);
1520 sm_check(__FILE__, __LINE__, false);
1524 * Read a record from the tape
1531 if (!get_cmd("Enter length to read: ")) {
1535 if (len < 0 || len > 1000000) {
1536 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1539 buf = (char *)malloc(len);
1540 stat = read(dev->fd, buf, len);
1541 if (stat > 0 && stat <= len) {
1545 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1546 len, stat, be.strerror());
1552 * Scan tape by reading block by block. Report what is
1553 * on the tape. Note, this command does raw reads, and as such
1554 * will not work with fixed block size devices.
1556 static void scancmd()
1559 int blocks, tot_blocks, tot_files;
1565 blocks = block_size = tot_blocks = 0;
1567 if (dev->state & ST_EOT) {
1568 Pmsg0(0, "End of tape\n");
1571 update_pos_dev(dev);
1572 tot_files = dev->file;
1573 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1575 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1577 clrerror_dev(dev, -1);
1578 Mmsg2(dev->errmsg, "read error on %s. ERR=%s.\n",
1579 dev->dev_name, be.strerror());
1580 Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
1582 printf("%d block%s of %d bytes in file %d\n",
1583 blocks, blocks>1?"s":"", block_size, dev->file);
1586 Dmsg1(200, "read status = %d\n", stat);
1588 if (stat != block_size) {
1589 update_pos_dev(dev);
1591 printf("%d block%s of %d bytes in file %d\n",
1592 blocks, blocks>1?"s":"", block_size, dev->file);
1597 if (stat == 0) { /* EOF */
1598 update_pos_dev(dev);
1599 printf("End of File mark.\n");
1600 /* Two reads of zero means end of tape */
1601 if (dev->state & ST_EOF)
1602 dev->state |= ST_EOT;
1604 dev->state |= ST_EOF;
1607 if (dev->state & ST_EOT) {
1608 printf("End of tape\n");
1611 } else { /* Got data */
1612 dev->state &= ~ST_EOF;
1618 update_pos_dev(dev);
1619 tot_files = dev->file - tot_files;
1620 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1621 edit_uint64_with_commas(bytes, ec1));
1626 * Scan tape by reading Bacula block by block. Report what is
1627 * on the tape. This function reads Bacula blocks, so if your
1628 * Device resource is correctly defined, it should work with
1629 * either variable or fixed block sizes.
1631 static void scan_blocks()
1633 int blocks, tot_blocks, tot_files;
1634 uint32_t block_size;
1636 DEV_BLOCK *block = dcr->block;
1639 blocks = block_size = tot_blocks = 0;
1643 update_pos_dev(dev);
1644 tot_files = dev->file;
1646 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1647 Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
1648 if (dev->state & ST_EOT) {
1650 printf("%d block%s of %d bytes in file %d\n",
1651 blocks, blocks>1?"s":"", block_size, dev->file);
1656 if (dev->state & ST_EOF) {
1658 printf("%d block%s of %d bytes in file %d\n",
1659 blocks, blocks>1?"s":"", block_size, dev->file);
1662 printf(_("End of File mark.\n"));
1665 if (dev->state & ST_SHORT) {
1667 printf("%d block%s of %d bytes in file %d\n",
1668 blocks, blocks>1?"s":"", block_size, dev->file);
1671 printf(_("Short block read.\n"));
1674 printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1677 if (block->block_len != block_size) {
1679 printf("%d block%s of %d bytes in file %d\n",
1680 blocks, blocks>1?"s":"", block_size, dev->file);
1683 block_size = block->block_len;
1687 bytes += block->block_len;
1688 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1689 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1690 block->VolSessionId, block->VolSessionTime);
1692 DEV_RECORD *rec = new_record();
1693 read_record_from_block(block, rec);
1694 Pmsg8(-1, "Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
1695 block->BlockNumber, dev->block_num, block->block_len,
1696 FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1697 stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
1700 } else if (verbose > 1) {
1701 dump_block(block, "");
1706 tot_files = dev->file - tot_files;
1707 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1708 edit_uint64_with_commas(bytes, ec1));
1712 static void statcmd()
1714 int debug = debug_level;
1716 Pmsg2(0, "Device status: %u. ERR=%s\n", status_dev(dev), strerror_dev(dev));
1718 dump_volume_label(dev);
1720 debug_level = debug;
1725 * First we label the tape, then we fill
1726 * it with data get a new tape and write a few blocks.
1728 static void fillcmd()
1731 DEV_BLOCK *block = dcr->block;
1735 uint32_t min_block_size;
1745 "This command simulates Bacula writing to a tape.\n"
1746 "It requires either one or two blank tapes, which it\n"
1747 "will label and write.\n\n"
1748 "If you have an autochanger configured, it will use\n"
1749 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1750 "be prompted to insert the tapes when necessary.\n\n"
1751 "It will print a status approximately\n"
1752 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1753 "selected the simple test option, after writing the first tape\n"
1754 "it will rewind it and re-read the last block written.\n\n"
1755 "If you have selected the multiple tape test, when the first tape\n"
1756 "fills, it will ask for a second, and after writing a few more \n"
1757 "blocks, it will stop. Then it will begin re-reading the\n"
1759 "This may take a long time -- hours! ...\n\n");
1761 get_cmd("Do you want to run the simplified test (s) with one tape\n"
1762 "or the complete multiple tape (m) test: (s/m) ");
1763 if (cmd[0] == 's') {
1764 Pmsg0(-1, "Simple test (single tape) selected.\n");
1766 } else if (cmd[0] == 'm') {
1767 Pmsg0(-1, "Multiple tape test selected.\n");
1770 Pmsg0(000, "Command aborted.\n");
1774 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1775 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1777 /* Use fixed block size to simplify read back */
1778 min_block_size = dev->min_block_size;
1779 dev->min_block_size = dev->max_block_size;
1780 set_volume_name("TestVolume1", 1);
1782 if (!dev->rewind()) {
1783 Pmsg0(000, "Rewind failed.\n");
1786 Pmsg0(000, "Write EOF failed.\n");
1789 dev->set_append(); /* force volume to be relabeled */
1792 * Acquire output device for writing. Note, after acquiring a
1793 * device, we MUST release it, which is done at the end of this
1796 Dmsg0(100, "just before acquire_device\n");
1797 if (!acquire_device_for_append(jcr, dev)) {
1798 set_jcr_job_status(jcr, JS_ErrorTerminated);
1801 block = jcr->dcr->block;
1803 Dmsg0(100, "Just after acquire_device_for_append\n");
1805 * Write Begin Session Record
1807 if (!write_session_label(dcr, SOS_LABEL)) {
1808 set_jcr_job_status(jcr, JS_ErrorTerminated);
1809 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1813 Pmsg0(-1, "Wrote Start of Session label.\n");
1815 memset(&rec, 0, sizeof(rec));
1816 rec.data = get_memory(100000); /* max record size */
1818 #define REC_SIZE 32768
1819 rec.data_len = REC_SIZE;
1822 * Put some random data in the record
1824 fd = open("/dev/urandom", O_RDONLY);
1826 read(fd, rec.data, rec.data_len);
1829 uint32_t *p = (uint32_t *)rec.data;
1830 srandom(time(NULL));
1831 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1837 * Generate data as if from File daemon, write to device
1839 jcr->dcr->VolFirstIndex = 0;
1840 time(&jcr->run_time); /* start counting time for rates */
1842 Pmsg0(-1, "Begin writing Bacula records to tape ...\n");
1844 Pmsg0(-1, "Begin writing Bacula records to first tape ...\n");
1846 for (file_index = 0; ok && !job_canceled(jcr); ) {
1847 rec.VolSessionId = jcr->VolSessionId;
1848 rec.VolSessionTime = jcr->VolSessionTime;
1849 rec.FileIndex = ++file_index;
1850 rec.Stream = STREAM_FILE_DATA;
1852 /* Mix up the data just a bit */
1853 uint32_t *lp = (uint32_t *)rec.data;
1855 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1859 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1860 rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1863 while (!write_record_to_block(block, &rec)) {
1865 * When we get here we have just filled a block
1867 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1870 /* Write block to tape */
1871 if (!flush_block(block, 1)) {
1875 /* Every 5000 blocks (approx 322MB) report where we are.
1877 if ((block->BlockNumber % 5000) == 0) {
1879 now -= jcr->run_time;
1881 now = 1; /* prevent divide error */
1883 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1884 Pmsg4(-1, "Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n",
1885 block->BlockNumber, dev->block_num,
1886 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1888 /* Every 15000 blocks (approx 1GB) write an EOF.
1890 if ((block->BlockNumber % 15000) == 0) {
1891 Pmsg0(-1, "Flush block, write EOF\n");
1892 flush_block(block, 0);
1896 /* Get out after writing 10 blocks to the second tape */
1897 if (++BlockNumber > 10 && stop != 0) { /* get out */
1902 Pmsg0(000, _("Not OK\n"));
1905 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1906 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1907 FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1908 stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1910 /* Get out after writing 10 blocks to the second tape */
1911 if (BlockNumber > 10 && stop != 0) { /* get out */
1912 Pmsg0(-1, "Done writing ...\n");
1917 Dmsg0(100, "Write_end_session_label()\n");
1918 /* Create Job status for end of session label */
1919 if (!job_canceled(jcr) && ok) {
1920 set_jcr_job_status(jcr, JS_Terminated);
1922 set_jcr_job_status(jcr, JS_ErrorTerminated);
1924 if (!write_session_label(dcr, EOS_LABEL)) {
1925 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1928 /* Write out final block of this session */
1929 if (!write_block_to_device(dcr)) {
1930 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1933 Pmsg0(-1, _("Wrote End of Session label.\n"));
1935 /* Save last block info for second tape */
1936 last_block_num2 = last_block_num;
1937 last_file2 = last_file;
1939 free_block(last_block2);
1941 last_block2 = dup_block(last_block);
1944 sprintf(buf, "%s/btape.state", working_directory);
1945 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1947 write(fd, &btape_state_level, sizeof(btape_state_level));
1948 write(fd, &simple, sizeof(simple));
1949 write(fd, &last_block_num1, sizeof(last_block_num1));
1950 write(fd, &last_block_num2, sizeof(last_block_num2));
1951 write(fd, &last_file1, sizeof(last_file1));
1952 write(fd, &last_file2, sizeof(last_file2));
1953 write(fd, last_block1->buf, last_block1->buf_len);
1954 write(fd, last_block2->buf, last_block2->buf_len);
1955 write(fd, first_block->buf, first_block->buf_len);
1957 Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
1958 last_block_num1, last_block_num2);
1961 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
1965 Pmsg4(-1, _("\n\nDone filling tape%s at %d:%d. Now beginning re-read of %stape ...\n"),
1966 simple?"":"s", jcr->dcr->dev->file, jcr->dcr->dev->block_num, simple?"":"first ");
1968 jcr->dcr->block = block;
1971 dev->min_block_size = min_block_size;
1972 free_memory(rec.data);
1976 * Read two tapes written by the "fill" command and ensure
1977 * that the data is valid. If stop==1 we simulate full read back
1978 * of two tapes. If stop==-1 we simply read the last block and
1979 * verify that it is correct.
1981 static void unfillcmd()
1985 last_block1 = new_block(dev);
1986 last_block2 = new_block(dev);
1987 first_block = new_block(dev);
1988 sprintf(buf, "%s/btape.state", working_directory);
1989 fd = open(buf, O_RDONLY);
1991 uint32_t state_level;
1992 read(fd, &state_level, sizeof(btape_state_level));
1993 read(fd, &simple, sizeof(simple));
1994 read(fd, &last_block_num1, sizeof(last_block_num1));
1995 read(fd, &last_block_num2, sizeof(last_block_num2));
1996 read(fd, &last_file1, sizeof(last_file1));
1997 read(fd, &last_file2, sizeof(last_file2));
1998 read(fd, last_block1->buf, last_block1->buf_len);
1999 read(fd, last_block2->buf, last_block2->buf_len);
2000 read(fd, first_block->buf, first_block->buf_len);
2002 if (state_level != btape_state_level) {
2003 Pmsg0(-1, "\nThe state file level has changed. You must redo\n"
2004 "the fill command.\n");
2009 Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
2010 "You must redo the fill command.\n", buf, be.strerror());
2017 static void do_unfill()
2019 DEV_BLOCK *block = dcr->block;
2026 Dmsg0(20, "Enter do_unfill\n");
2027 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2028 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2032 time(&jcr->run_time); /* start counting time for rates */
2036 free_block(last_block);
2038 last_block_num = last_block_num1;
2039 last_file = last_file1;
2040 last_block = last_block1;
2043 /* Multiple Volume tape */
2044 /* Close device so user can use autochanger if desired */
2045 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2048 autochanger = autoload_device(dcr, 1, NULL);
2050 force_close_dev(dev);
2051 get_cmd(_("Mount first tape. Press enter when ready: "));
2054 jcr->dcr = new_dcr(jcr, dev);
2055 set_volume_name("TestVolume1", 1);
2057 create_vol_list(jcr);
2059 dev->state &= ~(ST_READ|ST_APPEND);
2060 dev->num_writers = 0;
2061 if (!acquire_device_for_read(jcr, dev)) {
2062 Pmsg1(-1, "%s", dev->errmsg);
2067 * We now have the first tape mounted.
2068 * Note, re-reading last block may have caused us to
2069 * loose track of where we are (block number unknown).
2071 if (!rewind_dev(dev)) { /* get to a known place on tape */
2074 /* Read the first 10000 records */
2075 Pmsg0(-1, _("Reading the first 10000 records.\n"));
2077 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2078 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2079 last_file, last_block_num);
2080 if (!reposition_dev(dev, last_file, last_block_num)) {
2081 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2084 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2085 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2086 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2089 if (compare_blocks(last_block, block)) {
2091 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2093 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2100 /* restore info for last block on second Volume */
2101 last_block_num = last_block_num2;
2102 last_file = last_file2;
2103 last_block = last_block2;
2105 /* Multiple Volume tape */
2106 /* Close device so user can use autochanger if desired */
2107 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2112 set_volume_name("TestVolume2", 2);
2114 create_vol_list(jcr);
2115 autochanger = autoload_device(dcr, 1, NULL);
2117 force_close_dev(dev);
2118 get_cmd(_("Mount second tape. Press enter when ready: "));
2121 dev->state &= ~ST_READ;
2122 if (!acquire_device_for_read(jcr, dev)) {
2123 Pmsg1(-1, "%s", dev->errmsg);
2127 /* Space to "first" block which is last block not written
2128 * on the previous tape.
2130 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2131 if (!reposition_dev(dev, 0, 1)) {
2132 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2135 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2136 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2137 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2140 if (compare_blocks(first_block, block)) {
2141 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2144 /* Now find and compare the last block */
2145 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2146 last_file, last_block_num);
2147 if (!reposition_dev(dev, last_file, last_block_num)) {
2148 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2151 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2152 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2153 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2156 if (compare_blocks(last_block, block)) {
2157 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2161 free_block(last_block1);
2162 free_block(last_block2);
2163 free_block(first_block);
2166 /* Read 10000 records then stop */
2167 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2169 DEVICE *dev = dcr->dev;
2170 if (dev->file != 0) {
2171 Pmsg3(-1, "ERROR! device at %d:%d count=%d\n", dev->file, dev->block_num,
2176 if (quickie_count == 10000) {
2177 Pmsg2(-1, "1000 records read now at %d:%d\n", dev->file, dev->block_num);
2179 return quickie_count < 10000;
2182 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2185 uint32_t CheckSum, block_len;
2188 p = last_block->buf;
2190 unser_begin(q, BLKHDR2_LENGTH);
2191 unser_uint32(CheckSum);
2192 unser_uint32(block_len);
2193 while (q < (block->buf+block_len)) {
2200 dump_block(last_block, _("Last block written"));
2202 dump_block(block, _("Block read back"));
2203 Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf);
2204 Pmsg0(-1, "\n\n!!!! The last block written and the block\n"
2205 "that was read back differ. The test FAILED !!!!\n"
2206 "This must be corrected before you use Bacula\n"
2207 "to write multi-tape Volumes.!!!!\n");
2211 dump_block(last_block, _("Last block written"));
2212 dump_block(block, _("Block read back"));
2222 * Write current block to tape regardless of whether or
2223 * not it is full. If the tape fills, attempt to
2224 * acquire another tape.
2226 static int flush_block(DEV_BLOCK *block, int dump)
2230 uint32_t this_file, this_block_num;
2234 this_block = new_block(dev);
2237 last_block = new_block(dev);
2240 this_file = dev->file;
2241 this_block_num = dev->block_num;
2242 if (!write_block_to_dev(dcr)) {
2243 Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n",
2244 last_file, last_block_num, this_block_num);
2247 * This is 1st tape, so save first tape info separate
2248 * from second tape info
2250 last_block_num1 = last_block_num;
2251 last_file1 = last_file;
2252 last_block1 = dup_block(last_block);
2253 last_block2 = dup_block(last_block);
2254 first_block = dup_block(block); /* first block second tape */
2257 Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n",
2258 (unsigned)file_index, block->BlockNumber, block->block_len);
2259 dump_block(last_block, "Last block written");
2261 dump_block(block, "Block not written");
2264 eot_block = block->BlockNumber;
2265 eot_block_len = block->block_len;
2266 eot_FileIndex = file_index;
2270 now -= jcr->run_time;
2272 now = 1; /* don't divide by zero */
2274 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2275 vol_size = dev->VolCatInfo.VolCatBytes;
2276 Pmsg4(000, "End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
2277 dev->file, dev->block_num,
2278 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2281 stop = -1; /* stop, but do simplified test */
2283 /* Full test in progress */
2284 if (!fixup_device_block_write_error(jcr->dcr)) {
2285 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2290 BlockNumber = 0; /* start counting for second tape */
2293 return 1; /* end of tape reached */
2296 /* Save contents after write so that the header is serialized */
2297 memcpy(this_block->buf, block->buf, this_block->buf_len);
2300 * Note, we always read/write to block, but we toggle
2301 * copying it to one or another of two allocated blocks.
2302 * Switch blocks so that the block just successfully written is
2303 * always in last_block.
2305 tblock = last_block;
2306 last_block = this_block;
2307 this_block = tblock;
2308 last_file = this_file;
2309 last_block_num = this_block_num;
2317 * First we label the tape, then we fill
2318 * it with data get a new tape and write a few blocks.
2320 static void qfillcmd()
2322 DEV_BLOCK *block = dcr->block;
2323 DEV_RECORD *rec = dcr->rec;
2326 Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
2328 get_cmd("How many blocks do you want to write? (1000): ");
2335 sm_check(__FILE__, __LINE__, false);
2337 i = block->buf_len - 100;
2339 rec->data = check_pool_memory_size(rec->data, i);
2340 memset(rec->data, i & 0xFF, i);
2343 Pmsg1(0, "Begin writing %d Bacula blocks to tape ...\n", count);
2344 for (i=0; i < count; i++) {
2349 if (!write_record_to_block(block, rec)) {
2350 Pmsg0(0, _("Error writing record to block.\n"));
2353 if (!write_block_to_dev(dcr)) {
2354 Pmsg0(0, _("Error writing block to device.\n"));
2360 if (dev_cap(dev, CAP_TWOEOF)) {
2367 sm_check(__FILE__, __LINE__, false);
2371 * Fill a tape using raw write() command
2373 static void rawfill_cmd()
2375 DEV_BLOCK *block = dcr->block;
2378 uint32_t block_num = 0;
2383 fd = open("/dev/urandom", O_RDONLY);
2385 read(fd, block->buf, block->buf_len);
2388 uint32_t *p = (uint32_t *)block->buf;
2389 srandom(time(NULL));
2390 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2394 p = (uint32_t *)block->buf;
2395 Pmsg1(0, "Begin writing raw blocks of %u bytes.\n", block->buf_len);
2398 stat = write(dev->fd, block->buf, block->buf_len);
2399 if (stat == (int)block->buf_len) {
2400 if ((block_num++ % 100) == 0) {
2405 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2415 printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
2416 be.strerror(my_errno));
2422 * Fill a tape using Bacula block writes
2424 static void bfill_cmd()
2426 DEV_BLOCK *block = dcr->block;
2427 uint32_t block_num = 0;
2433 fd = open("/dev/urandom", O_RDONLY);
2435 read(fd, block->buf, block->buf_len);
2438 uint32_t *p = (uint32_t *)block->buf;
2439 srandom(time(NULL));
2440 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2444 p = (uint32_t *)block->buf;
2445 Pmsg1(0, "Begin writing Bacula blocks of %u bytes.\n", block->buf_len);
2448 block->binbuf = block->buf_len;
2449 block->bufp = block->buf + block->binbuf;
2450 if (!write_block_to_dev(dcr)) {
2453 if ((block_num++ % 100) == 0) {
2458 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2464 printf("Write failed at block %u.\n", block_num);
2469 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2470 static struct cmdstruct commands[] = {
2471 {"autochanger", autochangercmd, "test autochanger"},
2472 {"bsf", bsfcmd, "backspace file"},
2473 {"bsr", bsrcmd, "backspace record"},
2474 {"bfill", bfill_cmd, "fill tape using Bacula writes"},
2475 {"cap", capcmd, "list device capabilities"},
2476 {"clear", clearcmd, "clear tape errors"},
2477 {"eod", eodcmd, "go to end of Bacula data for append"},
2478 {"eom", eomcmd, "go to the physical end of medium"},
2479 {"fill", fillcmd, "fill tape, write onto second volume"},
2480 {"unfill", unfillcmd, "read filled tape"},
2481 {"fsf", fsfcmd, "forward space a file"},
2482 {"fsr", fsrcmd, "forward space a record"},
2483 {"help", helpcmd, "print this command"},
2484 {"label", labelcmd, "write a Bacula label to the tape"},
2485 {"load", loadcmd, "load a tape"},
2486 {"quit", quitcmd, "quit btape"},
2487 {"rawfill", rawfill_cmd, "use write() to fill tape"},
2488 {"readlabel", readlabelcmd, "read and print the Bacula tape label"},
2489 {"rectest", rectestcmd, "test record handling functions"},
2490 {"rewind", rewindcmd, "rewind the tape"},
2491 {"scan", scancmd, "read() tape block by block to EOT and report"},
2492 {"scanblocks", scan_blocks, "Bacula read block by block to EOT and report"},
2493 {"status", statcmd, "print tape status"},
2494 {"test", testcmd, "General test Bacula tape functions"},
2495 {"weof", weofcmd, "write an EOF on the tape"},
2496 {"wr", wrcmd, "write a single Bacula block"},
2497 {"rr", rrcmd, "read a single record"},
2498 {"qfill", qfillcmd, "quick fill command"},
2500 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2508 while (get_cmd("*")) {
2509 sm_check(__FILE__, __LINE__, false);
2511 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2512 for (i=0; i<comsize; i++) /* search for command */
2513 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2514 (*commands[i].func)(); /* go execute command */
2519 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2525 static void helpcmd()
2529 printf(_("Interactive commands:\n"));
2530 printf(_(" Command Description\n ======= ===========\n"));
2531 for (i=0; i<comsize; i++)
2532 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2539 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2540 "\nVersion: " VERSION " (" BDATE ")\n\n"
2541 "Usage: btape <options> <device_name>\n"
2542 " -b <file> specify bootstrap file\n"
2543 " -c <file> set configuration file to file\n"
2544 " -d <nn> set debug level to nn\n"
2545 " -p proceed inspite of I/O errors\n"
2546 " -s turn off signals\n"
2548 " -? print this message.\n"
2554 * Get next input command from terminal. This
2555 * routine is REALLY primitive, and should be enhanced
2556 * to have correct backspacing, etc.
2559 get_cmd(const char *prompt)
2563 fprintf(stdout, prompt);
2565 /* We really should turn off echoing and pretty this
2569 while ((ch = fgetc(stdin)) != EOF) {
2571 strip_trailing_junk(cmd);
2573 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2586 /* Dummies to replace askdir.c */
2587 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2588 bool dir_send_job_status(JCR *jcr) {return 1;}
2590 bool dir_update_volume_info(DCR *dcr, bool relabel)
2596 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2598 Dmsg0(20, "Enter dir_get_volume_info\n");
2599 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2603 bool dir_create_jobmedia_record(DCR *dcr)
2605 dcr->WroteVol = false;
2610 bool dir_find_next_appendable_volume(DCR *dcr)
2612 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2613 return dcr->VolumeName[0] != 0;
2616 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2618 DEVICE *dev = dcr->dev;
2619 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2620 if (dcr->VolumeName[0] == 0) {
2621 return dir_ask_sysop_to_create_appendable_volume(dcr);
2623 /* Close device so user can use autochanger if desired */
2624 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2627 force_close_dev(dev);
2628 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2629 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2630 fprintf(stderr, "Mount second Volume on device %s and press return when ready: ",
2633 fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
2634 dcr->VolumeName, dev->print_name());
2640 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2643 DEVICE *dev = dcr->dev;
2644 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2646 set_volume_name("TestVolume1", 1);
2648 set_volume_name("TestVolume2", 2);
2650 /* Close device so user can use autochanger if desired */
2651 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2654 autochanger = autoload_device(dcr, 1, NULL);
2656 force_close_dev(dev);
2657 fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
2668 static bool my_mount_next_read_volume(DCR *dcr)
2671 JCR *jcr = dcr->jcr;
2672 DEV_BLOCK *block = dcr->block;
2674 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2675 Pmsg1(000, "End of Volume \"%s\"\n", dcr->VolumeName);
2677 if (LastBlock != block->BlockNumber) {
2678 VolBytes += block->block_len;
2680 LastBlock = block->BlockNumber;
2682 now -= jcr->run_time;
2686 kbs = (double)VolBytes / (1000.0 * (double)now);
2687 Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2688 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2690 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2696 set_volume_name("TestVolume2", 2);
2698 create_vol_list(jcr);
2700 dev->state &= ~ST_READ;
2701 if (!acquire_device_for_read(jcr, dev)) {
2702 Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev->print_name(), dcr->VolumeName);
2705 return true; /* next volume mounted */
2708 static void set_volume_name(const char *VolName, int volnum)
2710 DCR *dcr = jcr->dcr;
2711 VolumeName = VolName;
2713 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2714 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2715 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2716 dcr->VolCatInfo.Slot = volnum;