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-2004 Kern Sibbald and John Walker
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 bool forge_on = false;
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"
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 * Main Bacula Pool Creation Program
144 int main(int margc, char *margv[])
152 if (TAPE_BSIZE % DEV_BSIZE != 0 || TAPE_BSIZE / DEV_BSIZE == 0) {
153 Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
154 TAPE_BSIZE, DEV_BSIZE);
156 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
157 Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE);
159 if (sizeof(off_t) < 8) {
160 Pmsg1(-1, "\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n",
164 bsnprintf(buf, sizeof(buf), "%u", x32);
165 i = bsscanf(buf, "%u", &y32);
166 if (i != 1 || x32 != y32) {
167 Pmsg3(-1, "32 bit printf/scanf problem. i=%d x32=%u y32=%u\n", i, x32, y32);
173 bsnprintf(buf, sizeof(buf), "%" llu, x64);
174 i = bsscanf(buf, "%llu", &y64);
175 if (i != 1 || x64 != y64) {
176 Pmsg3(-1, "64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n", i, x64, y64);
180 printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
182 working_directory = "/tmp";
183 my_name_is(margc, margv, "btape");
184 init_msg(NULL, NULL);
186 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
188 case 'b': /* bootstrap file */
189 bsr = parse_bsr(NULL, optarg);
190 // dump_bsr(bsr, true);
193 case 'c': /* specify config file */
194 if (configfile != NULL) {
197 configfile = bstrdup(optarg);
200 case 'd': /* set debug level */
201 debug_level = atoi(optarg);
202 if (debug_level <= 0) {
229 cmd = get_pool_memory(PM_FNAME);
230 args = get_pool_memory(PM_FNAME);
233 init_signals(terminate_btape);
236 if (configfile == NULL) {
237 configfile = bstrdup(CONFIG_FILE);
240 daemon_start_time = time(NULL);
242 parse_config(configfile);
245 /* See if we can open a device */
247 Pmsg0(000, "No archive name specified.\n");
250 } else if (margc != 1) {
251 Pmsg0(000, "Improper number of arguments specified.\n");
256 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
265 if (!open_the_device()) {
269 Dmsg0(200, "Do tape commands\n");
277 static void terminate_btape(int stat)
280 sm_check(__FILE__, __LINE__, false);
284 free_config_resources();
286 free_pool_memory(args);
290 free_pool_memory(cmd);
305 if (debug_level > 10)
306 print_memory_pool_stats();
309 free_block(this_block);
314 close_memory_pool(); /* free memory in pool */
320 static bool open_the_device()
324 block = new_block(dev);
326 if (!(dev->state & ST_OPENED)) {
327 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
328 if (open_dev(dev, dcr->VolumeName, OPEN_READ_WRITE) < 0) {
329 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
335 Pmsg1(000, "open_dev %s OK\n", dev_name(dev));
336 dev->state |= ST_APPEND;
349 * Write a label to the tape
351 static void labelcmd()
354 pm_strcpy(cmd, VolumeName);
356 if (!get_cmd("Enter Volume Name: ")) {
361 if (!(dev->state & ST_OPENED)) {
362 if (!first_open_device(dev)) {
363 Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
367 write_new_volume_label_to_dev(dcr, cmd, "Default");
368 Pmsg1(-1, "Wrote Volume label for volume \"%s\".\n", cmd);
372 * Read the tape label
374 static void readlabelcmd()
376 int save_debug_level = debug_level;
379 stat = read_dev_volume_label(dcr);
382 Pmsg0(0, "Volume has no label.\n");
385 Pmsg0(0, "Volume label read correctly.\n");
388 Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev));
391 Pmsg0(0, "Volume name error\n");
393 case VOL_CREATE_ERROR:
394 Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
396 case VOL_VERSION_ERROR:
397 Pmsg0(0, "Volume version error.\n");
399 case VOL_LABEL_ERROR:
400 Pmsg0(0, "Bad Volume label type.\n");
403 Pmsg0(0, "Unknown error.\n");
408 dump_volume_label(dev);
409 debug_level = save_debug_level;
414 * Load the tape should have prevously been taken
415 * off line, otherwise this command is not necessary.
417 static void loadcmd()
420 if (!load_dev(dev)) {
421 Pmsg1(0, "Bad status from load. ERR=%s\n", strerror_dev(dev));
423 Pmsg1(0, "Loaded %s\n", dev_name(dev));
429 static void rewindcmd()
431 if (!rewind_dev(dev)) {
432 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
433 clrerror_dev(dev, -1);
435 Pmsg1(0, "Rewound %s\n", dev_name(dev));
440 * Clear any tape error
442 static void clearcmd()
444 clrerror_dev(dev, -1);
448 * Write and end of file on the tape
450 static void weofcmd()
461 if ((stat = weof_dev(dev, num)) < 0) {
462 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
465 Pmsg3(0, "Wrote %d EOF%s to %s\n", num, num==1?"":"s", dev_name(dev));
470 /* Go to the end of the medium -- raw command
471 * The idea was orginally that the end of the Bacula
472 * medium would be flagged differently. This is not
473 * currently the case. So, this is identical to the
479 Pmsg1(0, "%s", strerror_dev(dev));
482 Pmsg0(0, _("Moved to end of medium.\n"));
487 * Go to the end of the medium (either hardware determined
488 * or defined by two eofs.
508 if (!bsf_dev(dev, num)) {
509 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
511 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
527 if (!bsr_dev(dev, num)) {
528 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
530 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
535 * List device capabilities as defined in the
540 printf(_("Configured device capabilities:\n"));
541 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
542 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
543 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
544 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
545 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
546 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
547 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
548 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
549 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
550 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
551 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
552 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
553 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
554 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
557 printf(_("Device status:\n"));
558 printf("%sOPENED ", dev->state & ST_OPENED ? "" : "!");
559 printf("%sTAPE ", dev->state & ST_TAPE ? "" : "!");
560 printf("%sLABEL ", dev->state & ST_LABEL ? "" : "!");
561 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
562 printf("%sAPPEND ", dev->state & ST_APPEND ? "" : "!");
563 printf("%sREAD ", dev->state & ST_READ ? "" : "!");
564 printf("%sEOT ", dev->state & ST_EOT ? "" : "!");
565 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
566 printf("%sEOF ", dev->state & ST_EOF ? "" : "!");
567 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
568 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
571 printf(_("Device parameters:\n"));
572 printf("Device name: %s\n", dev->dev_name);
573 printf("File=%u block=%u\n", dev->file, dev->block_num);
574 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
582 * Test writting larger and larger records.
583 * This is a torture test for records.
585 static void rectestcmd()
591 Pmsg0(0, "Test writting larger and larger records.\n"
592 "This is a torture test for records.\nI am going to write\n"
593 "larger and larger records. It will stop when the record size\n"
594 "plus the header exceeds the block size (by default about 64K)\n");
597 get_cmd("Do you want to continue? (y/n): ");
599 Pmsg0(000, "Command aborted.\n");
603 sm_check(__FILE__, __LINE__, false);
604 block = new_block(dev);
607 for (i=1; i<500000; i++) {
608 rec->data = check_pool_memory_size(rec->data, i);
609 memset(rec->data, i & 0xFF, i);
611 sm_check(__FILE__, __LINE__, false);
612 if (write_record_to_block(block, rec)) {
615 Pmsg2(0, "Block %d i=%d\n", blkno, i);
619 sm_check(__FILE__, __LINE__, false);
623 sm_check(__FILE__, __LINE__, false);
627 * This test attempts to re-read a block written by Bacula
628 * normally at the end of the tape. Bacula will then back up
629 * over the two eof marks, backup over the record and reread
630 * it to make sure it is valid. Bacula can skip this validation
631 * if you set "Backward space record = no"
633 static int re_read_block_test()
635 DEV_BLOCK *block = dcr->block;
640 if (!(dev->capabilities & CAP_BSR)) {
641 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
645 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
646 "I'm going to write three records and an EOF\n"
647 "then backup over the EOF and re-read the last record.\n"
648 "Bacula does this after writing the last block on the\n"
649 "tape to verify that the block was written correctly.\n\n"
650 "This is not an *essential* feature ...\n\n"));
654 rec->data = check_pool_memory_size(rec->data, block->buf_len);
655 len = rec->data_len = block->buf_len-100;
656 memset(rec->data, 1, rec->data_len);
657 if (!write_record_to_block(block, rec)) {
658 Pmsg0(0, _("Error writing record to block.\n"));
661 if (!write_block_to_dev(dcr)) {
662 Pmsg0(0, _("Error writing block to device.\n"));
665 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
667 memset(rec->data, 2, rec->data_len);
668 if (!write_record_to_block(block, rec)) {
669 Pmsg0(0, _("Error writing record to block.\n"));
672 if (!write_block_to_dev(dcr)) {
673 Pmsg0(0, _("Error writing block to device.\n"));
676 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
678 memset(rec->data, 3, rec->data_len);
679 if (!write_record_to_block(block, rec)) {
680 Pmsg0(0, _("Error writing record to block.\n"));
683 if (!write_block_to_dev(dcr)) {
684 Pmsg0(0, _("Error writing block to device.\n"));
687 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
690 if (dev_cap(dev, CAP_TWOEOF)) {
693 if (!bsf_dev(dev, 1)) {
694 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
697 if (dev_cap(dev, CAP_TWOEOF)) {
698 if (!bsf_dev(dev, 1)) {
699 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
703 Pmsg0(0, "Backspaced over EOF OK.\n");
704 if (!bsr_dev(dev, 1)) {
705 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
708 Pmsg0(0, "Backspace record OK.\n");
709 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
711 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
714 memset(rec->data, 0, rec->data_len);
715 if (!read_record_from_block(block, rec)) {
717 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
720 for (int i=0; i<len; i++) {
721 if (rec->data[i] != 3) {
722 Pmsg0(0, _("Bad data in record. Test failed!\n"));
726 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
727 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
734 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
735 "this function to verify the last block written to the\n"
736 "tape. Bacula will skip the last block verification\n"
738 "Backward Space Record = No\n\n"
739 "to your Storage daemon's Device resource definition.\n"));
746 * This test writes Bacula blocks to the tape in
747 * several files. It then rewinds the tape and attepts
748 * to read these blocks back checking the data.
750 static int write_read_test()
758 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
759 "I'm going to write 1000 records and an EOF\n"
760 "then write 1000 records and an EOF, then rewind,\n"
761 "and re-read the data to verify that it is correct.\n\n"
762 "This is an *essential* feature ...\n\n"));
765 if (!rewind_dev(dev)) {
766 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
769 rec->data = check_pool_memory_size(rec->data, block->buf_len);
770 rec->data_len = block->buf_len-100;
771 len = rec->data_len/sizeof(i);
772 for (i=1; i<=1000; i++) {
773 p = (int *)rec->data;
774 for (j=0; j<len; j++) {
777 if (!write_record_to_block(block, rec)) {
778 Pmsg0(0, _("Error writing record to block.\n"));
781 if (!write_block_to_dev(dcr)) {
782 Pmsg0(0, _("Error writing block to device.\n"));
786 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
788 for (i=1001; i<=2000; i++) {
789 p = (int *)rec->data;
790 for (j=0; j<len; j++) {
793 if (!write_record_to_block(block, rec)) {
794 Pmsg0(0, _("Error writing record to block.\n"));
797 if (!write_block_to_dev(dcr)) {
798 Pmsg0(0, _("Error writing block to device.\n"));
802 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
804 if (dev_cap(dev, CAP_TWOEOF)) {
807 if (!rewind_dev(dev)) {
808 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
811 Pmsg0(0, "Rewind OK.\n");
813 for (i=1; i<=2000; i++) {
815 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
817 if (dev_state(dev, ST_EOF)) {
818 Pmsg0(-1, _("Got EOF on tape.\n"));
823 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
826 memset(rec->data, 0, rec->data_len);
827 if (!read_record_from_block(block, rec)) {
829 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
832 p = (int *)rec->data;
833 for (j=0; j<len; j++) {
835 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
841 if (i == 1000 || i == 2000) {
842 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
845 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
854 * This test writes Bacula blocks to the tape in
855 * several files. It then rewinds the tape and attepts
856 * to read these blocks back checking the data.
858 static int position_test()
860 DEV_BLOCK *block = dcr->block;
866 int file = 0, blk = 0;
868 bool got_eof = false;
870 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
871 "I'm going to write 1000 records and an EOF\n"
872 "then write 1000 records and an EOF, then rewind,\n"
873 "and position to a few blocks and verify that it is correct.\n\n"
874 "This is an *essential* feature ...\n\n"));
877 if (!rewind_dev(dev)) {
878 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
881 rec->data = check_pool_memory_size(rec->data, block->buf_len);
882 rec->data_len = block->buf_len-100;
883 len = rec->data_len/sizeof(i);
884 for (i=1; i<=1000; i++) {
885 p = (int *)rec->data;
886 for (j=0; j<len; j++) {
889 if (!write_record_to_block(block, rec)) {
890 Pmsg0(0, _("Error writing record to block.\n"));
893 if (!write_block_to_dev(dcr)) {
894 Pmsg0(0, _("Error writing block to device.\n"));
898 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
900 for (i=1001; i<=2000; i++) {
901 p = (int *)rec->data;
902 for (j=0; j<len; j++) {
905 if (!write_record_to_block(block, rec)) {
906 Pmsg0(0, _("Error writing record to block.\n"));
909 if (!write_block_to_dev(dcr)) {
910 Pmsg0(0, _("Error writing block to device.\n"));
914 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
916 if (dev_cap(dev, CAP_TWOEOF)) {
919 if (!rewind_dev(dev)) {
920 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
923 Pmsg0(0, "Rewind OK.\n");
927 /* Set up next item to read based on where we are */
963 Pmsg2(-1, "Reposition to file:block %d:%d\n", file, blk);
964 if (!reposition_dev(dev, file, blk)) {
965 Pmsg0(0, "Reposition error.\n");
969 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
971 if (dev_state(dev, ST_EOF)) {
972 Pmsg0(-1, _("Got EOF on tape.\n"));
978 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
979 recno, file, blk, be.strerror(dev->dev_errno));
980 Pmsg0(0, _("This may be because the tape drive block size is not\n"
981 " set to variable blocking as normally used by Bacula.\n"
982 " Please see the Tape Testing chapter in the manual and \n"
983 " look for using mt with defblksize and setoptions\n"
984 "If your tape drive block size is correct, then perhaps\n"
985 " your SCSI driver is *really* stupid and does not\n"
986 " correctly report the file:block after a FSF. In this\n"
987 " case try setting:\n"
988 " Fast Forward Space File = no\n"
989 " in your Device resource.\n"));
993 memset(rec->data, 0, rec->data_len);
994 if (!read_record_from_block(block, rec)) {
996 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
999 p = (int *)rec->data;
1000 for (j=0; j<len; j++) {
1001 if (p[j] != recno) {
1002 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1007 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1009 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1021 * This test writes some records, then writes an end of file,
1022 * rewinds the tape, moves to the end of the data and attepts
1023 * to append to the tape. This function is essential for
1024 * Bacula to be able to write multiple jobs to the tape.
1026 static int append_test()
1028 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1029 "This test is essential to Bacula.\n\n"
1030 "I'm going to write one record in file 0,\n"
1031 " two records in file 1,\n"
1032 " and three records in file 2\n\n"));
1036 weofcmd(); /* end file 0 */
1039 weofcmd(); /* end file 1 */
1043 weofcmd(); /* end file 2 */
1044 if (dev_cap(dev, CAP_TWOEOF)) {
1047 force_close_dev(dev); /* release device */
1048 if (!open_the_device()) {
1052 Pmsg0(0, _("Now moving to end of medium.\n"));
1054 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1055 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1057 if (dev->file != 3) {
1061 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1064 if (dev_cap(dev, CAP_TWOEOF)) {
1068 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1069 Pmsg0(-1, "Doing Bacula scan of blocks:\n");
1071 Pmsg0(-1, _("End scanning the tape.\n"));
1072 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1073 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1075 if (dev->file != 4) {
1083 * This test exercises the autochanger
1085 static int autochanger_test()
1087 POOLMEM *results, *changer;
1088 int slot, status, loaded;
1089 int timeout = jcr->device->max_changer_wait;
1092 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1093 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1096 if (!(jcr->device && jcr->device->changer_name && jcr->device->changer_command)) {
1097 Pmsg0(-1, "\nAutochanger enabled, but no name or no command device specified.\n");
1101 Pmsg0(-1, "\nAh, I see you have an autochanger configured.\n"
1102 "To test the autochanger you must have a blank tape\n"
1103 " that I can write on in Slot 1.\n");
1104 if (!get_cmd("\nDo you wish to continue with the Autochanger test? (y/n): ")) {
1107 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1111 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1113 results = get_pool_memory(PM_MESSAGE);
1114 changer = get_pool_memory(PM_FNAME);
1118 dcr->VolCatInfo.Slot = slot;
1119 /* Find out what is loaded, zero means device is unloaded */
1120 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1121 changer = edit_device_codes(jcr, changer, jcr->device->changer_command,
1123 status = run_program(changer, timeout, results);
1124 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1126 loaded = atoi(results);
1129 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1130 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1134 Pmsg1(-1, "Slot %d loaded. I am going to unload it.\n", loaded);
1136 Pmsg0(-1, "Nothing loaded in the drive. OK.\n");
1138 Dmsg1(100, "Results from loaded query=%s\n", results);
1140 dcr->VolCatInfo.Slot = loaded;
1141 offline_or_rewind_dev(dev);
1142 /* We are going to load a new tape, so close the device */
1143 force_close_dev(dev);
1144 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1145 loaded, dev->drive_index);
1146 changer = edit_device_codes(jcr, changer,
1147 jcr->device->changer_command, "unload");
1148 status = run_program(changer, timeout, results);
1149 Pmsg2(-1, "unload status=%s %d\n", status==0?"OK":"Bad", status);
1152 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1153 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1162 dcr->VolCatInfo.Slot = slot;
1163 Pmsg2(-1, _("3303 Issuing autochanger \"load slot %d %d\" command.\n"),
1164 slot, dev->drive_index);
1165 changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "load");
1166 Dmsg1(100, "Changer=%s\n", changer);
1167 force_close_dev(dev);
1168 status = run_program(changer, timeout, results);
1170 Pmsg2(-1, _("3303 Autochanger \"load slot %d %d\" status is OK.\n"),
1171 slot, dev->drive_index);
1174 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1175 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1179 if (!open_the_device()) {
1183 * Start with sleep_time 0 then increment by 30 seconds if we get
1186 bmicrosleep(sleep_time, 0);
1187 if (!rewind_dev(dev) || weof_dev(dev,1) < 0) {
1188 Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
1189 clrerror_dev(dev, -1);
1190 Pmsg0(-1, "\nThe test failed, probably because you need to put\n"
1191 "a longer sleep time in the mtx-script in the load) case.\n"
1192 "Adding a 30 second sleep and trying again ...\n");
1196 Pmsg1(0, "Rewound %s\n", dev_name(dev));
1199 if ((status = weof_dev(dev, 1)) < 0) {
1200 Pmsg2(0, "Bad status from weof %d. ERR=%s\n", status, strerror_dev(dev));
1203 Pmsg1(0, "Wrote EOF to %s\n", dev_name(dev));
1207 Pmsg1(-1, "\nThe test worked this time. Please add:\n\n"
1209 "to your mtx-changer script in the load) case.\n\n",
1212 Pmsg0(-1, "\nThe test autochanger worked!!\n\n");
1215 free_pool_memory(changer);
1216 free_pool_memory(results);
1221 free_pool_memory(changer);
1222 free_pool_memory(results);
1223 Pmsg0(-1, "You must correct this error or the Autochanger will not work.\n");
1227 static void autochangercmd()
1234 * This test assumes that the append test has been done,
1235 * then it tests the fsf function.
1237 static int fsf_test()
1239 bool set_off = false;
1241 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1242 "This test is essential to Bacula.\n\n"
1243 "I'm going to write five files then test forward spacing\n\n"));
1247 weofcmd(); /* end file 0 */
1250 weofcmd(); /* end file 1 */
1254 weofcmd(); /* end file 2 */
1257 weofcmd(); /* end file 3 */
1259 weofcmd(); /* end file 4 */
1260 if (dev_cap(dev, CAP_TWOEOF)) {
1266 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1267 if (!fsf_dev(dev, 1)) {
1268 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1271 Pmsg2(-1, _("We should be in file 1. I am at file %d. This is %s\n"),
1272 dev->file, dev->file == 1 ? "correct!" : "NOT correct!!!!");
1274 if (dev->file != 1) {
1278 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1279 if (!fsf_dev(dev, 2)) {
1280 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1283 Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
1284 dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
1286 if (dev->file != 3) {
1291 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1292 if (!fsf_dev(dev, 4)) {
1293 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1296 Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
1297 dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
1299 if (dev->file != 4) {
1303 Pmsg0(-1, "The test worked this time. Please add:\n\n"
1304 " Fast Forward Space File = no\n\n"
1305 "to your Device resource for this drive.\n");
1309 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1310 if (!fsf_dev(dev, 1)) {
1311 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1313 Pmsg2(-1, _("We should be in file 5. I am at file %d. This is %s\n"),
1314 dev->file, dev->file == 5 ? "correct!" : "NOT correct!!!!");
1315 if (dev->file != 5) {
1318 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1322 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1323 if (dev_cap(dev, CAP_FASTFSF)) {
1324 Pmsg0(-1, "You have Fast Forward Space File enabled.\n"
1325 "I am turning it off then retrying the test.\n");
1326 dev->capabilities &= ~CAP_FASTFSF;
1330 Pmsg0(-1, "You must correct this error or Bacula will not work.\n");
1339 * This is a general test of Bacula's functions
1340 * needed to read and write the tape.
1342 static void testcmd()
1346 if (!write_read_test()) {
1349 if (!position_test()) {
1353 stat = append_test();
1354 if (stat == 1) { /* OK get out */
1357 if (stat == -1) { /* first test failed */
1358 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1359 Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
1360 "Setting \"Hardware End of Medium = no\n"
1361 " and \"Fast Forward Space File = no\n"
1362 "and retrying append test.\n\n");
1363 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1364 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1365 stat = append_test();
1367 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1368 " Hardware End of Medium = No\n\n"
1369 " Fast Forward Space File = No\n"
1370 "to your Device resource in the Storage conf file.\n");
1374 Pmsg0(-1, "\n\nThat appears *NOT* to have corrected the problem.\n");
1377 /* Wrong count after append */
1379 Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
1380 "Setting \"BSF at EOM = yes\" and retrying append test.\n");
1381 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1382 stat = append_test();
1384 Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
1385 " Hardware End of Medium = No\n"
1386 " Fast Forward Space File = No\n"
1387 " BSF at EOM = yes\n\n"
1388 "to your Device resource in the Storage conf file.\n");
1395 Pmsg0(-1, "\nAppend test failed.\n\n");
1396 Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1397 "Unable to correct the problem. You MUST fix this\n"
1398 "problem before Bacula can use your tape drive correctly\n");
1399 Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
1400 "Do so by setting:\n\n"
1401 "Minimum Block Size = nnn\n"
1402 "Maximum Block Size = nnn\n\n"
1403 "in your Storage daemon's Device definition.\n"
1404 "nnn must match your tape driver's block size, which\n"
1405 "can be determined by reading your tape manufacturers\n"
1406 "information, and the information on your kernel dirver.\n"
1407 "Fixed block sizes, however, are not normally an ideal solution.\n");
1412 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1413 "Please double check it ...\n"
1414 "=== Sample correct output ===\n"
1415 "1 block of 64448 bytes in file 1\n"
1416 "End of File mark.\n"
1417 "2 blocks of 64448 bytes in file 2\n"
1418 "End of File mark.\n"
1419 "3 blocks of 64448 bytes in file 3\n"
1420 "End of File mark.\n"
1421 "1 block of 64448 bytes in file 4\n"
1422 "End of File mark.\n"
1423 "Total files=4, blocks=7, bytes = 451,136\n"
1424 "=== End sample correct output ===\n\n"));
1426 Pmsg0(-1, _("If the above scan output is not identical to the\n"
1427 "sample output, you MUST correct the problem\n"
1428 "or Bacula will not be able to write multiple Jobs to \n"
1432 re_read_block_test();
1435 fsf_test(); /* do fast forward space file test */
1437 autochanger_test(); /* do autochanger test */
1441 /* Forward space a file */
1442 static void fsfcmd()
1446 num = atoi(argk[1]);
1451 if (!fsf_dev(dev, num)) {
1452 Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
1455 Pmsg2(0, "Forward spaced %d file%s.\n", num, num==1?"":"s");
1458 /* Forward space a record */
1459 static void fsrcmd()
1463 num = atoi(argk[1]);
1468 if (!fsr_dev(dev, num)) {
1469 Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
1472 Pmsg2(0, "Forward spaced %d record%s.\n", num, num==1?"":"s");
1477 * Write a Bacula block to the tape
1481 DEV_BLOCK *block = dcr->block;
1482 DEV_RECORD *rec = dcr->rec;
1485 sm_check(__FILE__, __LINE__, false);
1488 dump_block(block, "test");
1491 i = block->buf_len - 100;
1493 rec->data = check_pool_memory_size(rec->data, i);
1494 memset(rec->data, i & 0xFF, i);
1496 sm_check(__FILE__, __LINE__, false);
1497 if (!write_record_to_block(block, rec)) {
1498 Pmsg0(0, _("Error writing record to block.\n"));
1501 if (!write_block_to_dev(dcr)) {
1502 Pmsg0(0, _("Error writing block to device.\n"));
1505 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1507 Pmsg0(0, _("Wrote block to device.\n"));
1510 sm_check(__FILE__, __LINE__, false);
1511 sm_check(__FILE__, __LINE__, false);
1515 * Read a record from the tape
1522 if (!get_cmd("Enter length to read: ")) {
1526 if (len < 0 || len > 1000000) {
1527 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1530 buf = (char *)malloc(len);
1531 stat = read(dev->fd, buf, len);
1532 if (stat > 0 && stat <= len) {
1536 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1537 len, stat, be.strerror());
1543 * Scan tape by reading block by block. Report what is
1544 * on the tape. Note, this command does raw reads, and as such
1545 * will not work with fixed block size devices.
1547 static void scancmd()
1550 int blocks, tot_blocks, tot_files;
1556 blocks = block_size = tot_blocks = 0;
1558 if (dev->state & ST_EOT) {
1559 Pmsg0(0, "End of tape\n");
1562 update_pos_dev(dev);
1563 tot_files = dev->file;
1564 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1566 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1568 clrerror_dev(dev, -1);
1569 Mmsg2(dev->errmsg, "read error on %s. ERR=%s.\n",
1570 dev->dev_name, be.strerror());
1571 Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
1573 printf("%d block%s of %d bytes in file %d\n",
1574 blocks, blocks>1?"s":"", block_size, dev->file);
1577 Dmsg1(200, "read status = %d\n", stat);
1579 if (stat != block_size) {
1580 update_pos_dev(dev);
1582 printf("%d block%s of %d bytes in file %d\n",
1583 blocks, blocks>1?"s":"", block_size, dev->file);
1588 if (stat == 0) { /* EOF */
1589 update_pos_dev(dev);
1590 printf("End of File mark.\n");
1591 /* Two reads of zero means end of tape */
1592 if (dev->state & ST_EOF)
1593 dev->state |= ST_EOT;
1595 dev->state |= ST_EOF;
1598 if (dev->state & ST_EOT) {
1599 printf("End of tape\n");
1602 } else { /* Got data */
1603 dev->state &= ~ST_EOF;
1609 update_pos_dev(dev);
1610 tot_files = dev->file - tot_files;
1611 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1612 edit_uint64_with_commas(bytes, ec1));
1617 * Scan tape by reading Bacula block by block. Report what is
1618 * on the tape. This function reads Bacula blocks, so if your
1619 * Device resource is correctly defined, it should work with
1620 * either variable or fixed block sizes.
1622 static void scan_blocks()
1624 int blocks, tot_blocks, tot_files;
1625 uint32_t block_size;
1627 DEV_BLOCK *block = dcr->block;
1630 blocks = block_size = tot_blocks = 0;
1634 update_pos_dev(dev);
1635 tot_files = dev->file;
1637 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1638 Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
1639 if (dev->state & ST_EOT) {
1641 printf("%d block%s of %d bytes in file %d\n",
1642 blocks, blocks>1?"s":"", block_size, dev->file);
1647 if (dev->state & ST_EOF) {
1649 printf("%d block%s of %d bytes in file %d\n",
1650 blocks, blocks>1?"s":"", block_size, dev->file);
1653 printf(_("End of File mark.\n"));
1656 if (dev->state & ST_SHORT) {
1658 printf("%d block%s of %d bytes in file %d\n",
1659 blocks, blocks>1?"s":"", block_size, dev->file);
1662 printf(_("Short block read.\n"));
1665 printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1668 if (block->block_len != block_size) {
1670 printf("%d block%s of %d bytes in file %d\n",
1671 blocks, blocks>1?"s":"", block_size, dev->file);
1674 block_size = block->block_len;
1678 bytes += block->block_len;
1679 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1680 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1681 block->VolSessionId, block->VolSessionTime);
1683 DEV_RECORD *rec = new_record();
1684 read_record_from_block(block, rec);
1685 Pmsg8(-1, "Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
1686 block->BlockNumber, dev->block_num, block->block_len,
1687 FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1688 stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
1691 } else if (verbose > 1) {
1692 dump_block(block, "");
1697 tot_files = dev->file - tot_files;
1698 printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1699 edit_uint64_with_commas(bytes, ec1));
1703 static void statcmd()
1705 int debug = debug_level;
1707 Pmsg2(0, "Device status: %u. ERR=%s\n", status_dev(dev), strerror_dev(dev));
1709 dump_volume_label(dev);
1711 debug_level = debug;
1716 * First we label the tape, then we fill
1717 * it with data get a new tape and write a few blocks.
1719 static void fillcmd()
1722 DEV_BLOCK *block = dcr->block;
1726 uint32_t min_block_size;
1736 This command simulates Bacula writing to a tape.\n\
1737 It requires either one or two blank tapes, which it\n\
1738 will label and write.\n\n\
1739 If you have an autochanger configured, it will use\n\
1740 the tapes that are in slots 1 and 2, otherwise, you will\n\
1741 be prompted to insert the tapes when necessary.\n\n\
1742 It will print a status approximately\n\
1743 every 322 MB, and write an EOF every 3.2 GB. If you have\n\
1744 selected the simple test option, after writing the first tape\n\
1745 it will rewind it and re-read the last block written.\n\n\
1746 If you have selected the multiple tape test, when the first tape\n\
1747 fills, it will ask for a second, and after writing a few more \n\
1748 blocks, it will stop. Then it will begin re-reading the\n\
1750 This may take a long time -- hours! ...\n\n");
1752 get_cmd("Do you want to run the simplified test (s) with one tape\n"
1753 "or the complete multiple tape (m) test: (s/m) ");
1754 if (cmd[0] == 's') {
1755 Pmsg0(-1, "Simple test (single tape) selected.\n");
1757 } else if (cmd[0] == 'm') {
1758 Pmsg0(-1, "Multiple tape test selected.\n");
1761 Pmsg0(000, "Command aborted.\n");
1765 Dmsg1(20, "Begin append device=%s\n", dev_name(dev));
1766 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1768 /* Use fixed block size to simplify read back */
1769 min_block_size = dev->min_block_size;
1770 dev->min_block_size = dev->max_block_size;
1771 set_volume_name("TestVolume1", 1);
1775 dev->state &= ~ST_APPEND; /* force volume to be relabeled */
1778 * Acquire output device for writing. Note, after acquiring a
1779 * device, we MUST release it, which is done at the end of this
1782 Dmsg0(100, "just before acquire_device\n");
1783 if (!acquire_device_for_append(jcr)) {
1784 set_jcr_job_status(jcr, JS_ErrorTerminated);
1787 block = jcr->dcr->block;
1789 Dmsg0(100, "Just after acquire_device_for_append\n");
1791 * Write Begin Session Record
1793 if (!write_session_label(dcr, SOS_LABEL)) {
1794 set_jcr_job_status(jcr, JS_ErrorTerminated);
1795 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1799 Pmsg0(-1, "Wrote Start of Session label.\n");
1801 memset(&rec, 0, sizeof(rec));
1802 rec.data = get_memory(100000); /* max record size */
1804 #define REC_SIZE 32768
1805 rec.data_len = REC_SIZE;
1808 * Put some random data in the record
1810 fd = open("/dev/urandom", O_RDONLY);
1812 read(fd, rec.data, rec.data_len);
1815 uint32_t *p = (uint32_t *)rec.data;
1816 srandom(time(NULL));
1817 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1823 * Generate data as if from File daemon, write to device
1825 jcr->dcr->VolFirstIndex = 0;
1826 time(&jcr->run_time); /* start counting time for rates */
1828 Pmsg0(-1, "Begin writing Bacula records to tape ...\n");
1830 Pmsg0(-1, "Begin writing Bacula records to first tape ...\n");
1832 for (file_index = 0; ok && !job_canceled(jcr); ) {
1833 rec.VolSessionId = jcr->VolSessionId;
1834 rec.VolSessionTime = jcr->VolSessionTime;
1835 rec.FileIndex = ++file_index;
1836 rec.Stream = STREAM_FILE_DATA;
1838 /* Mix up the data just a bit */
1839 uint32_t *lp = (uint32_t *)rec.data;
1841 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1845 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1846 rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1849 while (!write_record_to_block(block, &rec)) {
1851 * When we get here we have just filled a block
1853 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1856 /* Write block to tape */
1857 if (!flush_block(block, 1)) {
1861 /* Every 5000 blocks (approx 322MB) report where we are.
1863 if ((block->BlockNumber % 5000) == 0) {
1865 now -= jcr->run_time;
1867 now = 1; /* prevent divide error */
1869 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1870 Pmsg4(-1, "Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n",
1871 block->BlockNumber, dev->block_num,
1872 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1874 /* Every 15000 blocks (approx 1GB) write an EOF.
1876 if ((block->BlockNumber % 15000) == 0) {
1877 Pmsg0(-1, "Flush block, write EOF\n");
1878 flush_block(block, 0);
1882 /* Get out after writing 10 blocks to the second tape */
1883 if (++BlockNumber > 10 && stop != 0) { /* get out */
1888 Pmsg0(000, _("Not OK\n"));
1891 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1892 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1893 FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1894 stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1896 /* Get out after writing 10 blocks to the second tape */
1897 if (BlockNumber > 10 && stop != 0) { /* get out */
1898 Pmsg0(-1, "Done writing ...\n");
1903 Dmsg0(100, "Write_end_session_label()\n");
1904 /* Create Job status for end of session label */
1905 if (!job_canceled(jcr) && ok) {
1906 set_jcr_job_status(jcr, JS_Terminated);
1908 set_jcr_job_status(jcr, JS_ErrorTerminated);
1910 if (!write_session_label(dcr, EOS_LABEL)) {
1911 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1914 /* Write out final block of this session */
1915 if (!write_block_to_device(dcr)) {
1916 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1919 Pmsg0(-1, _("Wrote End of Session label.\n"));
1921 /* Save last block info for second tape */
1922 last_block_num2 = last_block_num;
1923 last_file2 = last_file;
1925 free_block(last_block2);
1927 last_block2 = dup_block(last_block);
1930 sprintf(buf, "%s/btape.state", working_directory);
1931 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1933 write(fd, &btape_state_level, sizeof(btape_state_level));
1934 write(fd, &simple, sizeof(simple));
1935 write(fd, &last_block_num1, sizeof(last_block_num1));
1936 write(fd, &last_block_num2, sizeof(last_block_num2));
1937 write(fd, &last_file1, sizeof(last_file1));
1938 write(fd, &last_file2, sizeof(last_file2));
1939 write(fd, last_block1->buf, last_block1->buf_len);
1940 write(fd, last_block2->buf, last_block2->buf_len);
1941 write(fd, first_block->buf, first_block->buf_len);
1943 Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
1944 last_block_num1, last_block_num2);
1947 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
1951 Pmsg4(-1, _("\n\nDone filling tape%s at %d:%d. Now beginning re-read of %stape ...\n"),
1952 simple?"":"s", jcr->dcr->dev->file, jcr->dcr->dev->block_num, simple?"":"first ");
1954 jcr->dcr->block = block;
1955 /* Release the device if multiple tapes being used */
1956 // if (!simple && !release_device(jcr)) {
1957 // Pmsg0(-1, _("Error in release_device\n"));
1963 dev->min_block_size = min_block_size;
1964 free_memory(rec.data);
1968 * Read two tapes written by the "fill" command and ensure
1969 * that the data is valid. If stop==1 we simulate full read back
1970 * of two tapes. If stop==-1 we simply read the last block and
1971 * verify that it is correct.
1973 static void unfillcmd()
1977 last_block1 = new_block(dev);
1978 last_block2 = new_block(dev);
1979 first_block = new_block(dev);
1980 sprintf(buf, "%s/btape.state", working_directory);
1981 fd = open(buf, O_RDONLY);
1983 uint32_t state_level;
1984 read(fd, &state_level, sizeof(btape_state_level));
1985 read(fd, &simple, sizeof(simple));
1986 read(fd, &last_block_num1, sizeof(last_block_num1));
1987 read(fd, &last_block_num2, sizeof(last_block_num2));
1988 read(fd, &last_file1, sizeof(last_file1));
1989 read(fd, &last_file2, sizeof(last_file2));
1990 read(fd, last_block1->buf, last_block1->buf_len);
1991 read(fd, last_block2->buf, last_block2->buf_len);
1992 read(fd, first_block->buf, first_block->buf_len);
1994 if (state_level != btape_state_level) {
1995 Pmsg0(-1, "\nThe state file level has changed. You must redo\n"
1996 "the fill command.\n");
2001 Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
2002 "You must redo the fill command.\n", buf, be.strerror());
2009 static void do_unfill()
2011 DEV_BLOCK *block = dcr->block;
2018 Dmsg0(20, "Enter do_unfill\n");
2019 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2020 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2024 time(&jcr->run_time); /* start counting time for rates */
2028 free_block(last_block);
2030 last_block_num = last_block_num1;
2031 last_file = last_file1;
2032 last_block = last_block1;
2035 /* Multiple Volume tape */
2036 /* Close device so user can use autochanger if desired */
2037 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2040 autochanger = autoload_device(dcr, 1, NULL);
2042 force_close_dev(dev);
2043 get_cmd(_("Mount first tape. Press enter when ready: "));
2046 jcr->dcr = new_dcr(jcr, dev);
2047 set_volume_name("TestVolume1", 1);
2049 create_vol_list(jcr);
2051 dev->state &= ~(ST_READ|ST_APPEND);
2052 dev->num_writers = 0;
2053 if (!acquire_device_for_read(jcr)) {
2054 Pmsg1(-1, "%s", dev->errmsg);
2059 * We now have the first tape mounted.
2060 * Note, re-reading last block may have caused us to
2061 * loose track of where we are (block number unknown).
2063 if (!rewind_dev(dev)) { /* get to a known place on tape */
2066 /* Read the first 1000 records */
2067 Pmsg0(-1, _("Reading the first 1000 records.\n"));
2069 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2070 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2071 last_file, last_block_num);
2072 if (!reposition_dev(dev, last_file, last_block_num)) {
2073 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2076 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2077 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2078 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2081 if (compare_blocks(last_block, block)) {
2083 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2085 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2092 /* restore info for last block on second Volume */
2093 last_block_num = last_block_num2;
2094 last_file = last_file2;
2095 last_block = last_block2;
2097 /* Multiple Volume tape */
2098 /* Close device so user can use autochanger if desired */
2099 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2104 set_volume_name("TestVolume2", 2);
2106 create_vol_list(jcr);
2107 autochanger = autoload_device(dcr, 1, NULL);
2109 force_close_dev(dev);
2110 get_cmd(_("Mount second tape. Press enter when ready: "));
2113 dev->state &= ~ST_READ;
2114 if (!acquire_device_for_read(jcr)) {
2115 Pmsg1(-1, "%s", dev->errmsg);
2119 /* Space to "first" block which is last block not written
2120 * on the previous tape.
2122 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2123 if (!reposition_dev(dev, 0, 1)) {
2124 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2127 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2128 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2129 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2132 if (compare_blocks(first_block, block)) {
2133 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2136 /* Now find and compare the last block */
2137 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2138 last_file, last_block_num);
2139 if (!reposition_dev(dev, last_file, last_block_num)) {
2140 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2143 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2144 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2145 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2148 if (compare_blocks(last_block, block)) {
2149 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2153 free_block(last_block1);
2154 free_block(last_block2);
2155 free_block(first_block);
2158 /* Read 1000 records then stop */
2159 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2161 DEVICE *dev = dcr->dev;
2162 if (dev->file != 0) {
2163 Pmsg3(-1, "ERROR! device at %d:%d count=%d\n", dev->file, dev->block_num,
2168 if (quickie_count == 1000) {
2169 Pmsg2(-1, "1000 records read now at %d:%d\n", dev->file, dev->block_num);
2171 return quickie_count < 1000;
2174 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2177 uint32_t CheckSum, block_len;
2180 p = last_block->buf;
2182 unser_begin(q, BLKHDR2_LENGTH);
2183 unser_uint32(CheckSum);
2184 unser_uint32(block_len);
2185 while (q < (block->buf+block_len)) {
2192 dump_block(last_block, _("Last block written"));
2194 dump_block(block, _("Block read back"));
2195 Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf);
2196 Pmsg0(-1, "\n\n!!!! The last block written and the block\n"
2197 "that was read back differ. The test FAILED !!!!\n"
2198 "This must be corrected before you use Bacula\n"
2199 "to write multi-tape Volumes.!!!!\n");
2203 dump_block(last_block, _("Last block written"));
2204 dump_block(block, _("Block read back"));
2214 * Write current block to tape regardless of whether or
2215 * not it is full. If the tape fills, attempt to
2216 * acquire another tape.
2218 static int flush_block(DEV_BLOCK *block, int dump)
2222 uint32_t this_file, this_block_num;
2226 this_block = new_block(dev);
2229 last_block = new_block(dev);
2232 this_file = dev->file;
2233 this_block_num = dev->block_num;
2234 if (!write_block_to_dev(dcr)) {
2235 Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n",
2236 last_file, last_block_num, this_block_num);
2239 * This is 1st tape, so save first tape info separate
2240 * from second tape info
2242 last_block_num1 = last_block_num;
2243 last_file1 = last_file;
2244 last_block1 = dup_block(last_block);
2245 last_block2 = dup_block(last_block);
2246 first_block = dup_block(block); /* first block second tape */
2249 Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n",
2250 (unsigned)file_index, block->BlockNumber, block->block_len);
2251 dump_block(last_block, "Last block written");
2253 dump_block(block, "Block not written");
2256 eot_block = block->BlockNumber;
2257 eot_block_len = block->block_len;
2258 eot_FileIndex = file_index;
2262 now -= jcr->run_time;
2264 now = 1; /* don't divide by zero */
2266 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2267 vol_size = dev->VolCatInfo.VolCatBytes;
2268 Pmsg4(000, "End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
2269 dev->file, dev->block_num,
2270 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2273 stop = -1; /* stop, but do simplified test */
2275 /* Full test in progress */
2276 if (!fixup_device_block_write_error(jcr->dcr)) {
2277 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2282 BlockNumber = 0; /* start counting for second tape */
2285 return 1; /* end of tape reached */
2288 /* Save contents after write so that the header is serialized */
2289 memcpy(this_block->buf, block->buf, this_block->buf_len);
2292 * Note, we always read/write to block, but we toggle
2293 * copying it to one or another of two allocated blocks.
2294 * Switch blocks so that the block just successfully written is
2295 * always in last_block.
2297 tblock = last_block;
2298 last_block = this_block;
2299 this_block = tblock;
2300 last_file = this_file;
2301 last_block_num = this_block_num;
2309 * First we label the tape, then we fill
2310 * it with data get a new tape and write a few blocks.
2312 static void qfillcmd()
2314 DEV_BLOCK *block = dcr->block;
2315 DEV_RECORD *rec = dcr->rec;
2318 Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
2320 get_cmd("How many blocks do you want to write? (1000): ");
2327 sm_check(__FILE__, __LINE__, false);
2329 i = block->buf_len - 100;
2331 rec->data = check_pool_memory_size(rec->data, i);
2332 memset(rec->data, i & 0xFF, i);
2335 Pmsg1(0, "Begin writing %d Bacula blocks to tape ...\n", count);
2336 for (i=0; i < count; i++) {
2341 if (!write_record_to_block(block, rec)) {
2342 Pmsg0(0, _("Error writing record to block.\n"));
2345 if (!write_block_to_dev(dcr)) {
2346 Pmsg0(0, _("Error writing block to device.\n"));
2352 if (dev_cap(dev, CAP_TWOEOF)) {
2359 sm_check(__FILE__, __LINE__, false);
2363 * Fill a tape using raw write() command
2365 static void rawfill_cmd()
2367 DEV_BLOCK *block = dcr->block;
2370 uint32_t block_num = 0;
2375 fd = open("/dev/urandom", O_RDONLY);
2377 read(fd, block->buf, block->buf_len);
2380 uint32_t *p = (uint32_t *)block->buf;
2381 srandom(time(NULL));
2382 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2386 p = (uint32_t *)block->buf;
2387 Pmsg1(0, "Begin writing raw blocks of %u bytes.\n", block->buf_len);
2390 stat = write(dev->fd, block->buf, block->buf_len);
2391 if (stat == (int)block->buf_len) {
2392 if ((block_num++ % 100) == 0) {
2397 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2407 printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
2408 be.strerror(my_errno));
2414 * Fill a tape using raw write() command
2416 static void bfill_cmd()
2418 DEV_BLOCK *block = dcr->block;
2419 uint32_t block_num = 0;
2425 fd = open("/dev/urandom", O_RDONLY);
2427 read(fd, block->buf, block->buf_len);
2430 uint32_t *p = (uint32_t *)block->buf;
2431 srandom(time(NULL));
2432 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2436 p = (uint32_t *)block->buf;
2437 Pmsg1(0, "Begin writing Bacula blocks of %u bytes.\n", block->buf_len);
2440 block->binbuf = block->buf_len;
2441 block->bufp = block->buf + block->binbuf;
2442 if (!write_block_to_dev(dcr)) {
2445 if ((block_num++ % 100) == 0) {
2450 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2456 printf("Write failed at block %u.\n", block_num);
2461 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2462 static struct cmdstruct commands[] = {
2463 {"autochanger", autochangercmd, "test autochanger"},
2464 {"bsf", bsfcmd, "backspace file"},
2465 {"bsr", bsrcmd, "backspace record"},
2466 {"bfill", bfill_cmd, "fill tape using Bacula writes"},
2467 {"cap", capcmd, "list device capabilities"},
2468 {"clear", clearcmd, "clear tape errors"},
2469 {"eod", eodcmd, "go to end of Bacula data for append"},
2470 {"eom", eomcmd, "go to the physical end of medium"},
2471 {"fill", fillcmd, "fill tape, write onto second volume"},
2472 {"unfill", unfillcmd, "read filled tape"},
2473 {"fsf", fsfcmd, "forward space a file"},
2474 {"fsr", fsrcmd, "forward space a record"},
2475 {"help", helpcmd, "print this command"},
2476 {"label", labelcmd, "write a Bacula label to the tape"},
2477 {"load", loadcmd, "load a tape"},
2478 {"quit", quitcmd, "quit btape"},
2479 {"rawfill", rawfill_cmd, "use write() to fill tape"},
2480 {"readlabel", readlabelcmd, "read and print the Bacula tape label"},
2481 {"rectest", rectestcmd, "test record handling functions"},
2482 {"rewind", rewindcmd, "rewind the tape"},
2483 {"scan", scancmd, "read() tape block by block to EOT and report"},
2484 {"scanblocks", scan_blocks, "Bacula read block by block to EOT and report"},
2485 {"status", statcmd, "print tape status"},
2486 {"test", testcmd, "General test Bacula tape functions"},
2487 {"weof", weofcmd, "write an EOF on the tape"},
2488 {"wr", wrcmd, "write a single Bacula block"},
2489 {"rr", rrcmd, "read a single record"},
2490 {"qfill", qfillcmd, "quick fill command"},
2492 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2500 while (get_cmd("*")) {
2501 sm_check(__FILE__, __LINE__, false);
2503 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2504 for (i=0; i<comsize; i++) /* search for command */
2505 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2506 (*commands[i].func)(); /* go execute command */
2511 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2517 static void helpcmd()
2521 printf(_("Interactive commands:\n"));
2522 printf(_(" Command Description\n ======= ===========\n"));
2523 for (i=0; i<comsize; i++)
2524 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2531 "Copyright (C) 2000-2004 Kern Sibbald and John Walker.\n"
2532 "\nVersion: " VERSION " (" BDATE ")\n\n"
2533 "Usage: btape <options> <device_name>\n"
2534 " -b <file> specify bootstrap file\n"
2535 " -c <file> set configuration file to file\n"
2536 " -d <nn> set debug level to nn\n"
2537 " -p proceed inspite of I/O errors\n"
2538 " -s turn off signals\n"
2540 " -? print this message.\n"
2546 * Get next input command from terminal. This
2547 * routine is REALLY primitive, and should be enhanced
2548 * to have correct backspacing, etc.
2551 get_cmd(const char *prompt)
2555 fprintf(stdout, prompt);
2557 /* We really should turn off echoing and pretty this
2561 while ((ch = fgetc(stdin)) != EOF) {
2563 strip_trailing_junk(cmd);
2565 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2578 /* Dummies to replace askdir.c */
2579 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2580 bool dir_send_job_status(JCR *jcr) {return 1;}
2582 bool dir_update_volume_info(DCR *dcr, bool relabel)
2588 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2590 Dmsg0(20, "Enter dir_get_volume_info\n");
2591 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2595 bool dir_create_jobmedia_record(DCR *dcr)
2597 dcr->WroteVol = false;
2602 bool dir_find_next_appendable_volume(DCR *dcr)
2604 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2605 return dcr->VolumeName[0] != 0;
2608 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2610 DEVICE *dev = dcr->dev;
2611 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2612 if (dcr->VolumeName[0] == 0) {
2613 return dir_ask_sysop_to_create_appendable_volume(dcr);
2615 /* Close device so user can use autochanger if desired */
2616 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2619 force_close_dev(dev);
2620 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2621 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2622 fprintf(stderr, "Mount second Volume on device %s and press return when ready: ",
2625 fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
2626 dcr->VolumeName, dev_name(dev));
2632 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2635 DEVICE *dev = dcr->dev;
2636 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2638 set_volume_name("TestVolume1", 1);
2640 set_volume_name("TestVolume2", 2);
2642 /* Close device so user can use autochanger if desired */
2643 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2646 autochanger = autoload_device(dcr, 1, NULL);
2648 force_close_dev(dev);
2649 fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
2660 static bool my_mount_next_read_volume(DCR *dcr)
2663 JCR *jcr = dcr->jcr;
2664 DEV_BLOCK *block = dcr->block;
2666 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2667 Pmsg1(000, "End of Volume \"%s\"\n", dcr->VolumeName);
2669 if (LastBlock != block->BlockNumber) {
2670 VolBytes += block->block_len;
2672 LastBlock = block->BlockNumber;
2674 now -= jcr->run_time;
2678 kbs = (double)VolBytes / (1000.0 * (double)now);
2679 Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2680 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2682 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2688 set_volume_name("TestVolume2", 2);
2690 create_vol_list(jcr);
2692 dev->state &= ~ST_READ;
2693 if (!acquire_device_for_read(jcr)) {
2694 Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), dcr->VolumeName);
2697 return true; /* next volume mounted */
2700 static void set_volume_name(const char *VolName, int volnum)
2702 DCR *dcr = jcr->dcr;
2703 VolumeName = VolName;
2705 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2706 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2707 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2708 dcr->VolCatInfo.Slot = volnum;