3 * Bacula Tape manipulation program
5 * Has various tape manipulation commands -- mostly for
6 * use in determining how tapes really work.
8 * Kern Sibbald, April MM
10 * Note, this program reads stored.conf, and will only
11 * talk to devices that are configured.
17 Copyright (C) 2000-2005 Kern Sibbald
19 This program is free software; you can redistribute it and/or
20 modify it under the terms of the GNU General Public License
21 version 2 as amended with additional clauses defined in the
22 file LICENSE in the main source directory.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 the file LICENSE for additional details.
35 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
37 /* External subroutines */
38 extern void free_config_resources();
40 /* Exported variables */
43 int bsize = TAPE_BSIZE;
44 char VolName[MAX_NAME_LENGTH];
45 STORES *me = NULL; /* our Global resource */
46 bool forge_on = false; /* proceed inspite of I/O errors */
47 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
48 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
51 * If you change the format of the state file,
52 * increment this value
54 static uint32_t btape_state_level = 2;
58 DEVRES *device = NULL;
61 /* Forward referenced subroutines */
62 static void do_tape_cmds();
63 static void helpcmd();
64 static void scancmd();
65 static void rewindcmd();
66 static void clearcmd();
70 static void fillcmd();
71 static void qfillcmd();
72 static void statcmd();
73 static void unfillcmd();
74 static int flush_block(DEV_BLOCK *block, int dump);
75 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
76 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
77 static bool my_mount_next_read_volume(DCR *dcr);
78 static void scan_blocks();
79 static void set_volume_name(const char *VolName, int volnum);
80 static void rawfill_cmd();
81 static void bfill_cmd();
82 static bool open_the_device();
83 static void autochangercmd();
84 static void do_unfill();
87 /* Static variables */
88 #define CONFIG_FILE "bacula-sd.conf"
89 char *configfile = NULL;
91 #define MAX_CMD_ARGS 30
94 static char *argk[MAX_CMD_ARGS];
95 static char *argv[MAX_CMD_ARGS];
98 static int quickie_count = 0;
99 static BSR *bsr = NULL;
100 static int signals = TRUE;
103 static uint64_t vol_size;
104 static uint64_t VolBytes;
107 static int32_t file_index;
108 static int end_of_tape = 0;
109 static uint32_t LastBlock = 0;
110 static uint32_t eot_block;
111 static uint32_t eot_block_len;
112 static uint32_t eot_FileIndex;
113 static int dumped = 0;
114 static DEV_BLOCK *last_block1 = NULL;
115 static DEV_BLOCK *last_block2 = NULL;
116 static DEV_BLOCK *last_block = NULL;
117 static DEV_BLOCK *this_block = NULL;
118 static DEV_BLOCK *first_block = NULL;
119 static uint32_t last_file1 = 0;
120 static uint32_t last_file2 = 0;
121 static uint32_t last_file = 0;
122 static uint32_t last_block_num1 = 0;
123 static uint32_t last_block_num2 = 0;
124 static uint32_t last_block_num = 0;
125 static uint32_t BlockNumber = 0;
126 static bool simple = true;
128 static const char *VolumeName = NULL;
129 static int vol_num = 0;
131 static JCR *jcr = NULL;
135 static void terminate_btape(int sig);
136 int get_cmd(const char *prompt);
139 /*********************************************************************
141 * Main Bacula Pool Creation Program
144 int main(int margc, char *margv[])
151 setlocale(LC_ALL, "");
152 bindtextdomain("bacula", LOCALEDIR);
153 textdomain("bacula");
156 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
157 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
158 TAPE_BSIZE, B_DEV_BSIZE);
160 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
161 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
163 if (sizeof(off_t) < 8) {
164 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n"),
168 bsnprintf(buf, sizeof(buf), "%u", x32);
169 i = bsscanf(buf, "%u", &y32);
170 if (i != 1 || x32 != y32) {
171 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
177 bsnprintf(buf, sizeof(buf), "%" llu, x64);
178 i = bsscanf(buf, "%llu", &y64);
179 if (i != 1 || x64 != y64) {
180 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"), i, x64, y64);
184 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
186 working_directory = "/tmp";
187 my_name_is(margc, margv, "btape");
188 init_msg(NULL, NULL);
190 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
192 case 'b': /* bootstrap file */
193 bsr = parse_bsr(NULL, optarg);
194 // dump_bsr(bsr, true);
197 case 'c': /* specify config file */
198 if (configfile != NULL) {
201 configfile = bstrdup(optarg);
204 case 'd': /* set debug level */
205 debug_level = atoi(optarg);
206 if (debug_level <= 0) {
233 cmd = get_pool_memory(PM_FNAME);
234 args = get_pool_memory(PM_FNAME);
237 init_signals(terminate_btape);
240 if (configfile == NULL) {
241 configfile = bstrdup(CONFIG_FILE);
244 daemon_start_time = time(NULL);
246 parse_config(configfile);
249 /* See if we can open a device */
251 Pmsg0(000, _("No archive name specified.\n"));
254 } else if (margc != 1) {
255 Pmsg0(000, _("Improper number of arguments specified.\n"));
260 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
269 if (!open_the_device()) {
273 Dmsg0(200, "Do tape commands\n");
281 static void terminate_btape(int stat)
284 sm_check(__FILE__, __LINE__, false);
288 free_config_resources();
290 free_pool_memory(args);
294 free_pool_memory(cmd);
309 if (debug_level > 10)
310 print_memory_pool_stats();
313 free_block(this_block);
318 close_memory_pool(); /* free memory in pool */
319 term_last_jobs_list();
325 static bool open_the_device()
329 block = new_block(dev);
331 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
332 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
333 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
338 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
339 dev->set_append(); /* put volume in append mode */
352 * Write a label to the tape
354 static void labelcmd()
357 pm_strcpy(cmd, VolumeName);
359 if (!get_cmd(_("Enter Volume Name: "))) {
364 if (!dev->is_open()) {
365 if (!first_open_device(dcr)) {
366 Pmsg1(0, _("Device open failed. ERR=%s\n"), strerror_dev(dev));
370 write_new_volume_label_to_dev(dcr, cmd, "Default");
371 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
375 * Read the tape label
377 static void readlabelcmd()
379 int save_debug_level = debug_level;
382 stat = read_dev_volume_label(dcr);
385 Pmsg0(0, _("Volume has no label.\n"));
388 Pmsg0(0, _("Volume label read correctly.\n"));
391 Pmsg1(0, _("I/O error on device: ERR=%s"), strerror_dev(dev));
394 Pmsg0(0, _("Volume name error\n"));
396 case VOL_CREATE_ERROR:
397 Pmsg1(0, _("Error creating label. ERR=%s"), strerror_dev(dev));
399 case VOL_VERSION_ERROR:
400 Pmsg0(0, _("Volume version error.\n"));
402 case VOL_LABEL_ERROR:
403 Pmsg0(0, _("Bad Volume label type.\n"));
406 Pmsg0(0, _("Unknown error.\n"));
411 dump_volume_label(dev);
412 debug_level = save_debug_level;
417 * Load the tape should have prevously been taken
418 * off line, otherwise this command is not necessary.
420 static void loadcmd()
423 if (!load_dev(dev)) {
424 Pmsg1(0, _("Bad status from load. ERR=%s\n"), strerror_dev(dev));
426 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
432 static void rewindcmd()
434 if (!dev->rewind(dcr)) {
435 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
436 clrerror_dev(dev, -1);
438 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
443 * Clear any tape error
445 static void clearcmd()
447 clrerror_dev(dev, -1);
451 * Write and end of file on the tape
453 static void weofcmd()
464 if ((stat = weof_dev(dev, num)) < 0) {
465 Pmsg2(0, _("Bad status from weof %d. ERR=%s\n"), stat, strerror_dev(dev));
469 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
472 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
478 /* Go to the end of the medium -- raw command
479 * The idea was orginally that the end of the Bacula
480 * medium would be flagged differently. This is not
481 * currently the case. So, this is identical to the
487 Pmsg1(0, "%s", strerror_dev(dev));
490 Pmsg0(0, _("Moved to end of medium.\n"));
495 * Go to the end of the medium (either hardware determined
496 * or defined by two eofs.
516 if (!bsf_dev(dev, num)) {
517 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
519 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
535 if (!bsr_dev(dev, num)) {
536 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
538 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
543 * List device capabilities as defined in the
548 printf(_("Configured device capabilities:\n"));
549 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
550 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
551 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
552 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
553 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
554 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
555 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
556 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
557 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
558 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
559 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
560 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
561 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
562 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
563 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
566 printf(_("Device status:\n"));
567 printf("%sOPENED ", dev->is_open() ? "" : "!");
568 printf("%sTAPE ", dev->is_tape() ? "" : "!");
569 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
570 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
571 printf("%sAPPEND ", dev->can_append() ? "" : "!");
572 printf("%sREAD ", dev->can_read() ? "" : "!");
573 printf("%sEOT ", dev->at_eot() ? "" : "!");
574 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
575 printf("%sEOF ", dev->at_eof() ? "" : "!");
576 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
577 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
580 printf(_("Device parameters:\n"));
581 printf("Device name: %s\n", dev->dev_name);
582 printf("File=%u block=%u\n", dev->file, dev->block_num);
583 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
585 printf(_("Status:\n"));
591 * Test writting larger and larger records.
592 * This is a torture test for records.
594 static void rectestcmd()
600 Pmsg0(0, _("Test writting larger and larger records.\n"
601 "This is a torture test for records.\nI am going to write\n"
602 "larger and larger records. It will stop when the record size\n"
603 "plus the header exceeds the block size (by default about 64K)\n"));
606 get_cmd(_("Do you want to continue? (y/n): "));
608 Pmsg0(000, _("Command aborted.\n"));
612 sm_check(__FILE__, __LINE__, false);
613 block = new_block(dev);
616 for (i=1; i<500000; i++) {
617 rec->data = check_pool_memory_size(rec->data, i);
618 memset(rec->data, i & 0xFF, i);
620 sm_check(__FILE__, __LINE__, false);
621 if (write_record_to_block(block, rec)) {
624 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
628 sm_check(__FILE__, __LINE__, false);
632 sm_check(__FILE__, __LINE__, false);
636 * This test attempts to re-read a block written by Bacula
637 * normally at the end of the tape. Bacula will then back up
638 * over the two eof marks, backup over the record and reread
639 * it to make sure it is valid. Bacula can skip this validation
640 * if you set "Backward space record = no"
642 static int re_read_block_test()
644 DEV_BLOCK *block = dcr->block;
649 if (!(dev->capabilities & CAP_BSR)) {
650 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
654 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
655 "I'm going to write three records and an EOF\n"
656 "then backup over the EOF and re-read the last record.\n"
657 "Bacula does this after writing the last block on the\n"
658 "tape to verify that the block was written correctly.\n\n"
659 "This is not an *essential* feature ...\n\n"));
663 rec->data = check_pool_memory_size(rec->data, block->buf_len);
664 len = rec->data_len = block->buf_len-100;
665 memset(rec->data, 1, rec->data_len);
666 if (!write_record_to_block(block, rec)) {
667 Pmsg0(0, _("Error writing record to block.\n"));
670 if (!write_block_to_dev(dcr)) {
671 Pmsg0(0, _("Error writing block to device.\n"));
674 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
676 memset(rec->data, 2, rec->data_len);
677 if (!write_record_to_block(block, rec)) {
678 Pmsg0(0, _("Error writing record to block.\n"));
681 if (!write_block_to_dev(dcr)) {
682 Pmsg0(0, _("Error writing block to device.\n"));
685 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
687 memset(rec->data, 3, rec->data_len);
688 if (!write_record_to_block(block, rec)) {
689 Pmsg0(0, _("Error writing record to block.\n"));
692 if (!write_block_to_dev(dcr)) {
693 Pmsg0(0, _("Error writing block to device.\n"));
696 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
699 if (dev_cap(dev, CAP_TWOEOF)) {
702 if (!bsf_dev(dev, 1)) {
703 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
706 if (dev_cap(dev, CAP_TWOEOF)) {
707 if (!bsf_dev(dev, 1)) {
708 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
712 Pmsg0(0, _("Backspaced over EOF OK.\n"));
713 if (!bsr_dev(dev, 1)) {
714 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
717 Pmsg0(0, _("Backspace record OK.\n"));
718 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
720 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
723 memset(rec->data, 0, rec->data_len);
724 if (!read_record_from_block(block, rec)) {
726 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
729 for (int i=0; i<len; i++) {
730 if (rec->data[i] != 3) {
731 Pmsg0(0, _("Bad data in record. Test failed!\n"));
735 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
736 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
743 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
744 "this function to verify the last block written to the\n"
745 "tape. Bacula will skip the last block verification\n"
747 "Backward Space Record = No\n\n"
748 "to your Storage daemon's Device resource definition.\n"));
755 * This test writes Bacula blocks to the tape in
756 * several files. It then rewinds the tape and attepts
757 * to read these blocks back checking the data.
759 static int write_read_test()
767 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
768 "I'm going to write 1000 records and an EOF\n"
769 "then write 1000 records and an EOF, then rewind,\n"
770 "and re-read the data to verify that it is correct.\n\n"
771 "This is an *essential* feature ...\n\n"));
774 if (!dev->rewind(dcr)) {
775 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
778 rec->data = check_pool_memory_size(rec->data, block->buf_len);
779 rec->data_len = block->buf_len-100;
780 len = rec->data_len/sizeof(i);
781 for (i=1; i<=1000; i++) {
782 p = (int *)rec->data;
783 for (j=0; j<len; j++) {
786 if (!write_record_to_block(block, rec)) {
787 Pmsg0(0, _("Error writing record to block.\n"));
790 if (!write_block_to_dev(dcr)) {
791 Pmsg0(0, _("Error writing block to device.\n"));
795 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
797 for (i=1001; i<=2000; i++) {
798 p = (int *)rec->data;
799 for (j=0; j<len; j++) {
802 if (!write_record_to_block(block, rec)) {
803 Pmsg0(0, _("Error writing record to block.\n"));
806 if (!write_block_to_dev(dcr)) {
807 Pmsg0(0, _("Error writing block to device.\n"));
811 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
813 if (dev_cap(dev, CAP_TWOEOF)) {
816 if (!dev->rewind(dcr)) {
817 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
820 Pmsg0(0, _("Rewind OK.\n"));
822 for (i=1; i<=2000; i++) {
824 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
826 if (dev_state(dev, ST_EOF)) {
827 Pmsg0(-1, _("Got EOF on tape.\n"));
832 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
835 memset(rec->data, 0, rec->data_len);
836 if (!read_record_from_block(block, rec)) {
838 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
841 p = (int *)rec->data;
842 for (j=0; j<len; j++) {
844 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
850 if (i == 1000 || i == 2000) {
851 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
854 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
863 * This test writes Bacula blocks to the tape in
864 * several files. It then rewinds the tape and attepts
865 * to read these blocks back checking the data.
867 static int position_test()
869 DEV_BLOCK *block = dcr->block;
875 int file = 0, blk = 0;
877 bool got_eof = false;
879 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
880 "I'm going to write 1000 records and an EOF\n"
881 "then write 1000 records and an EOF, then rewind,\n"
882 "and position to a few blocks and verify that it is correct.\n\n"
883 "This is an *essential* feature ...\n\n"));
886 if (!dev->rewind(dcr)) {
887 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
890 rec->data = check_pool_memory_size(rec->data, block->buf_len);
891 rec->data_len = block->buf_len-100;
892 len = rec->data_len/sizeof(i);
893 for (i=1; i<=1000; i++) {
894 p = (int *)rec->data;
895 for (j=0; j<len; j++) {
898 if (!write_record_to_block(block, rec)) {
899 Pmsg0(0, _("Error writing record to block.\n"));
902 if (!write_block_to_dev(dcr)) {
903 Pmsg0(0, _("Error writing block to device.\n"));
907 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
909 for (i=1001; i<=2000; i++) {
910 p = (int *)rec->data;
911 for (j=0; j<len; j++) {
914 if (!write_record_to_block(block, rec)) {
915 Pmsg0(0, _("Error writing record to block.\n"));
918 if (!write_block_to_dev(dcr)) {
919 Pmsg0(0, _("Error writing block to device.\n"));
923 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
925 if (dev_cap(dev, CAP_TWOEOF)) {
928 if (!dev->rewind(dcr)) {
929 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
932 Pmsg0(0, _("Rewind OK.\n"));
936 /* Set up next item to read based on where we are */
972 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
973 if (!reposition_dev(dev, file, blk)) {
974 Pmsg0(0, _("Reposition error.\n"));
978 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
980 if (dev_state(dev, ST_EOF)) {
981 Pmsg0(-1, _("Got EOF on tape.\n"));
987 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
988 recno, file, blk, be.strerror(dev->dev_errno));
989 Pmsg0(0, _("This may be because the tape drive block size is not\n"
990 " set to variable blocking as normally used by Bacula.\n"
991 " Please see the Tape Testing chapter in the manual and \n"
992 " look for using mt with defblksize and setoptions\n"
993 "If your tape drive block size is correct, then perhaps\n"
994 " your SCSI driver is *really* stupid and does not\n"
995 " correctly report the file:block after a FSF. In this\n"
996 " case try setting:\n"
997 " Fast Forward Space File = no\n"
998 " in your Device resource.\n"));
1002 memset(rec->data, 0, rec->data_len);
1003 if (!read_record_from_block(block, rec)) {
1005 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1008 p = (int *)rec->data;
1009 for (j=0; j<len; j++) {
1010 if (p[j] != recno) {
1011 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1016 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1018 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1030 * This test writes some records, then writes an end of file,
1031 * rewinds the tape, moves to the end of the data and attepts
1032 * to append to the tape. This function is essential for
1033 * Bacula to be able to write multiple jobs to the tape.
1035 static int append_test()
1037 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1038 "This test is essential to Bacula.\n\n"
1039 "I'm going to write one record in file 0,\n"
1040 " two records in file 1,\n"
1041 " and three records in file 2\n\n"));
1045 weofcmd(); /* end file 0 */
1048 weofcmd(); /* end file 1 */
1052 weofcmd(); /* end file 2 */
1053 if (dev_cap(dev, CAP_TWOEOF)) {
1056 force_close_device(dev); /* release device */
1057 if (!open_the_device()) {
1061 Pmsg0(0, _("Now moving to end of medium.\n"));
1063 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1064 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1066 if (dev->file != 3) {
1070 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1073 if (dev_cap(dev, CAP_TWOEOF)) {
1077 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1078 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1080 Pmsg0(-1, _("End scanning the tape.\n"));
1081 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1082 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1084 if (dev->file != 4) {
1092 * This test exercises the autochanger
1094 static int autochanger_test()
1096 POOLMEM *results, *changer;
1097 int slot, status, loaded;
1098 int timeout = dcr->device->max_changer_wait;
1101 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1102 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1105 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1106 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1110 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1111 "To test the autochanger you must have a blank tape\n"
1112 " that I can write on in Slot 1.\n"));
1113 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1116 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1120 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1122 results = get_pool_memory(PM_MESSAGE);
1123 changer = get_pool_memory(PM_FNAME);
1127 dcr->VolCatInfo.Slot = slot;
1128 /* Find out what is loaded, zero means device is unloaded */
1129 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1130 changer = edit_device_codes(dcr, changer,
1131 dcr->device->changer_command, "loaded");
1132 status = run_program(changer, timeout, results);
1133 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1135 loaded = atoi(results);
1138 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1139 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1143 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1145 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1147 Dmsg1(100, "Results from loaded query=%s\n", results);
1149 dcr->VolCatInfo.Slot = loaded;
1150 offline_or_rewind_dev(dev);
1151 /* We are going to load a new tape, so close the device */
1152 force_close_device(dev);
1153 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1154 loaded, dev->drive_index);
1155 changer = edit_device_codes(dcr, changer,
1156 dcr->device->changer_command, "unload");
1157 status = run_program(changer, timeout, results);
1158 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1161 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1162 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1171 dcr->VolCatInfo.Slot = slot;
1172 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1173 slot, dev->drive_index);
1174 changer = edit_device_codes(dcr, changer,
1175 dcr->device->changer_command, "load");
1176 Dmsg1(100, "Changer=%s\n", changer);
1177 force_close_device(dev);
1178 status = run_program(changer, timeout, results);
1180 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1181 slot, dev->drive_index);
1184 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1185 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1189 if (!open_the_device()) {
1193 * Start with sleep_time 0 then increment by 30 seconds if we get
1196 bmicrosleep(sleep_time, 0);
1197 if (!dev->rewind(dcr) || weof_dev(dev,1) < 0) {
1198 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
1199 clrerror_dev(dev, -1);
1200 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1201 "a longer sleep time in the mtx-script in the load) case.\n"
1202 "Adding a 30 second sleep and trying again ...\n"));
1206 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1209 if ((status = weof_dev(dev, 1)) < 0) {
1210 Pmsg2(0, _("Bad status from weof %d. ERR=%s\n"), status, strerror_dev(dev));
1213 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1217 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1219 "to your mtx-changer script in the load) case.\n\n"),
1222 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1225 free_pool_memory(changer);
1226 free_pool_memory(results);
1231 free_pool_memory(changer);
1232 free_pool_memory(results);
1233 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1237 static void autochangercmd()
1244 * This test assumes that the append test has been done,
1245 * then it tests the fsf function.
1247 static int fsf_test()
1249 bool set_off = false;
1251 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1252 "This test is essential to Bacula.\n\n"
1253 "I'm going to write five files then test forward spacing\n\n"));
1257 weofcmd(); /* end file 0 */
1260 weofcmd(); /* end file 1 */
1264 weofcmd(); /* end file 2 */
1267 weofcmd(); /* end file 3 */
1269 weofcmd(); /* end file 4 */
1270 if (dev_cap(dev, CAP_TWOEOF)) {
1276 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1278 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1281 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1282 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1284 if (dev->file != 1) {
1288 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1290 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1293 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1294 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1296 if (dev->file != 3) {
1301 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1303 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1306 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1307 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1309 if (dev->file != 4) {
1313 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1314 " Fast Forward Space File = no\n\n"
1315 "to your Device resource for this drive.\n"));
1319 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1321 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1323 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1324 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1325 if (dev->file != 5) {
1328 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1332 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1333 if (dev_cap(dev, CAP_FASTFSF)) {
1334 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1335 "I am turning it off then retrying the test.\n"));
1336 dev->capabilities &= ~CAP_FASTFSF;
1340 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1341 "Some systems, e.g. OpenBSD, require you to set\n"
1342 " Use MTIOCGET= no\n"
1343 "in your device resource. Use with caution.\n"));
1352 * This is a general test of Bacula's functions
1353 * needed to read and write the tape.
1355 static void testcmd()
1359 if (!write_read_test()) {
1362 if (!position_test()) {
1366 stat = append_test();
1367 if (stat == 1) { /* OK get out */
1370 if (stat == -1) { /* first test failed */
1371 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1372 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1373 "Setting \"Hardware End of Medium = no\n"
1374 " and \"Fast Forward Space File = no\n"
1375 "and retrying append test.\n\n"));
1376 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1377 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1378 stat = append_test();
1380 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1381 " Hardware End of Medium = No\n\n"
1382 " Fast Forward Space File = No\n"
1383 "to your Device resource in the Storage conf file.\n"));
1387 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1390 /* Wrong count after append */
1392 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1393 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1394 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1395 stat = append_test();
1397 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1398 " Hardware End of Medium = No\n"
1399 " Fast Forward Space File = No\n"
1400 " BSF at EOM = yes\n\n"
1401 "to your Device resource in the Storage conf file.\n"));
1408 Pmsg0(-1, _("\nAppend test failed.\n\n"
1409 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1410 "Unable to correct the problem. You MUST fix this\n"
1411 "problem before Bacula can use your tape drive correctly\n"
1412 "\nPerhaps running Bacula in fixed block mode will work.\n"
1413 "Do so by setting:\n\n"
1414 "Minimum Block Size = nnn\n"
1415 "Maximum Block Size = nnn\n\n"
1416 "in your Storage daemon's Device definition.\n"
1417 "nnn must match your tape driver's block size, which\n"
1418 "can be determined by reading your tape manufacturers\n"
1419 "information, and the information on your kernel dirver.\n"
1420 "Fixed block sizes, however, are not normally an ideal solution.\n"
1422 "Some systems, e.g. OpenBSD, require you to set\n"
1423 " Use MTIOCGET= no\n"
1424 "in your device resource. Use with caution.\n"));
1429 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1430 "Please double check it ...\n"
1431 "=== Sample correct output ===\n"
1432 "1 block of 64448 bytes in file 1\n"
1433 "End of File mark.\n"
1434 "2 blocks of 64448 bytes in file 2\n"
1435 "End of File mark.\n"
1436 "3 blocks of 64448 bytes in file 3\n"
1437 "End of File mark.\n"
1438 "1 block of 64448 bytes in file 4\n"
1439 "End of File mark.\n"
1440 "Total files=4, blocks=7, bytes = 451,136\n"
1441 "=== End sample correct output ===\n\n"
1442 "If the above scan output is not identical to the\n"
1443 "sample output, you MUST correct the problem\n"
1444 "or Bacula will not be able to write multiple Jobs to \n"
1448 re_read_block_test();
1451 fsf_test(); /* do fast forward space file test */
1453 autochanger_test(); /* do autochanger test */
1457 /* Forward space a file */
1458 static void fsfcmd()
1462 num = atoi(argk[1]);
1467 if (!dev->fsf(num)) {
1468 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), strerror_dev(dev));
1472 Pmsg0(0, _("Forward spaced 1 file.\n"));
1475 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1479 /* Forward space a record */
1480 static void fsrcmd()
1484 num = atoi(argk[1]);
1489 if (!dev->fsr(num)) {
1490 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1494 Pmsg0(0, _("Forward spaced 1 record.\n"));
1497 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1503 * Write a Bacula block to the tape
1507 DEV_BLOCK *block = dcr->block;
1508 DEV_RECORD *rec = dcr->rec;
1511 sm_check(__FILE__, __LINE__, false);
1514 dump_block(block, "test");
1517 i = block->buf_len - 100;
1519 rec->data = check_pool_memory_size(rec->data, i);
1520 memset(rec->data, i & 0xFF, i);
1522 sm_check(__FILE__, __LINE__, false);
1523 if (!write_record_to_block(block, rec)) {
1524 Pmsg0(0, _("Error writing record to block.\n"));
1527 if (!write_block_to_dev(dcr)) {
1528 Pmsg0(0, _("Error writing block to device.\n"));
1531 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1533 Pmsg0(0, _("Wrote block to device.\n"));
1536 sm_check(__FILE__, __LINE__, false);
1537 sm_check(__FILE__, __LINE__, false);
1541 * Read a record from the tape
1548 if (!get_cmd(_("Enter length to read: "))) {
1552 if (len < 0 || len > 1000000) {
1553 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1556 buf = (char *)malloc(len);
1557 stat = read(dev->fd, buf, len);
1558 if (stat > 0 && stat <= len) {
1562 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1563 len, stat, be.strerror());
1569 * Scan tape by reading block by block. Report what is
1570 * on the tape. Note, this command does raw reads, and as such
1571 * will not work with fixed block size devices.
1573 static void scancmd()
1576 int blocks, tot_blocks, tot_files;
1582 blocks = block_size = tot_blocks = 0;
1584 if (dev->state & ST_EOT) {
1585 Pmsg0(0, _("End of tape\n"));
1588 update_pos_dev(dev);
1589 tot_files = dev->file;
1590 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1592 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1594 clrerror_dev(dev, -1);
1595 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1596 dev->dev_name, be.strerror());
1597 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, strerror_dev(dev));
1600 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1603 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1608 Dmsg1(200, "read status = %d\n", stat);
1610 if (stat != block_size) {
1611 update_pos_dev(dev);
1614 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1617 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1623 if (stat == 0) { /* EOF */
1624 update_pos_dev(dev);
1625 printf(_("End of File mark.\n"));
1626 /* Two reads of zero means end of tape */
1627 if (dev->state & ST_EOF)
1628 dev->state |= ST_EOT;
1630 dev->state |= ST_EOF;
1633 if (dev->state & ST_EOT) {
1634 printf(_("End of tape\n"));
1637 } else { /* Got data */
1638 dev->state &= ~ST_EOF;
1644 update_pos_dev(dev);
1645 tot_files = dev->file - tot_files;
1646 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1647 edit_uint64_with_commas(bytes, ec1));
1652 * Scan tape by reading Bacula block by block. Report what is
1653 * on the tape. This function reads Bacula blocks, so if your
1654 * Device resource is correctly defined, it should work with
1655 * either variable or fixed block sizes.
1657 static void scan_blocks()
1659 int blocks, tot_blocks, tot_files;
1660 uint32_t block_size;
1662 DEV_BLOCK *block = dcr->block;
1664 char buf1[100], buf2[100];
1666 blocks = block_size = tot_blocks = 0;
1670 update_pos_dev(dev);
1671 tot_files = dev->file;
1673 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1674 Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
1675 if (dev->state & ST_EOT) {
1678 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1681 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1687 if (dev->state & ST_EOF) {
1690 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1693 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1697 printf(_("End of File mark.\n"));
1700 if (dev->state & ST_SHORT) {
1703 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1706 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1710 printf(_("Short block read.\n"));
1713 printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1716 if (block->block_len != block_size) {
1719 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1722 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1726 block_size = block->block_len;
1730 bytes += block->block_len;
1731 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1732 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1733 block->VolSessionId, block->VolSessionTime);
1735 DEV_RECORD *rec = new_record();
1736 read_record_from_block(block, rec);
1737 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1738 block->BlockNumber, dev->block_num, block->block_len,
1739 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1740 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1743 } else if (verbose > 1) {
1744 dump_block(block, "");
1749 tot_files = dev->file - tot_files;
1750 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1751 edit_uint64_with_commas(bytes, ec1));
1755 static void statcmd()
1757 int debug = debug_level;
1759 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), strerror_dev(dev));
1761 dump_volume_label(dev);
1763 debug_level = debug;
1768 * First we label the tape, then we fill
1769 * it with data get a new tape and write a few blocks.
1771 static void fillcmd()
1774 DEV_BLOCK *block = dcr->block;
1776 char buf1[100], buf2[100];
1779 uint32_t min_block_size;
1790 "This command simulates Bacula writing to a tape.\n"
1791 "It requires either one or two blank tapes, which it\n"
1792 "will label and write.\n\n"
1793 "If you have an autochanger configured, it will use\n"
1794 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1795 "be prompted to insert the tapes when necessary.\n\n"
1796 "It will print a status approximately\n"
1797 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1798 "selected the simple test option, after writing the first tape\n"
1799 "it will rewind it and re-read the last block written.\n\n"
1800 "If you have selected the multiple tape test, when the first tape\n"
1801 "fills, it will ask for a second, and after writing a few more \n"
1802 "blocks, it will stop. Then it will begin re-reading the\n"
1804 "This may take a long time -- hours! ...\n\n"));
1806 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1807 "or the complete multiple tape (m) test: (s/m) "));
1808 if (cmd[0] == 's') {
1809 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1811 } else if (cmd[0] == 'm') {
1812 Pmsg0(-1, _("Multiple tape test selected.\n"));
1815 Pmsg0(000, _("Command aborted.\n"));
1819 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1820 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1822 /* Use fixed block size to simplify read back */
1823 min_block_size = dev->min_block_size;
1824 dev->min_block_size = dev->max_block_size;
1825 set_volume_name("TestVolume1", 1);
1827 if (!dev->rewind(dcr)) {
1828 Pmsg0(000, _("Rewind failed.\n"));
1831 Pmsg0(000, _("Write EOF failed.\n"));
1834 dev->set_append(); /* force volume to be relabeled */
1837 * Acquire output device for writing. Note, after acquiring a
1838 * device, we MUST release it, which is done at the end of this
1841 Dmsg0(100, "just before acquire_device\n");
1842 if (!acquire_device_for_append(dcr)) {
1843 set_jcr_job_status(jcr, JS_ErrorTerminated);
1846 block = jcr->dcr->block;
1848 Dmsg0(100, "Just after acquire_device_for_append\n");
1850 * Write Begin Session Record
1852 if (!write_session_label(dcr, SOS_LABEL)) {
1853 set_jcr_job_status(jcr, JS_ErrorTerminated);
1854 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1858 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1860 memset(&rec, 0, sizeof(rec));
1861 rec.data = get_memory(100000); /* max record size */
1863 #define REC_SIZE 32768
1864 rec.data_len = REC_SIZE;
1867 * Put some random data in the record
1869 fd = open("/dev/urandom", O_RDONLY);
1871 read(fd, rec.data, rec.data_len);
1874 uint32_t *p = (uint32_t *)rec.data;
1875 srandom(time(NULL));
1876 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1882 * Generate data as if from File daemon, write to device
1884 jcr->dcr->VolFirstIndex = 0;
1885 time(&jcr->run_time); /* start counting time for rates */
1886 localtime_r(&jcr->run_time, &tm);
1887 strftime(buf1, sizeof(buf1), "%T", &tm);
1889 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1891 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1893 for (file_index = 0; ok && !job_canceled(jcr); ) {
1894 rec.VolSessionId = jcr->VolSessionId;
1895 rec.VolSessionTime = jcr->VolSessionTime;
1896 rec.FileIndex = ++file_index;
1897 rec.Stream = STREAM_FILE_DATA;
1899 /* Mix up the data just a bit */
1900 uint32_t *lp = (uint32_t *)rec.data;
1902 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1906 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1907 rec.FileIndex, rec.VolSessionId,
1908 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1911 while (!write_record_to_block(block, &rec)) {
1913 * When we get here we have just filled a block
1915 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1918 /* Write block to tape */
1919 if (!flush_block(block, 1)) {
1923 /* Every 5000 blocks (approx 322MB) report where we are.
1925 if ((block->BlockNumber % 5000) == 0) {
1927 now -= jcr->run_time;
1929 now = 1; /* prevent divide error */
1931 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1932 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1933 block->BlockNumber, dev->block_num,
1934 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1936 /* Every 32000 blocks (approx 2GB) write an EOF.
1938 if ((block->BlockNumber % 32000) == 0) {
1940 localtime_r(&now, &tm);
1941 strftime(buf1, sizeof(buf1), "%T", &tm);
1942 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1943 flush_block(block, 0);
1947 /* Get out after writing 10 blocks to the second tape */
1948 if (++BlockNumber > 10 && stop != 0) { /* get out */
1953 Pmsg0(000, _("Not OK\n"));
1956 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1957 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1958 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1959 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1961 /* Get out after writing 10 blocks to the second tape */
1962 if (BlockNumber > 10 && stop != 0) { /* get out */
1963 Pmsg0(-1, "Done writing ...\n");
1968 Dmsg0(100, "Write_end_session_label()\n");
1969 /* Create Job status for end of session label */
1970 if (!job_canceled(jcr) && ok) {
1971 set_jcr_job_status(jcr, JS_Terminated);
1973 set_jcr_job_status(jcr, JS_ErrorTerminated);
1975 if (!write_session_label(dcr, EOS_LABEL)) {
1976 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1979 /* Write out final block of this session */
1980 if (!write_block_to_device(dcr)) {
1981 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1984 Pmsg0(-1, _("Wrote End of Session label.\n"));
1986 /* Save last block info for second tape */
1987 last_block_num2 = last_block_num;
1988 last_file2 = last_file;
1990 free_block(last_block2);
1992 last_block2 = dup_block(last_block);
1995 sprintf(buf, "%s/btape.state", working_directory);
1996 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1998 write(fd, &btape_state_level, sizeof(btape_state_level));
1999 write(fd, &simple, sizeof(simple));
2000 write(fd, &last_block_num1, sizeof(last_block_num1));
2001 write(fd, &last_block_num2, sizeof(last_block_num2));
2002 write(fd, &last_file1, sizeof(last_file1));
2003 write(fd, &last_file2, sizeof(last_file2));
2004 write(fd, last_block1->buf, last_block1->buf_len);
2005 write(fd, last_block2->buf, last_block2->buf_len);
2006 write(fd, first_block->buf, first_block->buf_len);
2008 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2009 last_block_num1, last_block_num2);
2012 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2017 localtime_r(&now, &tm);
2018 strftime(buf1, sizeof(buf1), "%T", &tm);
2020 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2021 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2024 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2025 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2028 jcr->dcr->block = block;
2031 dev->min_block_size = min_block_size;
2032 free_memory(rec.data);
2036 * Read two tapes written by the "fill" command and ensure
2037 * that the data is valid. If stop==1 we simulate full read back
2038 * of two tapes. If stop==-1 we simply read the last block and
2039 * verify that it is correct.
2041 static void unfillcmd()
2045 last_block1 = new_block(dev);
2046 last_block2 = new_block(dev);
2047 first_block = new_block(dev);
2048 sprintf(buf, "%s/btape.state", working_directory);
2049 fd = open(buf, O_RDONLY);
2051 uint32_t state_level;
2052 read(fd, &state_level, sizeof(btape_state_level));
2053 read(fd, &simple, sizeof(simple));
2054 read(fd, &last_block_num1, sizeof(last_block_num1));
2055 read(fd, &last_block_num2, sizeof(last_block_num2));
2056 read(fd, &last_file1, sizeof(last_file1));
2057 read(fd, &last_file2, sizeof(last_file2));
2058 read(fd, last_block1->buf, last_block1->buf_len);
2059 read(fd, last_block2->buf, last_block2->buf_len);
2060 read(fd, first_block->buf, first_block->buf_len);
2062 if (state_level != btape_state_level) {
2063 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2064 "the fill command.\n"));
2069 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2070 "You must redo the fill command.\n"), buf, be.strerror());
2077 static void do_unfill()
2079 DEV_BLOCK *block = dcr->block;
2086 Dmsg0(20, "Enter do_unfill\n");
2087 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2088 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2092 time(&jcr->run_time); /* start counting time for rates */
2096 free_block(last_block);
2098 last_block_num = last_block_num1;
2099 last_file = last_file1;
2100 last_block = last_block1;
2103 /* Multiple Volume tape */
2104 /* Close device so user can use autochanger if desired */
2105 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2108 autochanger = autoload_device(dcr, 1, NULL);
2110 force_close_device(dev);
2111 get_cmd(_("Mount first tape. Press enter when ready: "));
2113 free_restore_volume_list(jcr);
2114 jcr->dcr = new_dcr(jcr, dev);
2115 set_volume_name("TestVolume1", 1);
2117 create_restore_volume_list(jcr);
2119 dev->state &= ~(ST_READ|ST_APPEND);
2120 dev->num_writers = 0;
2121 if (!acquire_device_for_read(dcr)) {
2122 Pmsg1(-1, "%s", dev->errmsg);
2127 * We now have the first tape mounted.
2128 * Note, re-reading last block may have caused us to
2129 * loose track of where we are (block number unknown).
2131 Pmsg0(-1, _("Rewinding.\n"));
2132 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2135 /* Read the first 10000 records */
2136 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2137 dev->file, dev->block_num);
2139 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2140 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2141 last_file, last_block_num);
2142 if (!reposition_dev(dev, last_file, last_block_num)) {
2143 Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2146 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2147 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2148 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2151 if (compare_blocks(last_block, block)) {
2153 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2155 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2162 /* restore info for last block on second Volume */
2163 last_block_num = last_block_num2;
2164 last_file = last_file2;
2165 last_block = last_block2;
2167 /* Multiple Volume tape */
2168 /* Close device so user can use autochanger if desired */
2169 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2173 free_restore_volume_list(jcr);
2174 set_volume_name("TestVolume2", 2);
2176 create_restore_volume_list(jcr);
2177 autochanger = autoload_device(dcr, 1, NULL);
2179 force_close_device(dev);
2180 get_cmd(_("Mount second tape. Press enter when ready: "));
2184 if (!acquire_device_for_read(dcr)) {
2185 Pmsg1(-1, "%s", dev->errmsg);
2189 /* Space to "first" block which is last block not written
2190 * on the previous tape.
2192 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2193 if (!reposition_dev(dev, 0, 1)) {
2194 Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2197 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2198 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2199 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2202 if (compare_blocks(first_block, block)) {
2203 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2206 /* Now find and compare the last block */
2207 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2208 last_file, last_block_num);
2209 if (!reposition_dev(dev, last_file, last_block_num)) {
2210 Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2213 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2214 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2215 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2218 if (compare_blocks(last_block, block)) {
2219 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2223 free_block(last_block1);
2224 free_block(last_block2);
2225 free_block(first_block);
2228 /* Read 10000 records then stop */
2229 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2231 DEVICE *dev = dcr->dev;
2233 if (quickie_count == 10000) {
2234 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2236 return quickie_count < 10000;
2239 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2242 uint32_t CheckSum, block_len;
2245 p = last_block->buf;
2247 unser_begin(q, BLKHDR2_LENGTH);
2248 unser_uint32(CheckSum);
2249 unser_uint32(block_len);
2250 while (q < (block->buf+block_len)) {
2257 dump_block(last_block, _("Last block written"));
2259 dump_block(block, _("Block read back"));
2260 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2261 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2262 "that was read back differ. The test FAILED !!!!\n"
2263 "This must be corrected before you use Bacula\n"
2264 "to write multi-tape Volumes.!!!!\n"));
2268 dump_block(last_block, _("Last block written"));
2269 dump_block(block, _("Block read back"));
2279 * Write current block to tape regardless of whether or
2280 * not it is full. If the tape fills, attempt to
2281 * acquire another tape.
2283 static int flush_block(DEV_BLOCK *block, int dump)
2287 uint32_t this_file, this_block_num;
2291 this_block = new_block(dev);
2294 last_block = new_block(dev);
2297 this_file = dev->file;
2298 this_block_num = dev->block_num;
2299 if (!write_block_to_dev(dcr)) {
2300 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2301 last_file, last_block_num, this_block_num);
2304 * This is 1st tape, so save first tape info separate
2305 * from second tape info
2307 last_block_num1 = last_block_num;
2308 last_file1 = last_file;
2309 last_block1 = dup_block(last_block);
2310 last_block2 = dup_block(last_block);
2311 first_block = dup_block(block); /* first block second tape */
2314 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2315 (unsigned)file_index, block->BlockNumber, block->block_len);
2316 dump_block(last_block, _("Last block written"));
2318 dump_block(block, _("Block not written"));
2321 eot_block = block->BlockNumber;
2322 eot_block_len = block->block_len;
2323 eot_FileIndex = file_index;
2327 now -= jcr->run_time;
2329 now = 1; /* don't divide by zero */
2331 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2332 vol_size = dev->VolCatInfo.VolCatBytes;
2333 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2334 dev->file, dev->block_num,
2335 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2338 stop = -1; /* stop, but do simplified test */
2340 /* Full test in progress */
2341 if (!fixup_device_block_write_error(jcr->dcr)) {
2342 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2347 BlockNumber = 0; /* start counting for second tape */
2350 return 1; /* end of tape reached */
2353 /* Save contents after write so that the header is serialized */
2354 memcpy(this_block->buf, block->buf, this_block->buf_len);
2357 * Note, we always read/write to block, but we toggle
2358 * copying it to one or another of two allocated blocks.
2359 * Switch blocks so that the block just successfully written is
2360 * always in last_block.
2362 tblock = last_block;
2363 last_block = this_block;
2364 this_block = tblock;
2365 last_file = this_file;
2366 last_block_num = this_block_num;
2374 * First we label the tape, then we fill
2375 * it with data get a new tape and write a few blocks.
2377 static void qfillcmd()
2379 DEV_BLOCK *block = dcr->block;
2380 DEV_RECORD *rec = dcr->rec;
2383 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2385 get_cmd(_("How many blocks do you want to write? (1000): "));
2392 sm_check(__FILE__, __LINE__, false);
2394 i = block->buf_len - 100;
2396 rec->data = check_pool_memory_size(rec->data, i);
2397 memset(rec->data, i & 0xFF, i);
2400 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2401 for (i=0; i < count; i++) {
2406 if (!write_record_to_block(block, rec)) {
2407 Pmsg0(0, _("Error writing record to block.\n"));
2410 if (!write_block_to_dev(dcr)) {
2411 Pmsg0(0, _("Error writing block to device.\n"));
2417 if (dev_cap(dev, CAP_TWOEOF)) {
2424 sm_check(__FILE__, __LINE__, false);
2428 * Fill a tape using raw write() command
2430 static void rawfill_cmd()
2432 DEV_BLOCK *block = dcr->block;
2435 uint32_t block_num = 0;
2440 fd = open("/dev/urandom", O_RDONLY);
2442 read(fd, block->buf, block->buf_len);
2445 uint32_t *p = (uint32_t *)block->buf;
2446 srandom(time(NULL));
2447 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2451 p = (uint32_t *)block->buf;
2452 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2455 stat = write(dev->fd, block->buf, block->buf_len);
2456 if (stat == (int)block->buf_len) {
2457 if ((block_num++ % 100) == 0) {
2462 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2472 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2473 be.strerror(my_errno));
2479 * Fill a tape using Bacula block writes
2481 static void bfill_cmd()
2483 DEV_BLOCK *block = dcr->block;
2484 uint32_t block_num = 0;
2490 fd = open("/dev/urandom", O_RDONLY);
2492 read(fd, block->buf, block->buf_len);
2495 uint32_t *p = (uint32_t *)block->buf;
2496 srandom(time(NULL));
2497 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2501 p = (uint32_t *)block->buf;
2502 Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2505 block->binbuf = block->buf_len;
2506 block->bufp = block->buf + block->binbuf;
2507 if (!write_block_to_dev(dcr)) {
2510 if ((block_num++ % 100) == 0) {
2515 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2521 printf(_("Write failed at block %u.\n"), block_num);
2526 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2527 static struct cmdstruct commands[] = {
2528 {N_("autochanger"),autochangercmd, _("test autochanger")},
2529 {N_("bsf"), bsfcmd, _("backspace file")},
2530 {N_("bsr"), bsrcmd, _("backspace record")},
2531 {N_("bfill"), bfill_cmd, _("fill tape using Bacula writes")},
2532 {N_("cap"), capcmd, _("list device capabilities")},
2533 {N_("clear"), clearcmd, _("clear tape errors")},
2534 {N_("eod"), eodcmd, _("go to end of Bacula data for append")},
2535 {N_("eom"), eomcmd, _("go to the physical end of medium")},
2536 {N_("fill"), fillcmd, _("fill tape, write onto second volume")},
2537 {N_("unfill"), unfillcmd, _("read filled tape")},
2538 {N_("fsf"), fsfcmd, _("forward space a file")},
2539 {N_("fsr"), fsrcmd, _("forward space a record")},
2540 {N_("help"), helpcmd, _("print this command")},
2541 {N_("label"), labelcmd, _("write a Bacula label to the tape")},
2542 {N_("load"), loadcmd, _("load a tape")},
2543 {N_("quit"), quitcmd, _("quit btape")},
2544 {N_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2545 {N_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2546 {N_("rectest"), rectestcmd, _("test record handling functions")},
2547 {N_("rewind"), rewindcmd, _("rewind the tape")},
2548 {N_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2549 {N_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2550 {N_("status"), statcmd, _("print tape status")},
2551 {N_("test"), testcmd, _("General test Bacula tape functions")},
2552 {N_("weof"), weofcmd, _("write an EOF on the tape")},
2553 {N_("wr"), wrcmd, _("write a single Bacula block")},
2554 {N_("rr"), rrcmd, _("read a single record")},
2555 {N_("qfill"), qfillcmd, _("quick fill command")}
2557 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2565 while (get_cmd("*")) {
2566 sm_check(__FILE__, __LINE__, false);
2568 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2569 for (i=0; i<comsize; i++) /* search for command */
2570 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2571 (*commands[i].func)(); /* go execute command */
2576 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2582 static void helpcmd()
2586 printf(_("Interactive commands:\n"));
2587 printf(_(" Command Description\n ======= ===========\n"));
2588 for (i=0; i<comsize; i++)
2589 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2596 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2597 "\nVersion: %s (%s)\n\n"
2598 "Usage: btape <options> <device_name>\n"
2599 " -b <file> specify bootstrap file\n"
2600 " -c <file> set configuration file to file\n"
2601 " -d <nn> set debug level to nn\n"
2602 " -p proceed inspite of I/O errors\n"
2603 " -s turn off signals\n"
2605 " -? print this message.\n"
2606 "\n"), VERSION, BDATE);
2611 * Get next input command from terminal. This
2612 * routine is REALLY primitive, and should be enhanced
2613 * to have correct backspacing, etc.
2616 get_cmd(const char *prompt)
2620 fprintf(stdout, prompt);
2622 /* We really should turn off echoing and pretty this
2626 while ((ch = fgetc(stdin)) != EOF) {
2628 strip_trailing_junk(cmd);
2630 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2643 /* Dummies to replace askdir.c */
2644 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2645 bool dir_send_job_status(JCR *jcr) {return 1;}
2647 bool dir_update_volume_info(DCR *dcr, bool relabel)
2653 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2655 Dmsg0(20, "Enter dir_get_volume_info\n");
2656 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2660 bool dir_create_jobmedia_record(DCR *dcr)
2662 dcr->WroteVol = false;
2667 bool dir_find_next_appendable_volume(DCR *dcr)
2669 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2670 return dcr->VolumeName[0] != 0;
2673 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2675 DEVICE *dev = dcr->dev;
2676 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2677 if (dcr->VolumeName[0] == 0) {
2678 return dir_ask_sysop_to_create_appendable_volume(dcr);
2680 /* Close device so user can use autochanger if desired */
2681 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2684 force_close_device(dev);
2685 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2686 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2687 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2690 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2691 dcr->VolumeName, dev->print_name());
2697 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2700 DEVICE *dev = dcr->dev;
2701 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2703 set_volume_name("TestVolume1", 1);
2705 set_volume_name("TestVolume2", 2);
2707 /* Close device so user can use autochanger if desired */
2708 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2711 autochanger = autoload_device(dcr, 1, NULL);
2713 force_close_device(dev);
2714 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2725 static bool my_mount_next_read_volume(DCR *dcr)
2728 JCR *jcr = dcr->jcr;
2729 DEV_BLOCK *block = dcr->block;
2731 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2732 Pmsg1(000, _("End of Volume \"%s\"\n"), dcr->VolumeName);
2734 if (LastBlock != block->BlockNumber) {
2735 VolBytes += block->block_len;
2737 LastBlock = block->BlockNumber;
2739 now -= jcr->run_time;
2743 kbs = (double)VolBytes / (1000.0 * (double)now);
2744 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2745 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2747 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2752 free_restore_volume_list(jcr);
2753 set_volume_name("TestVolume2", 2);
2755 create_restore_volume_list(jcr);
2758 if (!acquire_device_for_read(dcr)) {
2759 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2762 return true; /* next volume mounted */
2765 static void set_volume_name(const char *VolName, int volnum)
2767 DCR *dcr = jcr->dcr;
2768 VolumeName = VolName;
2770 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2771 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2772 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2773 dcr->VolCatInfo.Slot = volnum;
2776 VOLRES *new_volume(DCR *dcr, const char *VolumeName) { return NULL; }
2777 bool free_volume(DEVICE *dev) { return true; }
2778 void free_unused_volume(DCR *dcr) { }