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 if (!dev->is_open()) {
332 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
333 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
334 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
340 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
341 dev->set_append(); /* put volume in append mode */
354 * Write a label to the tape
356 static void labelcmd()
359 pm_strcpy(cmd, VolumeName);
361 if (!get_cmd(_("Enter Volume Name: "))) {
366 if (!dev->is_open()) {
367 if (!first_open_device(dcr)) {
368 Pmsg1(0, _("Device open failed. ERR=%s\n"), strerror_dev(dev));
372 write_new_volume_label_to_dev(dcr, cmd, "Default");
373 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
377 * Read the tape label
379 static void readlabelcmd()
381 int save_debug_level = debug_level;
384 stat = read_dev_volume_label(dcr);
387 Pmsg0(0, _("Volume has no label.\n"));
390 Pmsg0(0, _("Volume label read correctly.\n"));
393 Pmsg1(0, _("I/O error on device: ERR=%s"), strerror_dev(dev));
396 Pmsg0(0, _("Volume name error\n"));
398 case VOL_CREATE_ERROR:
399 Pmsg1(0, _("Error creating label. ERR=%s"), strerror_dev(dev));
401 case VOL_VERSION_ERROR:
402 Pmsg0(0, _("Volume version error.\n"));
404 case VOL_LABEL_ERROR:
405 Pmsg0(0, _("Bad Volume label type.\n"));
408 Pmsg0(0, _("Unknown error.\n"));
413 dump_volume_label(dev);
414 debug_level = save_debug_level;
419 * Load the tape should have prevously been taken
420 * off line, otherwise this command is not necessary.
422 static void loadcmd()
425 if (!load_dev(dev)) {
426 Pmsg1(0, _("Bad status from load. ERR=%s\n"), strerror_dev(dev));
428 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
434 static void rewindcmd()
436 if (!rewind_dev(dev)) {
437 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
438 clrerror_dev(dev, -1);
440 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
445 * Clear any tape error
447 static void clearcmd()
449 clrerror_dev(dev, -1);
453 * Write and end of file on the tape
455 static void weofcmd()
466 if ((stat = weof_dev(dev, num)) < 0) {
467 Pmsg2(0, _("Bad status from weof %d. ERR=%s\n"), stat, strerror_dev(dev));
471 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
474 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
480 /* Go to the end of the medium -- raw command
481 * The idea was orginally that the end of the Bacula
482 * medium would be flagged differently. This is not
483 * currently the case. So, this is identical to the
489 Pmsg1(0, "%s", strerror_dev(dev));
492 Pmsg0(0, _("Moved to end of medium.\n"));
497 * Go to the end of the medium (either hardware determined
498 * or defined by two eofs.
518 if (!bsf_dev(dev, num)) {
519 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
521 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
537 if (!bsr_dev(dev, num)) {
538 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
540 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
545 * List device capabilities as defined in the
550 printf(_("Configured device capabilities:\n"));
551 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
552 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
553 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
554 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
555 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
556 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
557 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
558 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
559 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
560 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
561 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
562 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
563 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
564 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
565 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
568 printf(_("Device status:\n"));
569 printf("%sOPENED ", dev->is_open() ? "" : "!");
570 printf("%sTAPE ", dev->is_tape() ? "" : "!");
571 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
572 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
573 printf("%sAPPEND ", dev->can_append() ? "" : "!");
574 printf("%sREAD ", dev->can_read() ? "" : "!");
575 printf("%sEOT ", dev->at_eot() ? "" : "!");
576 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
577 printf("%sEOF ", dev->at_eof() ? "" : "!");
578 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
579 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
582 printf(_("Device parameters:\n"));
583 printf("Device name: %s\n", dev->dev_name);
584 printf("File=%u block=%u\n", dev->file, dev->block_num);
585 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
587 printf(_("Status:\n"));
593 * Test writting larger and larger records.
594 * This is a torture test for records.
596 static void rectestcmd()
602 Pmsg0(0, _("Test writting larger and larger records.\n"
603 "This is a torture test for records.\nI am going to write\n"
604 "larger and larger records. It will stop when the record size\n"
605 "plus the header exceeds the block size (by default about 64K)\n"));
608 get_cmd(_("Do you want to continue? (y/n): "));
610 Pmsg0(000, _("Command aborted.\n"));
614 sm_check(__FILE__, __LINE__, false);
615 block = new_block(dev);
618 for (i=1; i<500000; i++) {
619 rec->data = check_pool_memory_size(rec->data, i);
620 memset(rec->data, i & 0xFF, i);
622 sm_check(__FILE__, __LINE__, false);
623 if (write_record_to_block(block, rec)) {
626 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
630 sm_check(__FILE__, __LINE__, false);
634 sm_check(__FILE__, __LINE__, false);
638 * This test attempts to re-read a block written by Bacula
639 * normally at the end of the tape. Bacula will then back up
640 * over the two eof marks, backup over the record and reread
641 * it to make sure it is valid. Bacula can skip this validation
642 * if you set "Backward space record = no"
644 static int re_read_block_test()
646 DEV_BLOCK *block = dcr->block;
651 if (!(dev->capabilities & CAP_BSR)) {
652 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
656 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
657 "I'm going to write three records and an EOF\n"
658 "then backup over the EOF and re-read the last record.\n"
659 "Bacula does this after writing the last block on the\n"
660 "tape to verify that the block was written correctly.\n\n"
661 "This is not an *essential* feature ...\n\n"));
665 rec->data = check_pool_memory_size(rec->data, block->buf_len);
666 len = rec->data_len = block->buf_len-100;
667 memset(rec->data, 1, 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 first record of %d bytes.\n"), rec->data_len);
678 memset(rec->data, 2, 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 second record of %d bytes.\n"), rec->data_len);
689 memset(rec->data, 3, rec->data_len);
690 if (!write_record_to_block(block, rec)) {
691 Pmsg0(0, _("Error writing record to block.\n"));
694 if (!write_block_to_dev(dcr)) {
695 Pmsg0(0, _("Error writing block to device.\n"));
698 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
701 if (dev_cap(dev, CAP_TWOEOF)) {
704 if (!bsf_dev(dev, 1)) {
705 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
708 if (dev_cap(dev, CAP_TWOEOF)) {
709 if (!bsf_dev(dev, 1)) {
710 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
714 Pmsg0(0, _("Backspaced over EOF OK.\n"));
715 if (!bsr_dev(dev, 1)) {
716 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
719 Pmsg0(0, _("Backspace record OK.\n"));
720 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
722 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
725 memset(rec->data, 0, rec->data_len);
726 if (!read_record_from_block(block, rec)) {
728 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
731 for (int i=0; i<len; i++) {
732 if (rec->data[i] != 3) {
733 Pmsg0(0, _("Bad data in record. Test failed!\n"));
737 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
738 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
745 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
746 "this function to verify the last block written to the\n"
747 "tape. Bacula will skip the last block verification\n"
749 "Backward Space Record = No\n\n"
750 "to your Storage daemon's Device resource definition.\n"));
757 * This test writes Bacula blocks to the tape in
758 * several files. It then rewinds the tape and attepts
759 * to read these blocks back checking the data.
761 static int write_read_test()
769 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
770 "I'm going to write 1000 records and an EOF\n"
771 "then write 1000 records and an EOF, then rewind,\n"
772 "and re-read the data to verify that it is correct.\n\n"
773 "This is an *essential* feature ...\n\n"));
776 if (!rewind_dev(dev)) {
777 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
780 rec->data = check_pool_memory_size(rec->data, block->buf_len);
781 rec->data_len = block->buf_len-100;
782 len = rec->data_len/sizeof(i);
783 for (i=1; i<=1000; i++) {
784 p = (int *)rec->data;
785 for (j=0; j<len; j++) {
788 if (!write_record_to_block(block, rec)) {
789 Pmsg0(0, _("Error writing record to block.\n"));
792 if (!write_block_to_dev(dcr)) {
793 Pmsg0(0, _("Error writing block to device.\n"));
797 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
799 for (i=1001; i<=2000; i++) {
800 p = (int *)rec->data;
801 for (j=0; j<len; j++) {
804 if (!write_record_to_block(block, rec)) {
805 Pmsg0(0, _("Error writing record to block.\n"));
808 if (!write_block_to_dev(dcr)) {
809 Pmsg0(0, _("Error writing block to device.\n"));
813 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
815 if (dev_cap(dev, CAP_TWOEOF)) {
818 if (!rewind_dev(dev)) {
819 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
822 Pmsg0(0, _("Rewind OK.\n"));
824 for (i=1; i<=2000; i++) {
826 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
828 if (dev_state(dev, ST_EOF)) {
829 Pmsg0(-1, _("Got EOF on tape.\n"));
834 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
837 memset(rec->data, 0, rec->data_len);
838 if (!read_record_from_block(block, rec)) {
840 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
843 p = (int *)rec->data;
844 for (j=0; j<len; j++) {
846 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
852 if (i == 1000 || i == 2000) {
853 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
856 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
865 * This test writes Bacula blocks to the tape in
866 * several files. It then rewinds the tape and attepts
867 * to read these blocks back checking the data.
869 static int position_test()
871 DEV_BLOCK *block = dcr->block;
877 int file = 0, blk = 0;
879 bool got_eof = false;
881 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
882 "I'm going to write 1000 records and an EOF\n"
883 "then write 1000 records and an EOF, then rewind,\n"
884 "and position to a few blocks and verify that it is correct.\n\n"
885 "This is an *essential* feature ...\n\n"));
888 if (!rewind_dev(dev)) {
889 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
892 rec->data = check_pool_memory_size(rec->data, block->buf_len);
893 rec->data_len = block->buf_len-100;
894 len = rec->data_len/sizeof(i);
895 for (i=1; i<=1000; i++) {
896 p = (int *)rec->data;
897 for (j=0; j<len; j++) {
900 if (!write_record_to_block(block, rec)) {
901 Pmsg0(0, _("Error writing record to block.\n"));
904 if (!write_block_to_dev(dcr)) {
905 Pmsg0(0, _("Error writing block to device.\n"));
909 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
911 for (i=1001; i<=2000; i++) {
912 p = (int *)rec->data;
913 for (j=0; j<len; j++) {
916 if (!write_record_to_block(block, rec)) {
917 Pmsg0(0, _("Error writing record to block.\n"));
920 if (!write_block_to_dev(dcr)) {
921 Pmsg0(0, _("Error writing block to device.\n"));
925 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
927 if (dev_cap(dev, CAP_TWOEOF)) {
930 if (!rewind_dev(dev)) {
931 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
934 Pmsg0(0, _("Rewind OK.\n"));
938 /* Set up next item to read based on where we are */
974 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
975 if (!reposition_dev(dev, file, blk)) {
976 Pmsg0(0, _("Reposition error.\n"));
980 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
982 if (dev_state(dev, ST_EOF)) {
983 Pmsg0(-1, _("Got EOF on tape.\n"));
989 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
990 recno, file, blk, be.strerror(dev->dev_errno));
991 Pmsg0(0, _("This may be because the tape drive block size is not\n"
992 " set to variable blocking as normally used by Bacula.\n"
993 " Please see the Tape Testing chapter in the manual and \n"
994 " look for using mt with defblksize and setoptions\n"
995 "If your tape drive block size is correct, then perhaps\n"
996 " your SCSI driver is *really* stupid and does not\n"
997 " correctly report the file:block after a FSF. In this\n"
998 " case try setting:\n"
999 " Fast Forward Space File = no\n"
1000 " in your Device resource.\n"));
1004 memset(rec->data, 0, rec->data_len);
1005 if (!read_record_from_block(block, rec)) {
1007 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1010 p = (int *)rec->data;
1011 for (j=0; j<len; j++) {
1012 if (p[j] != recno) {
1013 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1018 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1020 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1032 * This test writes some records, then writes an end of file,
1033 * rewinds the tape, moves to the end of the data and attepts
1034 * to append to the tape. This function is essential for
1035 * Bacula to be able to write multiple jobs to the tape.
1037 static int append_test()
1039 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1040 "This test is essential to Bacula.\n\n"
1041 "I'm going to write one record in file 0,\n"
1042 " two records in file 1,\n"
1043 " and three records in file 2\n\n"));
1047 weofcmd(); /* end file 0 */
1050 weofcmd(); /* end file 1 */
1054 weofcmd(); /* end file 2 */
1055 if (dev_cap(dev, CAP_TWOEOF)) {
1058 force_close_device(dev); /* release device */
1059 if (!open_the_device()) {
1063 Pmsg0(0, _("Now moving to end of medium.\n"));
1065 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1066 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1068 if (dev->file != 3) {
1072 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1075 if (dev_cap(dev, CAP_TWOEOF)) {
1079 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1080 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1082 Pmsg0(-1, _("End scanning the tape.\n"));
1083 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1084 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1086 if (dev->file != 4) {
1094 * This test exercises the autochanger
1096 static int autochanger_test()
1098 POOLMEM *results, *changer;
1099 int slot, status, loaded;
1100 int timeout = dcr->device->max_changer_wait;
1103 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1104 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1107 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1108 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1112 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1113 "To test the autochanger you must have a blank tape\n"
1114 " that I can write on in Slot 1.\n"));
1115 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1118 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1122 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1124 results = get_pool_memory(PM_MESSAGE);
1125 changer = get_pool_memory(PM_FNAME);
1129 dcr->VolCatInfo.Slot = slot;
1130 /* Find out what is loaded, zero means device is unloaded */
1131 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1132 changer = edit_device_codes(dcr, changer,
1133 dcr->device->changer_command, "loaded");
1134 status = run_program(changer, timeout, results);
1135 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1137 loaded = atoi(results);
1140 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1141 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1145 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1147 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1149 Dmsg1(100, "Results from loaded query=%s\n", results);
1151 dcr->VolCatInfo.Slot = loaded;
1152 offline_or_rewind_dev(dev);
1153 /* We are going to load a new tape, so close the device */
1154 force_close_device(dev);
1155 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1156 loaded, dev->drive_index);
1157 changer = edit_device_codes(dcr, changer,
1158 dcr->device->changer_command, "unload");
1159 status = run_program(changer, timeout, results);
1160 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1163 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1164 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1173 dcr->VolCatInfo.Slot = slot;
1174 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1175 slot, dev->drive_index);
1176 changer = edit_device_codes(dcr, changer,
1177 dcr->device->changer_command, "load");
1178 Dmsg1(100, "Changer=%s\n", changer);
1179 force_close_device(dev);
1180 status = run_program(changer, timeout, results);
1182 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1183 slot, dev->drive_index);
1186 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1187 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1191 if (!open_the_device()) {
1195 * Start with sleep_time 0 then increment by 30 seconds if we get
1198 bmicrosleep(sleep_time, 0);
1199 if (!rewind_dev(dev) || weof_dev(dev,1) < 0) {
1200 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
1201 clrerror_dev(dev, -1);
1202 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1203 "a longer sleep time in the mtx-script in the load) case.\n"
1204 "Adding a 30 second sleep and trying again ...\n"));
1208 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1211 if ((status = weof_dev(dev, 1)) < 0) {
1212 Pmsg2(0, _("Bad status from weof %d. ERR=%s\n"), status, strerror_dev(dev));
1215 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1219 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1221 "to your mtx-changer script in the load) case.\n\n"),
1224 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1227 free_pool_memory(changer);
1228 free_pool_memory(results);
1233 free_pool_memory(changer);
1234 free_pool_memory(results);
1235 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1239 static void autochangercmd()
1246 * This test assumes that the append test has been done,
1247 * then it tests the fsf function.
1249 static int fsf_test()
1251 bool set_off = false;
1253 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1254 "This test is essential to Bacula.\n\n"
1255 "I'm going to write five files then test forward spacing\n\n"));
1259 weofcmd(); /* end file 0 */
1262 weofcmd(); /* end file 1 */
1266 weofcmd(); /* end file 2 */
1269 weofcmd(); /* end file 3 */
1271 weofcmd(); /* end file 4 */
1272 if (dev_cap(dev, CAP_TWOEOF)) {
1278 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1280 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1283 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1284 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1286 if (dev->file != 1) {
1290 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1292 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1295 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1296 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1298 if (dev->file != 3) {
1303 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1305 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1308 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1309 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1311 if (dev->file != 4) {
1315 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1316 " Fast Forward Space File = no\n\n"
1317 "to your Device resource for this drive.\n"));
1321 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1323 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1325 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1326 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1327 if (dev->file != 5) {
1330 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1334 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1335 if (dev_cap(dev, CAP_FASTFSF)) {
1336 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1337 "I am turning it off then retrying the test.\n"));
1338 dev->capabilities &= ~CAP_FASTFSF;
1342 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1343 "Some systems, e.g. OpenBSD, require you to set\n"
1344 " Use MTIOCGET= no\n"
1345 "in your device resource. Use with caution.\n"));
1354 * This is a general test of Bacula's functions
1355 * needed to read and write the tape.
1357 static void testcmd()
1361 if (!write_read_test()) {
1364 if (!position_test()) {
1368 stat = append_test();
1369 if (stat == 1) { /* OK get out */
1372 if (stat == -1) { /* first test failed */
1373 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1374 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1375 "Setting \"Hardware End of Medium = no\n"
1376 " and \"Fast Forward Space File = no\n"
1377 "and retrying append test.\n\n"));
1378 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1379 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1380 stat = append_test();
1382 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1383 " Hardware End of Medium = No\n\n"
1384 " Fast Forward Space File = No\n"
1385 "to your Device resource in the Storage conf file.\n"));
1389 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1392 /* Wrong count after append */
1394 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1395 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1396 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1397 stat = append_test();
1399 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1400 " Hardware End of Medium = No\n"
1401 " Fast Forward Space File = No\n"
1402 " BSF at EOM = yes\n\n"
1403 "to your Device resource in the Storage conf file.\n"));
1410 Pmsg0(-1, _("\nAppend test failed.\n\n"
1411 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1412 "Unable to correct the problem. You MUST fix this\n"
1413 "problem before Bacula can use your tape drive correctly\n"
1414 "\nPerhaps running Bacula in fixed block mode will work.\n"
1415 "Do so by setting:\n\n"
1416 "Minimum Block Size = nnn\n"
1417 "Maximum Block Size = nnn\n\n"
1418 "in your Storage daemon's Device definition.\n"
1419 "nnn must match your tape driver's block size, which\n"
1420 "can be determined by reading your tape manufacturers\n"
1421 "information, and the information on your kernel dirver.\n"
1422 "Fixed block sizes, however, are not normally an ideal solution.\n"
1424 "Some systems, e.g. OpenBSD, require you to set\n"
1425 " Use MTIOCGET= no\n"
1426 "in your device resource. Use with caution.\n"));
1431 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1432 "Please double check it ...\n"
1433 "=== Sample correct output ===\n"
1434 "1 block of 64448 bytes in file 1\n"
1435 "End of File mark.\n"
1436 "2 blocks of 64448 bytes in file 2\n"
1437 "End of File mark.\n"
1438 "3 blocks of 64448 bytes in file 3\n"
1439 "End of File mark.\n"
1440 "1 block of 64448 bytes in file 4\n"
1441 "End of File mark.\n"
1442 "Total files=4, blocks=7, bytes = 451,136\n"
1443 "=== End sample correct output ===\n\n"
1444 "If the above scan output is not identical to the\n"
1445 "sample output, you MUST correct the problem\n"
1446 "or Bacula will not be able to write multiple Jobs to \n"
1450 re_read_block_test();
1453 fsf_test(); /* do fast forward space file test */
1455 autochanger_test(); /* do autochanger test */
1459 /* Forward space a file */
1460 static void fsfcmd()
1464 num = atoi(argk[1]);
1469 if (!dev->fsf(num)) {
1470 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), strerror_dev(dev));
1474 Pmsg0(0, _("Forward spaced 1 file.\n"));
1477 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1481 /* Forward space a record */
1482 static void fsrcmd()
1486 num = atoi(argk[1]);
1491 if (!dev->fsr(num)) {
1492 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1496 Pmsg0(0, _("Forward spaced 1 record.\n"));
1499 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1505 * Write a Bacula block to the tape
1509 DEV_BLOCK *block = dcr->block;
1510 DEV_RECORD *rec = dcr->rec;
1513 sm_check(__FILE__, __LINE__, false);
1516 dump_block(block, "test");
1519 i = block->buf_len - 100;
1521 rec->data = check_pool_memory_size(rec->data, i);
1522 memset(rec->data, i & 0xFF, i);
1524 sm_check(__FILE__, __LINE__, false);
1525 if (!write_record_to_block(block, rec)) {
1526 Pmsg0(0, _("Error writing record to block.\n"));
1529 if (!write_block_to_dev(dcr)) {
1530 Pmsg0(0, _("Error writing block to device.\n"));
1533 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1535 Pmsg0(0, _("Wrote block to device.\n"));
1538 sm_check(__FILE__, __LINE__, false);
1539 sm_check(__FILE__, __LINE__, false);
1543 * Read a record from the tape
1550 if (!get_cmd(_("Enter length to read: "))) {
1554 if (len < 0 || len > 1000000) {
1555 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1558 buf = (char *)malloc(len);
1559 stat = read(dev->fd, buf, len);
1560 if (stat > 0 && stat <= len) {
1564 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1565 len, stat, be.strerror());
1571 * Scan tape by reading block by block. Report what is
1572 * on the tape. Note, this command does raw reads, and as such
1573 * will not work with fixed block size devices.
1575 static void scancmd()
1578 int blocks, tot_blocks, tot_files;
1584 blocks = block_size = tot_blocks = 0;
1586 if (dev->state & ST_EOT) {
1587 Pmsg0(0, _("End of tape\n"));
1590 update_pos_dev(dev);
1591 tot_files = dev->file;
1592 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1594 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1596 clrerror_dev(dev, -1);
1597 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1598 dev->dev_name, be.strerror());
1599 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, strerror_dev(dev));
1602 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1605 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1610 Dmsg1(200, "read status = %d\n", stat);
1612 if (stat != block_size) {
1613 update_pos_dev(dev);
1616 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1619 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1625 if (stat == 0) { /* EOF */
1626 update_pos_dev(dev);
1627 printf(_("End of File mark.\n"));
1628 /* Two reads of zero means end of tape */
1629 if (dev->state & ST_EOF)
1630 dev->state |= ST_EOT;
1632 dev->state |= ST_EOF;
1635 if (dev->state & ST_EOT) {
1636 printf(_("End of tape\n"));
1639 } else { /* Got data */
1640 dev->state &= ~ST_EOF;
1646 update_pos_dev(dev);
1647 tot_files = dev->file - tot_files;
1648 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1649 edit_uint64_with_commas(bytes, ec1));
1654 * Scan tape by reading Bacula block by block. Report what is
1655 * on the tape. This function reads Bacula blocks, so if your
1656 * Device resource is correctly defined, it should work with
1657 * either variable or fixed block sizes.
1659 static void scan_blocks()
1661 int blocks, tot_blocks, tot_files;
1662 uint32_t block_size;
1664 DEV_BLOCK *block = dcr->block;
1667 blocks = block_size = tot_blocks = 0;
1671 update_pos_dev(dev);
1672 tot_files = dev->file;
1674 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1675 Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
1676 if (dev->state & ST_EOT) {
1679 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1682 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1688 if (dev->state & ST_EOF) {
1691 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1694 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1698 printf(_("End of File mark.\n"));
1701 if (dev->state & ST_SHORT) {
1704 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1707 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1711 printf(_("Short block read.\n"));
1714 printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1717 if (block->block_len != block_size) {
1720 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1723 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1727 block_size = block->block_len;
1731 bytes += block->block_len;
1732 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1733 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1734 block->VolSessionId, block->VolSessionTime);
1736 DEV_RECORD *rec = new_record();
1737 read_record_from_block(block, rec);
1738 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1739 block->BlockNumber, dev->block_num, block->block_len,
1740 FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1741 stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
1744 } else if (verbose > 1) {
1745 dump_block(block, "");
1750 tot_files = dev->file - tot_files;
1751 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1752 edit_uint64_with_commas(bytes, ec1));
1756 static void statcmd()
1758 int debug = debug_level;
1760 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), strerror_dev(dev));
1762 dump_volume_label(dev);
1764 debug_level = debug;
1769 * First we label the tape, then we fill
1770 * it with data get a new tape and write a few blocks.
1772 static void fillcmd()
1775 DEV_BLOCK *block = dcr->block;
1779 uint32_t min_block_size;
1789 "This command simulates Bacula writing to a tape.\n"
1790 "It requires either one or two blank tapes, which it\n"
1791 "will label and write.\n\n"
1792 "If you have an autochanger configured, it will use\n"
1793 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1794 "be prompted to insert the tapes when necessary.\n\n"
1795 "It will print a status approximately\n"
1796 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1797 "selected the simple test option, after writing the first tape\n"
1798 "it will rewind it and re-read the last block written.\n\n"
1799 "If you have selected the multiple tape test, when the first tape\n"
1800 "fills, it will ask for a second, and after writing a few more \n"
1801 "blocks, it will stop. Then it will begin re-reading the\n"
1803 "This may take a long time -- hours! ...\n\n"));
1805 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1806 "or the complete multiple tape (m) test: (s/m) "));
1807 if (cmd[0] == 's') {
1808 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1810 } else if (cmd[0] == 'm') {
1811 Pmsg0(-1, _("Multiple tape test selected.\n"));
1814 Pmsg0(000, _("Command aborted.\n"));
1818 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1819 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1821 /* Use fixed block size to simplify read back */
1822 min_block_size = dev->min_block_size;
1823 dev->min_block_size = dev->max_block_size;
1824 set_volume_name("TestVolume1", 1);
1826 if (!dev->rewind()) {
1827 Pmsg0(000, _("Rewind failed.\n"));
1830 Pmsg0(000, _("Write EOF failed.\n"));
1833 dev->set_append(); /* force volume to be relabeled */
1836 * Acquire output device for writing. Note, after acquiring a
1837 * device, we MUST release it, which is done at the end of this
1840 Dmsg0(100, "just before acquire_device\n");
1841 if (!acquire_device_for_append(dcr)) {
1842 set_jcr_job_status(jcr, JS_ErrorTerminated);
1845 block = jcr->dcr->block;
1847 Dmsg0(100, "Just after acquire_device_for_append\n");
1849 * Write Begin Session Record
1851 if (!write_session_label(dcr, SOS_LABEL)) {
1852 set_jcr_job_status(jcr, JS_ErrorTerminated);
1853 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1857 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1859 memset(&rec, 0, sizeof(rec));
1860 rec.data = get_memory(100000); /* max record size */
1862 #define REC_SIZE 32768
1863 rec.data_len = REC_SIZE;
1866 * Put some random data in the record
1868 fd = open("/dev/urandom", O_RDONLY);
1870 read(fd, rec.data, rec.data_len);
1873 uint32_t *p = (uint32_t *)rec.data;
1874 srandom(time(NULL));
1875 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1881 * Generate data as if from File daemon, write to device
1883 jcr->dcr->VolFirstIndex = 0;
1884 time(&jcr->run_time); /* start counting time for rates */
1886 Pmsg0(-1, _("Begin writing Bacula records to tape ...\n"));
1888 Pmsg0(-1, _("Begin writing Bacula records to first tape ...\n"));
1890 for (file_index = 0; ok && !job_canceled(jcr); ) {
1891 rec.VolSessionId = jcr->VolSessionId;
1892 rec.VolSessionTime = jcr->VolSessionTime;
1893 rec.FileIndex = ++file_index;
1894 rec.Stream = STREAM_FILE_DATA;
1896 /* Mix up the data just a bit */
1897 uint32_t *lp = (uint32_t *)rec.data;
1899 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1903 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1904 rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1907 while (!write_record_to_block(block, &rec)) {
1909 * When we get here we have just filled a block
1911 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1914 /* Write block to tape */
1915 if (!flush_block(block, 1)) {
1919 /* Every 5000 blocks (approx 322MB) report where we are.
1921 if ((block->BlockNumber % 5000) == 0) {
1923 now -= jcr->run_time;
1925 now = 1; /* prevent divide error */
1927 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1928 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1929 block->BlockNumber, dev->block_num,
1930 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1932 /* Every 15000 blocks (approx 1GB) write an EOF.
1934 if ((block->BlockNumber % 15000) == 0) {
1935 Pmsg0(-1, _("Flush block, write EOF\n"));
1936 flush_block(block, 0);
1940 /* Get out after writing 10 blocks to the second tape */
1941 if (++BlockNumber > 10 && stop != 0) { /* get out */
1946 Pmsg0(000, _("Not OK\n"));
1949 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1950 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1951 FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1952 stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1954 /* Get out after writing 10 blocks to the second tape */
1955 if (BlockNumber > 10 && stop != 0) { /* get out */
1956 Pmsg0(-1, "Done writing ...\n");
1961 Dmsg0(100, "Write_end_session_label()\n");
1962 /* Create Job status for end of session label */
1963 if (!job_canceled(jcr) && ok) {
1964 set_jcr_job_status(jcr, JS_Terminated);
1966 set_jcr_job_status(jcr, JS_ErrorTerminated);
1968 if (!write_session_label(dcr, EOS_LABEL)) {
1969 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1972 /* Write out final block of this session */
1973 if (!write_block_to_device(dcr)) {
1974 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1977 Pmsg0(-1, _("Wrote End of Session label.\n"));
1979 /* Save last block info for second tape */
1980 last_block_num2 = last_block_num;
1981 last_file2 = last_file;
1983 free_block(last_block2);
1985 last_block2 = dup_block(last_block);
1988 sprintf(buf, "%s/btape.state", working_directory);
1989 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1991 write(fd, &btape_state_level, sizeof(btape_state_level));
1992 write(fd, &simple, sizeof(simple));
1993 write(fd, &last_block_num1, sizeof(last_block_num1));
1994 write(fd, &last_block_num2, sizeof(last_block_num2));
1995 write(fd, &last_file1, sizeof(last_file1));
1996 write(fd, &last_file2, sizeof(last_file2));
1997 write(fd, last_block1->buf, last_block1->buf_len);
1998 write(fd, last_block2->buf, last_block2->buf_len);
1999 write(fd, first_block->buf, first_block->buf_len);
2001 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2002 last_block_num1, last_block_num2);
2005 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2010 Pmsg2(-1, _("\n\nDone filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2011 jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2014 Pmsg2(-1, _("\n\nDone filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2015 jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2018 jcr->dcr->block = block;
2021 dev->min_block_size = min_block_size;
2022 free_memory(rec.data);
2026 * Read two tapes written by the "fill" command and ensure
2027 * that the data is valid. If stop==1 we simulate full read back
2028 * of two tapes. If stop==-1 we simply read the last block and
2029 * verify that it is correct.
2031 static void unfillcmd()
2035 last_block1 = new_block(dev);
2036 last_block2 = new_block(dev);
2037 first_block = new_block(dev);
2038 sprintf(buf, "%s/btape.state", working_directory);
2039 fd = open(buf, O_RDONLY);
2041 uint32_t state_level;
2042 read(fd, &state_level, sizeof(btape_state_level));
2043 read(fd, &simple, sizeof(simple));
2044 read(fd, &last_block_num1, sizeof(last_block_num1));
2045 read(fd, &last_block_num2, sizeof(last_block_num2));
2046 read(fd, &last_file1, sizeof(last_file1));
2047 read(fd, &last_file2, sizeof(last_file2));
2048 read(fd, last_block1->buf, last_block1->buf_len);
2049 read(fd, last_block2->buf, last_block2->buf_len);
2050 read(fd, first_block->buf, first_block->buf_len);
2052 if (state_level != btape_state_level) {
2053 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2054 "the fill command.\n"));
2059 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2060 "You must redo the fill command.\n"), buf, be.strerror());
2067 static void do_unfill()
2069 DEV_BLOCK *block = dcr->block;
2076 Dmsg0(20, "Enter do_unfill\n");
2077 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2078 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2082 time(&jcr->run_time); /* start counting time for rates */
2086 free_block(last_block);
2088 last_block_num = last_block_num1;
2089 last_file = last_file1;
2090 last_block = last_block1;
2093 /* Multiple Volume tape */
2094 /* Close device so user can use autochanger if desired */
2095 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2098 autochanger = autoload_device(dcr, 1, NULL);
2100 force_close_device(dev);
2101 get_cmd(_("Mount first tape. Press enter when ready: "));
2103 free_restore_volume_list(jcr);
2104 jcr->dcr = new_dcr(jcr, dev);
2105 set_volume_name("TestVolume1", 1);
2107 create_restore_volume_list(jcr);
2109 dev->state &= ~(ST_READ|ST_APPEND);
2110 dev->num_writers = 0;
2111 if (!acquire_device_for_read(dcr)) {
2112 Pmsg1(-1, "%s", dev->errmsg);
2117 * We now have the first tape mounted.
2118 * Note, re-reading last block may have caused us to
2119 * loose track of where we are (block number unknown).
2121 if (!rewind_dev(dev)) { /* get to a known place on tape */
2124 /* Read the first 10000 records */
2125 Pmsg0(-1, _("Reading the first 10000 records.\n"));
2127 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2128 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2129 last_file, last_block_num);
2130 if (!reposition_dev(dev, last_file, last_block_num)) {
2131 Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2134 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2135 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2136 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2139 if (compare_blocks(last_block, block)) {
2141 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2143 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2150 /* restore info for last block on second Volume */
2151 last_block_num = last_block_num2;
2152 last_file = last_file2;
2153 last_block = last_block2;
2155 /* Multiple Volume tape */
2156 /* Close device so user can use autochanger if desired */
2157 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2161 free_restore_volume_list(jcr);
2162 set_volume_name("TestVolume2", 2);
2164 create_restore_volume_list(jcr);
2165 autochanger = autoload_device(dcr, 1, NULL);
2167 force_close_device(dev);
2168 get_cmd(_("Mount second tape. Press enter when ready: "));
2172 if (!acquire_device_for_read(dcr)) {
2173 Pmsg1(-1, "%s", dev->errmsg);
2177 /* Space to "first" block which is last block not written
2178 * on the previous tape.
2180 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2181 if (!reposition_dev(dev, 0, 1)) {
2182 Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2185 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2186 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2187 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2190 if (compare_blocks(first_block, block)) {
2191 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2194 /* Now find and compare the last block */
2195 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2196 last_file, last_block_num);
2197 if (!reposition_dev(dev, last_file, last_block_num)) {
2198 Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2201 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2202 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2203 Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2206 if (compare_blocks(last_block, block)) {
2207 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2211 free_block(last_block1);
2212 free_block(last_block2);
2213 free_block(first_block);
2216 /* Read 10000 records then stop */
2217 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2219 DEVICE *dev = dcr->dev;
2220 if (dev->file != 0) {
2221 Pmsg3(-1, _("ERROR! device at %d:%d count=%d\n"), dev->file, dev->block_num,
2226 if (quickie_count == 10000) {
2227 Pmsg2(-1, _("1000 records read now at %d:%d\n"), dev->file, dev->block_num);
2229 return quickie_count < 10000;
2232 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2235 uint32_t CheckSum, block_len;
2238 p = last_block->buf;
2240 unser_begin(q, BLKHDR2_LENGTH);
2241 unser_uint32(CheckSum);
2242 unser_uint32(block_len);
2243 while (q < (block->buf+block_len)) {
2250 dump_block(last_block, _("Last block written"));
2252 dump_block(block, _("Block read back"));
2253 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2254 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2255 "that was read back differ. The test FAILED !!!!\n"
2256 "This must be corrected before you use Bacula\n"
2257 "to write multi-tape Volumes.!!!!\n"));
2261 dump_block(last_block, _("Last block written"));
2262 dump_block(block, _("Block read back"));
2272 * Write current block to tape regardless of whether or
2273 * not it is full. If the tape fills, attempt to
2274 * acquire another tape.
2276 static int flush_block(DEV_BLOCK *block, int dump)
2280 uint32_t this_file, this_block_num;
2284 this_block = new_block(dev);
2287 last_block = new_block(dev);
2290 this_file = dev->file;
2291 this_block_num = dev->block_num;
2292 if (!write_block_to_dev(dcr)) {
2293 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2294 last_file, last_block_num, this_block_num);
2297 * This is 1st tape, so save first tape info separate
2298 * from second tape info
2300 last_block_num1 = last_block_num;
2301 last_file1 = last_file;
2302 last_block1 = dup_block(last_block);
2303 last_block2 = dup_block(last_block);
2304 first_block = dup_block(block); /* first block second tape */
2307 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2308 (unsigned)file_index, block->BlockNumber, block->block_len);
2309 dump_block(last_block, _("Last block written"));
2311 dump_block(block, _("Block not written"));
2314 eot_block = block->BlockNumber;
2315 eot_block_len = block->block_len;
2316 eot_FileIndex = file_index;
2320 now -= jcr->run_time;
2322 now = 1; /* don't divide by zero */
2324 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2325 vol_size = dev->VolCatInfo.VolCatBytes;
2326 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2327 dev->file, dev->block_num,
2328 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2331 stop = -1; /* stop, but do simplified test */
2333 /* Full test in progress */
2334 if (!fixup_device_block_write_error(jcr->dcr)) {
2335 Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2340 BlockNumber = 0; /* start counting for second tape */
2343 return 1; /* end of tape reached */
2346 /* Save contents after write so that the header is serialized */
2347 memcpy(this_block->buf, block->buf, this_block->buf_len);
2350 * Note, we always read/write to block, but we toggle
2351 * copying it to one or another of two allocated blocks.
2352 * Switch blocks so that the block just successfully written is
2353 * always in last_block.
2355 tblock = last_block;
2356 last_block = this_block;
2357 this_block = tblock;
2358 last_file = this_file;
2359 last_block_num = this_block_num;
2367 * First we label the tape, then we fill
2368 * it with data get a new tape and write a few blocks.
2370 static void qfillcmd()
2372 DEV_BLOCK *block = dcr->block;
2373 DEV_RECORD *rec = dcr->rec;
2376 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2378 get_cmd(_("How many blocks do you want to write? (1000): "));
2385 sm_check(__FILE__, __LINE__, false);
2387 i = block->buf_len - 100;
2389 rec->data = check_pool_memory_size(rec->data, i);
2390 memset(rec->data, i & 0xFF, i);
2393 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2394 for (i=0; i < count; i++) {
2399 if (!write_record_to_block(block, rec)) {
2400 Pmsg0(0, _("Error writing record to block.\n"));
2403 if (!write_block_to_dev(dcr)) {
2404 Pmsg0(0, _("Error writing block to device.\n"));
2410 if (dev_cap(dev, CAP_TWOEOF)) {
2417 sm_check(__FILE__, __LINE__, false);
2421 * Fill a tape using raw write() command
2423 static void rawfill_cmd()
2425 DEV_BLOCK *block = dcr->block;
2428 uint32_t block_num = 0;
2433 fd = open("/dev/urandom", O_RDONLY);
2435 read(fd, block->buf, block->buf_len);
2438 uint32_t *p = (uint32_t *)block->buf;
2439 srandom(time(NULL));
2440 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2444 p = (uint32_t *)block->buf;
2445 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2448 stat = write(dev->fd, block->buf, block->buf_len);
2449 if (stat == (int)block->buf_len) {
2450 if ((block_num++ % 100) == 0) {
2455 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2465 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2466 be.strerror(my_errno));
2472 * Fill a tape using Bacula block writes
2474 static void bfill_cmd()
2476 DEV_BLOCK *block = dcr->block;
2477 uint32_t block_num = 0;
2483 fd = open("/dev/urandom", O_RDONLY);
2485 read(fd, block->buf, block->buf_len);
2488 uint32_t *p = (uint32_t *)block->buf;
2489 srandom(time(NULL));
2490 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2494 p = (uint32_t *)block->buf;
2495 Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2498 block->binbuf = block->buf_len;
2499 block->bufp = block->buf + block->binbuf;
2500 if (!write_block_to_dev(dcr)) {
2503 if ((block_num++ % 100) == 0) {
2508 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2514 printf(_("Write failed at block %u.\n"), block_num);
2519 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2520 static struct cmdstruct commands[] = {
2521 {N_("autochanger"),autochangercmd, _("test autochanger")},
2522 {N_("bsf"), bsfcmd, _("backspace file")},
2523 {N_("bsr"), bsrcmd, _("backspace record")},
2524 {N_("bfill"), bfill_cmd, _("fill tape using Bacula writes")},
2525 {N_("cap"), capcmd, _("list device capabilities")},
2526 {N_("clear"), clearcmd, _("clear tape errors")},
2527 {N_("eod"), eodcmd, _("go to end of Bacula data for append")},
2528 {N_("eom"), eomcmd, _("go to the physical end of medium")},
2529 {N_("fill"), fillcmd, _("fill tape, write onto second volume")},
2530 {N_("unfill"), unfillcmd, _("read filled tape")},
2531 {N_("fsf"), fsfcmd, _("forward space a file")},
2532 {N_("fsr"), fsrcmd, _("forward space a record")},
2533 {N_("help"), helpcmd, _("print this command")},
2534 {N_("label"), labelcmd, _("write a Bacula label to the tape")},
2535 {N_("load"), loadcmd, _("load a tape")},
2536 {N_("quit"), quitcmd, _("quit btape")},
2537 {N_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2538 {N_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2539 {N_("rectest"), rectestcmd, _("test record handling functions")},
2540 {N_("rewind"), rewindcmd, _("rewind the tape")},
2541 {N_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2542 {N_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2543 {N_("status"), statcmd, _("print tape status")},
2544 {N_("test"), testcmd, _("General test Bacula tape functions")},
2545 {N_("weof"), weofcmd, _("write an EOF on the tape")},
2546 {N_("wr"), wrcmd, _("write a single Bacula block")},
2547 {N_("rr"), rrcmd, _("read a single record")},
2548 {N_("qfill"), qfillcmd, _("quick fill command")}
2550 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2558 while (get_cmd("*")) {
2559 sm_check(__FILE__, __LINE__, false);
2561 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2562 for (i=0; i<comsize; i++) /* search for command */
2563 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2564 (*commands[i].func)(); /* go execute command */
2569 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2575 static void helpcmd()
2579 printf(_("Interactive commands:\n"));
2580 printf(_(" Command Description\n ======= ===========\n"));
2581 for (i=0; i<comsize; i++)
2582 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2589 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2590 "\nVersion: %s (%s)\n\n"
2591 "Usage: btape <options> <device_name>\n"
2592 " -b <file> specify bootstrap file\n"
2593 " -c <file> set configuration file to file\n"
2594 " -d <nn> set debug level to nn\n"
2595 " -p proceed inspite of I/O errors\n"
2596 " -s turn off signals\n"
2598 " -? print this message.\n"
2599 "\n"), VERSION, BDATE);
2604 * Get next input command from terminal. This
2605 * routine is REALLY primitive, and should be enhanced
2606 * to have correct backspacing, etc.
2609 get_cmd(const char *prompt)
2613 fprintf(stdout, prompt);
2615 /* We really should turn off echoing and pretty this
2619 while ((ch = fgetc(stdin)) != EOF) {
2621 strip_trailing_junk(cmd);
2623 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2636 /* Dummies to replace askdir.c */
2637 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2638 bool dir_send_job_status(JCR *jcr) {return 1;}
2640 bool dir_update_volume_info(DCR *dcr, bool relabel)
2646 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2648 Dmsg0(20, "Enter dir_get_volume_info\n");
2649 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2653 bool dir_create_jobmedia_record(DCR *dcr)
2655 dcr->WroteVol = false;
2660 bool dir_find_next_appendable_volume(DCR *dcr)
2662 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2663 return dcr->VolumeName[0] != 0;
2666 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2668 DEVICE *dev = dcr->dev;
2669 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2670 if (dcr->VolumeName[0] == 0) {
2671 return dir_ask_sysop_to_create_appendable_volume(dcr);
2673 /* Close device so user can use autochanger if desired */
2674 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2677 force_close_device(dev);
2678 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2679 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2680 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2683 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2684 dcr->VolumeName, dev->print_name());
2690 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2693 DEVICE *dev = dcr->dev;
2694 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2696 set_volume_name("TestVolume1", 1);
2698 set_volume_name("TestVolume2", 2);
2700 /* Close device so user can use autochanger if desired */
2701 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2704 autochanger = autoload_device(dcr, 1, NULL);
2706 force_close_device(dev);
2707 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2718 static bool my_mount_next_read_volume(DCR *dcr)
2721 JCR *jcr = dcr->jcr;
2722 DEV_BLOCK *block = dcr->block;
2724 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2725 Pmsg1(000, _("End of Volume \"%s\"\n"), dcr->VolumeName);
2727 if (LastBlock != block->BlockNumber) {
2728 VolBytes += block->block_len;
2730 LastBlock = block->BlockNumber;
2732 now -= jcr->run_time;
2736 kbs = (double)VolBytes / (1000.0 * (double)now);
2737 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2738 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2740 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2745 free_restore_volume_list(jcr);
2746 set_volume_name("TestVolume2", 2);
2748 create_restore_volume_list(jcr);
2751 if (!acquire_device_for_read(dcr)) {
2752 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2755 return true; /* next volume mounted */
2758 static void set_volume_name(const char *VolName, int volnum)
2760 DCR *dcr = jcr->dcr;
2761 VolumeName = VolName;
2763 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2764 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2765 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2766 dcr->VolCatInfo.Slot = volnum;
2769 VOLRES *new_volume(DCR *dcr, const char *VolumeName) { return NULL; }
2770 bool free_volume(DEVICE *dev) { return true; }
2771 void free_unused_volume(DCR *dcr) { }