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);
1776 dev->state &= ~ST_APPEND; /* force volume to be relabeled */
1779 * Acquire output device for writing. Note, after acquiring a
1780 * device, we MUST release it, which is done at the end of this
1783 Dmsg0(100, "just before acquire_device\n");
1784 if (!acquire_device_for_append(jcr)) {
1785 set_jcr_job_status(jcr, JS_ErrorTerminated);
1788 block = jcr->dcr->block;
1790 Dmsg0(100, "Just after acquire_device_for_append\n");
1792 * Write Begin Session Record
1794 if (!write_session_label(dcr, SOS_LABEL)) {
1795 set_jcr_job_status(jcr, JS_ErrorTerminated);
1796 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1800 Pmsg0(-1, "Wrote Start of Session label.\n");
1802 memset(&rec, 0, sizeof(rec));
1803 rec.data = get_memory(100000); /* max record size */
1805 #define REC_SIZE 32768
1806 rec.data_len = REC_SIZE;
1809 * Put some random data in the record
1811 fd = open("/dev/urandom", O_RDONLY);
1813 read(fd, rec.data, rec.data_len);
1816 uint32_t *p = (uint32_t *)rec.data;
1817 srandom(time(NULL));
1818 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1824 * Generate data as if from File daemon, write to device
1826 jcr->dcr->VolFirstIndex = 0;
1827 time(&jcr->run_time); /* start counting time for rates */
1829 Pmsg0(-1, "Begin writing Bacula records to tape ...\n");
1831 Pmsg0(-1, "Begin writing Bacula records to first tape ...\n");
1833 for (file_index = 0; ok && !job_canceled(jcr); ) {
1834 rec.VolSessionId = jcr->VolSessionId;
1835 rec.VolSessionTime = jcr->VolSessionTime;
1836 rec.FileIndex = ++file_index;
1837 rec.Stream = STREAM_FILE_DATA;
1839 /* Mix up the data just a bit */
1840 uint32_t *lp = (uint32_t *)rec.data;
1842 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1846 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1847 rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1850 while (!write_record_to_block(block, &rec)) {
1852 * When we get here we have just filled a block
1854 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1857 /* Write block to tape */
1858 if (!flush_block(block, 1)) {
1862 /* Every 5000 blocks (approx 322MB) report where we are.
1864 if ((block->BlockNumber % 5000) == 0) {
1866 now -= jcr->run_time;
1868 now = 1; /* prevent divide error */
1870 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1871 Pmsg4(-1, "Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n",
1872 block->BlockNumber, dev->block_num,
1873 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1875 /* Every 15000 blocks (approx 1GB) write an EOF.
1877 if ((block->BlockNumber % 15000) == 0) {
1878 Pmsg0(-1, "Flush block, write EOF\n");
1879 flush_block(block, 0);
1883 /* Get out after writing 10 blocks to the second tape */
1884 if (++BlockNumber > 10 && stop != 0) { /* get out */
1889 Pmsg0(000, _("Not OK\n"));
1892 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1893 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1894 FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1895 stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1897 /* Get out after writing 10 blocks to the second tape */
1898 if (BlockNumber > 10 && stop != 0) { /* get out */
1899 Pmsg0(-1, "Done writing ...\n");
1904 Dmsg0(100, "Write_end_session_label()\n");
1905 /* Create Job status for end of session label */
1906 if (!job_canceled(jcr) && ok) {
1907 set_jcr_job_status(jcr, JS_Terminated);
1909 set_jcr_job_status(jcr, JS_ErrorTerminated);
1911 if (!write_session_label(dcr, EOS_LABEL)) {
1912 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1915 /* Write out final block of this session */
1916 if (!write_block_to_device(dcr)) {
1917 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1920 Pmsg0(-1, _("Wrote End of Session label.\n"));
1922 /* Save last block info for second tape */
1923 last_block_num2 = last_block_num;
1924 last_file2 = last_file;
1926 free_block(last_block2);
1928 last_block2 = dup_block(last_block);
1931 sprintf(buf, "%s/btape.state", working_directory);
1932 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1934 write(fd, &btape_state_level, sizeof(btape_state_level));
1935 write(fd, &simple, sizeof(simple));
1936 write(fd, &last_block_num1, sizeof(last_block_num1));
1937 write(fd, &last_block_num2, sizeof(last_block_num2));
1938 write(fd, &last_file1, sizeof(last_file1));
1939 write(fd, &last_file2, sizeof(last_file2));
1940 write(fd, last_block1->buf, last_block1->buf_len);
1941 write(fd, last_block2->buf, last_block2->buf_len);
1942 write(fd, first_block->buf, first_block->buf_len);
1944 Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
1945 last_block_num1, last_block_num2);
1948 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
1952 Pmsg4(-1, _("\n\nDone filling tape%s at %d:%d. Now beginning re-read of %stape ...\n"),
1953 simple?"":"s", jcr->dcr->dev->file, jcr->dcr->dev->block_num, simple?"":"first ");
1955 jcr->dcr->block = block;
1956 /* Release the device if multiple tapes being used */
1957 // if (!simple && !release_device(jcr)) {
1958 // Pmsg0(-1, _("Error in release_device\n"));
1964 dev->min_block_size = min_block_size;
1965 free_memory(rec.data);
1969 * Read two tapes written by the "fill" command and ensure
1970 * that the data is valid. If stop==1 we simulate full read back
1971 * of two tapes. If stop==-1 we simply read the last block and
1972 * verify that it is correct.
1974 static void unfillcmd()
1978 last_block1 = new_block(dev);
1979 last_block2 = new_block(dev);
1980 first_block = new_block(dev);
1981 sprintf(buf, "%s/btape.state", working_directory);
1982 fd = open(buf, O_RDONLY);
1984 uint32_t state_level;
1985 read(fd, &state_level, sizeof(btape_state_level));
1986 read(fd, &simple, sizeof(simple));
1987 read(fd, &last_block_num1, sizeof(last_block_num1));
1988 read(fd, &last_block_num2, sizeof(last_block_num2));
1989 read(fd, &last_file1, sizeof(last_file1));
1990 read(fd, &last_file2, sizeof(last_file2));
1991 read(fd, last_block1->buf, last_block1->buf_len);
1992 read(fd, last_block2->buf, last_block2->buf_len);
1993 read(fd, first_block->buf, first_block->buf_len);
1995 if (state_level != btape_state_level) {
1996 Pmsg0(-1, "\nThe state file level has changed. You must redo\n"
1997 "the fill command.\n");
2002 Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
2003 "You must redo the fill command.\n", buf, be.strerror());
2010 static void do_unfill()
2012 DEV_BLOCK *block = dcr->block;
2019 Dmsg0(20, "Enter do_unfill\n");
2020 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2021 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2025 time(&jcr->run_time); /* start counting time for rates */
2029 free_block(last_block);
2031 last_block_num = last_block_num1;
2032 last_file = last_file1;
2033 last_block = last_block1;
2036 /* Multiple Volume tape */
2037 /* Close device so user can use autochanger if desired */
2038 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2041 autochanger = autoload_device(dcr, 1, NULL);
2043 force_close_dev(dev);
2044 get_cmd(_("Mount first tape. Press enter when ready: "));
2047 jcr->dcr = new_dcr(jcr, dev);
2048 set_volume_name("TestVolume1", 1);
2050 create_vol_list(jcr);
2052 dev->state &= ~(ST_READ|ST_APPEND);
2053 dev->num_writers = 0;
2054 if (!acquire_device_for_read(jcr)) {
2055 Pmsg1(-1, "%s", dev->errmsg);
2060 * We now have the first tape mounted.
2061 * Note, re-reading last block may have caused us to
2062 * loose track of where we are (block number unknown).
2064 if (!rewind_dev(dev)) { /* get to a known place on tape */
2067 /* Read the first 1000 records */
2068 Pmsg0(-1, _("Reading the first 1000 records.\n"));
2070 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2071 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2072 last_file, last_block_num);
2073 if (!reposition_dev(dev, last_file, last_block_num)) {
2074 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2077 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2078 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2079 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2082 if (compare_blocks(last_block, block)) {
2084 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2086 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2093 /* restore info for last block on second Volume */
2094 last_block_num = last_block_num2;
2095 last_file = last_file2;
2096 last_block = last_block2;
2098 /* Multiple Volume tape */
2099 /* Close device so user can use autochanger if desired */
2100 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2105 set_volume_name("TestVolume2", 2);
2107 create_vol_list(jcr);
2108 autochanger = autoload_device(dcr, 1, NULL);
2110 force_close_dev(dev);
2111 get_cmd(_("Mount second tape. Press enter when ready: "));
2114 dev->state &= ~ST_READ;
2115 if (!acquire_device_for_read(jcr)) {
2116 Pmsg1(-1, "%s", dev->errmsg);
2120 /* Space to "first" block which is last block not written
2121 * on the previous tape.
2123 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2124 if (!reposition_dev(dev, 0, 1)) {
2125 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2128 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2129 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2130 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2133 if (compare_blocks(first_block, block)) {
2134 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2137 /* Now find and compare the last block */
2138 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2139 last_file, last_block_num);
2140 if (!reposition_dev(dev, last_file, last_block_num)) {
2141 Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
2144 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2145 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2146 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2149 if (compare_blocks(last_block, block)) {
2150 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2154 free_block(last_block1);
2155 free_block(last_block2);
2156 free_block(first_block);
2159 /* Read 1000 records then stop */
2160 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2162 DEVICE *dev = dcr->dev;
2163 if (dev->file != 0) {
2164 Pmsg3(-1, "ERROR! device at %d:%d count=%d\n", dev->file, dev->block_num,
2169 if (quickie_count == 1000) {
2170 Pmsg2(-1, "1000 records read now at %d:%d\n", dev->file, dev->block_num);
2172 return quickie_count < 1000;
2175 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2178 uint32_t CheckSum, block_len;
2181 p = last_block->buf;
2183 unser_begin(q, BLKHDR2_LENGTH);
2184 unser_uint32(CheckSum);
2185 unser_uint32(block_len);
2186 while (q < (block->buf+block_len)) {
2193 dump_block(last_block, _("Last block written"));
2195 dump_block(block, _("Block read back"));
2196 Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf);
2197 Pmsg0(-1, "\n\n!!!! The last block written and the block\n"
2198 "that was read back differ. The test FAILED !!!!\n"
2199 "This must be corrected before you use Bacula\n"
2200 "to write multi-tape Volumes.!!!!\n");
2204 dump_block(last_block, _("Last block written"));
2205 dump_block(block, _("Block read back"));
2215 * Write current block to tape regardless of whether or
2216 * not it is full. If the tape fills, attempt to
2217 * acquire another tape.
2219 static int flush_block(DEV_BLOCK *block, int dump)
2223 uint32_t this_file, this_block_num;
2227 this_block = new_block(dev);
2230 last_block = new_block(dev);
2233 this_file = dev->file;
2234 this_block_num = dev->block_num;
2235 if (!write_block_to_dev(dcr)) {
2236 Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n",
2237 last_file, last_block_num, this_block_num);
2240 * This is 1st tape, so save first tape info separate
2241 * from second tape info
2243 last_block_num1 = last_block_num;
2244 last_file1 = last_file;
2245 last_block1 = dup_block(last_block);
2246 last_block2 = dup_block(last_block);
2247 first_block = dup_block(block); /* first block second tape */
2250 Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n",
2251 (unsigned)file_index, block->BlockNumber, block->block_len);
2252 dump_block(last_block, "Last block written");
2254 dump_block(block, "Block not written");
2257 eot_block = block->BlockNumber;
2258 eot_block_len = block->block_len;
2259 eot_FileIndex = file_index;
2263 now -= jcr->run_time;
2265 now = 1; /* don't divide by zero */
2267 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2268 vol_size = dev->VolCatInfo.VolCatBytes;
2269 Pmsg4(000, "End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
2270 dev->file, dev->block_num,
2271 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2274 stop = -1; /* stop, but do simplified test */
2276 /* Full test in progress */
2277 if (!fixup_device_block_write_error(jcr->dcr)) {
2278 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2283 BlockNumber = 0; /* start counting for second tape */
2286 return 1; /* end of tape reached */
2289 /* Save contents after write so that the header is serialized */
2290 memcpy(this_block->buf, block->buf, this_block->buf_len);
2293 * Note, we always read/write to block, but we toggle
2294 * copying it to one or another of two allocated blocks.
2295 * Switch blocks so that the block just successfully written is
2296 * always in last_block.
2298 tblock = last_block;
2299 last_block = this_block;
2300 this_block = tblock;
2301 last_file = this_file;
2302 last_block_num = this_block_num;
2310 * First we label the tape, then we fill
2311 * it with data get a new tape and write a few blocks.
2313 static void qfillcmd()
2315 DEV_BLOCK *block = dcr->block;
2316 DEV_RECORD *rec = dcr->rec;
2319 Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
2321 get_cmd("How many blocks do you want to write? (1000): ");
2328 sm_check(__FILE__, __LINE__, false);
2330 i = block->buf_len - 100;
2332 rec->data = check_pool_memory_size(rec->data, i);
2333 memset(rec->data, i & 0xFF, i);
2336 Pmsg1(0, "Begin writing %d Bacula blocks to tape ...\n", count);
2337 for (i=0; i < count; i++) {
2342 if (!write_record_to_block(block, rec)) {
2343 Pmsg0(0, _("Error writing record to block.\n"));
2346 if (!write_block_to_dev(dcr)) {
2347 Pmsg0(0, _("Error writing block to device.\n"));
2353 if (dev_cap(dev, CAP_TWOEOF)) {
2360 sm_check(__FILE__, __LINE__, false);
2364 * Fill a tape using raw write() command
2366 static void rawfill_cmd()
2368 DEV_BLOCK *block = dcr->block;
2371 uint32_t block_num = 0;
2376 fd = open("/dev/urandom", O_RDONLY);
2378 read(fd, block->buf, block->buf_len);
2381 uint32_t *p = (uint32_t *)block->buf;
2382 srandom(time(NULL));
2383 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2387 p = (uint32_t *)block->buf;
2388 Pmsg1(0, "Begin writing raw blocks of %u bytes.\n", block->buf_len);
2391 stat = write(dev->fd, block->buf, block->buf_len);
2392 if (stat == (int)block->buf_len) {
2393 if ((block_num++ % 100) == 0) {
2398 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2408 printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
2409 be.strerror(my_errno));
2415 * Fill a tape using raw write() command
2417 static void bfill_cmd()
2419 DEV_BLOCK *block = dcr->block;
2420 uint32_t block_num = 0;
2426 fd = open("/dev/urandom", O_RDONLY);
2428 read(fd, block->buf, block->buf_len);
2431 uint32_t *p = (uint32_t *)block->buf;
2432 srandom(time(NULL));
2433 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2437 p = (uint32_t *)block->buf;
2438 Pmsg1(0, "Begin writing Bacula blocks of %u bytes.\n", block->buf_len);
2441 block->binbuf = block->buf_len;
2442 block->bufp = block->buf + block->binbuf;
2443 if (!write_block_to_dev(dcr)) {
2446 if ((block_num++ % 100) == 0) {
2451 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2457 printf("Write failed at block %u.\n", block_num);
2462 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2463 static struct cmdstruct commands[] = {
2464 {"autochanger", autochangercmd, "test autochanger"},
2465 {"bsf", bsfcmd, "backspace file"},
2466 {"bsr", bsrcmd, "backspace record"},
2467 {"bfill", bfill_cmd, "fill tape using Bacula writes"},
2468 {"cap", capcmd, "list device capabilities"},
2469 {"clear", clearcmd, "clear tape errors"},
2470 {"eod", eodcmd, "go to end of Bacula data for append"},
2471 {"eom", eomcmd, "go to the physical end of medium"},
2472 {"fill", fillcmd, "fill tape, write onto second volume"},
2473 {"unfill", unfillcmd, "read filled tape"},
2474 {"fsf", fsfcmd, "forward space a file"},
2475 {"fsr", fsrcmd, "forward space a record"},
2476 {"help", helpcmd, "print this command"},
2477 {"label", labelcmd, "write a Bacula label to the tape"},
2478 {"load", loadcmd, "load a tape"},
2479 {"quit", quitcmd, "quit btape"},
2480 {"rawfill", rawfill_cmd, "use write() to fill tape"},
2481 {"readlabel", readlabelcmd, "read and print the Bacula tape label"},
2482 {"rectest", rectestcmd, "test record handling functions"},
2483 {"rewind", rewindcmd, "rewind the tape"},
2484 {"scan", scancmd, "read() tape block by block to EOT and report"},
2485 {"scanblocks", scan_blocks, "Bacula read block by block to EOT and report"},
2486 {"status", statcmd, "print tape status"},
2487 {"test", testcmd, "General test Bacula tape functions"},
2488 {"weof", weofcmd, "write an EOF on the tape"},
2489 {"wr", wrcmd, "write a single Bacula block"},
2490 {"rr", rrcmd, "read a single record"},
2491 {"qfill", qfillcmd, "quick fill command"},
2493 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2501 while (get_cmd("*")) {
2502 sm_check(__FILE__, __LINE__, false);
2504 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2505 for (i=0; i<comsize; i++) /* search for command */
2506 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2507 (*commands[i].func)(); /* go execute command */
2512 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2518 static void helpcmd()
2522 printf(_("Interactive commands:\n"));
2523 printf(_(" Command Description\n ======= ===========\n"));
2524 for (i=0; i<comsize; i++)
2525 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2532 "Copyright (C) 2000-2004 Kern Sibbald and John Walker.\n"
2533 "\nVersion: " VERSION " (" BDATE ")\n\n"
2534 "Usage: btape <options> <device_name>\n"
2535 " -b <file> specify bootstrap file\n"
2536 " -c <file> set configuration file to file\n"
2537 " -d <nn> set debug level to nn\n"
2538 " -p proceed inspite of I/O errors\n"
2539 " -s turn off signals\n"
2541 " -? print this message.\n"
2547 * Get next input command from terminal. This
2548 * routine is REALLY primitive, and should be enhanced
2549 * to have correct backspacing, etc.
2552 get_cmd(const char *prompt)
2556 fprintf(stdout, prompt);
2558 /* We really should turn off echoing and pretty this
2562 while ((ch = fgetc(stdin)) != EOF) {
2564 strip_trailing_junk(cmd);
2566 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2579 /* Dummies to replace askdir.c */
2580 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2581 bool dir_send_job_status(JCR *jcr) {return 1;}
2583 bool dir_update_volume_info(DCR *dcr, bool relabel)
2589 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2591 Dmsg0(20, "Enter dir_get_volume_info\n");
2592 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2596 bool dir_create_jobmedia_record(DCR *dcr)
2598 dcr->WroteVol = false;
2603 bool dir_find_next_appendable_volume(DCR *dcr)
2605 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2606 return dcr->VolumeName[0] != 0;
2609 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2611 DEVICE *dev = dcr->dev;
2612 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2613 if (dcr->VolumeName[0] == 0) {
2614 return dir_ask_sysop_to_create_appendable_volume(dcr);
2616 /* Close device so user can use autochanger if desired */
2617 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2620 force_close_dev(dev);
2621 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2622 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2623 fprintf(stderr, "Mount second Volume on device %s and press return when ready: ",
2626 fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
2627 dcr->VolumeName, dev_name(dev));
2633 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2636 DEVICE *dev = dcr->dev;
2637 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2639 set_volume_name("TestVolume1", 1);
2641 set_volume_name("TestVolume2", 2);
2643 /* Close device so user can use autochanger if desired */
2644 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2647 autochanger = autoload_device(dcr, 1, NULL);
2649 force_close_dev(dev);
2650 fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
2661 static bool my_mount_next_read_volume(DCR *dcr)
2664 JCR *jcr = dcr->jcr;
2665 DEV_BLOCK *block = dcr->block;
2667 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2668 Pmsg1(000, "End of Volume \"%s\"\n", dcr->VolumeName);
2670 if (LastBlock != block->BlockNumber) {
2671 VolBytes += block->block_len;
2673 LastBlock = block->BlockNumber;
2675 now -= jcr->run_time;
2679 kbs = (double)VolBytes / (1000.0 * (double)now);
2680 Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
2681 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2683 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2689 set_volume_name("TestVolume2", 2);
2691 create_vol_list(jcr);
2693 dev->state &= ~ST_READ;
2694 if (!acquire_device_for_read(jcr)) {
2695 Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), dcr->VolumeName);
2698 return true; /* next volume mounted */
2701 static void set_volume_name(const char *VolName, int volnum)
2703 DCR *dcr = jcr->dcr;
2704 VolumeName = VolName;
2706 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2707 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2708 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2709 dcr->VolCatInfo.Slot = volnum;