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-2006 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 uint64_t write_count = 0;
100 static BSR *bsr = NULL;
101 static int signals = TRUE;
104 static uint64_t vol_size;
105 static uint64_t VolBytes;
108 static int32_t file_index;
109 static int end_of_tape = 0;
110 static uint32_t LastBlock = 0;
111 static uint32_t eot_block;
112 static uint32_t eot_block_len;
113 static uint32_t eot_FileIndex;
114 static int dumped = 0;
115 static DEV_BLOCK *last_block1 = NULL;
116 static DEV_BLOCK *last_block2 = NULL;
117 static DEV_BLOCK *last_block = NULL;
118 static DEV_BLOCK *this_block = NULL;
119 static DEV_BLOCK *first_block = NULL;
120 static uint32_t last_file1 = 0;
121 static uint32_t last_file2 = 0;
122 static uint32_t last_file = 0;
123 static uint32_t last_block_num1 = 0;
124 static uint32_t last_block_num2 = 0;
125 static uint32_t last_block_num = 0;
126 static uint32_t BlockNumber = 0;
127 static bool simple = true;
129 static const char *VolumeName = NULL;
130 static int vol_num = 0;
132 static JCR *jcr = NULL;
136 static void terminate_btape(int sig);
137 int get_cmd(const char *prompt);
140 /*********************************************************************
142 * Bacula tape testing program
145 int main(int margc, char *margv[])
152 setlocale(LC_ALL, "");
153 bindtextdomain("bacula", LOCALEDIR);
154 textdomain("bacula");
157 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
158 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
159 TAPE_BSIZE, B_DEV_BSIZE);
161 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
162 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
164 if (sizeof(off_t) < 8) {
165 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n"),
169 bsnprintf(buf, sizeof(buf), "%u", x32);
170 i = bsscanf(buf, "%u", &y32);
171 if (i != 1 || x32 != y32) {
172 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
178 bsnprintf(buf, sizeof(buf), "%" llu, x64);
179 i = bsscanf(buf, "%llu", &y64);
180 if (i != 1 || x64 != y64) {
181 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"), i, x64, y64);
185 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
187 working_directory = "/tmp";
188 my_name_is(margc, margv, "btape");
189 init_msg(NULL, NULL);
193 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
195 case 'b': /* bootstrap file */
196 bsr = parse_bsr(NULL, optarg);
197 // dump_bsr(bsr, true);
200 case 'c': /* specify config file */
201 if (configfile != NULL) {
204 configfile = bstrdup(optarg);
207 case 'd': /* set debug level */
208 debug_level = atoi(optarg);
209 if (debug_level <= 0) {
236 cmd = get_pool_memory(PM_FNAME);
237 args = get_pool_memory(PM_FNAME);
240 init_signals(terminate_btape);
243 if (configfile == NULL) {
244 configfile = bstrdup(CONFIG_FILE);
247 daemon_start_time = time(NULL);
249 parse_config(configfile);
252 /* See if we can open a device */
254 Pmsg0(000, _("No archive name specified.\n"));
257 } else if (margc != 1) {
258 Pmsg0(000, _("Improper number of arguments specified.\n"));
263 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
272 if (!open_the_device()) {
276 Dmsg0(200, "Do tape commands\n");
284 static void terminate_btape(int stat)
287 sm_check(__FILE__, __LINE__, false);
291 free_config_resources();
293 free_pool_memory(args);
297 free_pool_memory(cmd);
312 if (debug_level > 10)
313 print_memory_pool_stats();
316 free_block(this_block);
321 close_memory_pool(); /* free memory in pool */
322 term_last_jobs_list();
328 static bool open_the_device()
332 block = new_block(dev);
334 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
335 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
336 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
341 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
342 dev->set_append(); /* put volume in append mode */
355 * Write a label to the tape
357 static void labelcmd()
360 pm_strcpy(cmd, VolumeName);
362 if (!get_cmd(_("Enter Volume Name: "))) {
367 if (!dev->is_open()) {
368 if (!first_open_device(dcr)) {
369 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
373 write_new_volume_label_to_dev(dcr, cmd, "Default");
374 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
378 * Read the tape label
380 static void readlabelcmd()
382 int save_debug_level = debug_level;
385 stat = read_dev_volume_label(dcr);
388 Pmsg0(0, _("Volume has no label.\n"));
391 Pmsg0(0, _("Volume label read correctly.\n"));
394 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
397 Pmsg0(0, _("Volume name error\n"));
399 case VOL_CREATE_ERROR:
400 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
402 case VOL_VERSION_ERROR:
403 Pmsg0(0, _("Volume version error.\n"));
405 case VOL_LABEL_ERROR:
406 Pmsg0(0, _("Bad Volume label type.\n"));
409 Pmsg0(0, _("Unknown error.\n"));
414 dump_volume_label(dev);
415 debug_level = save_debug_level;
420 * Load the tape should have prevously been taken
421 * off line, otherwise this command is not necessary.
423 static void loadcmd()
426 if (!load_dev(dev)) {
427 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
429 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
435 static void rewindcmd()
437 if (!dev->rewind(dcr)) {
438 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
441 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
446 * Clear any tape error
448 static void clearcmd()
454 * Write and end of file on the tape
456 static void weofcmd()
466 if (!dev->weof(num)) {
467 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
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", dev->bstrerror());
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 (!dev->bsf(num)) {
519 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
521 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
537 if (!dev->bsr(num)) {
538 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
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)) {
705 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
708 if (dev_cap(dev, CAP_TWOEOF)) {
710 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
714 Pmsg0(0, _("Backspaced over EOF OK.\n"));
716 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
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 (!dev->rewind(dcr)) {
777 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
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 (!dev->rewind(dcr)) {
819 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
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 (!dev->rewind(dcr)) {
889 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
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 (!dev->rewind(dcr)) {
931 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
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 (!dev->reposition(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 dev->close(); /* 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 /* We are going to load a new tape, so close the device */
1154 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1155 loaded, dev->drive_index);
1156 changer = edit_device_codes(dcr, changer,
1157 dcr->device->changer_command, "unload");
1158 status = run_program(changer, timeout, results);
1159 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1162 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1163 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1172 dcr->VolCatInfo.Slot = slot;
1173 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1174 slot, dev->drive_index);
1175 changer = edit_device_codes(dcr, changer,
1176 dcr->device->changer_command, "load");
1177 Dmsg1(100, "Changer=%s\n", changer);
1179 status = run_program(changer, timeout, results);
1181 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1182 slot, dev->drive_index);
1185 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1186 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1190 if (!open_the_device()) {
1194 * Start with sleep_time 0 then increment by 30 seconds if we get
1197 bmicrosleep(sleep_time, 0);
1198 if (!dev->rewind(dcr) || !dev->weof(1)) {
1199 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1201 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1202 "a longer sleep time in the mtx-script in the load) case.\n"
1203 "Adding a 30 second sleep and trying again ...\n"));
1207 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1210 if (!dev->weof(1)) {
1211 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1214 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1218 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1220 "to your mtx-changer script in the load) case.\n\n"),
1223 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1226 free_pool_memory(changer);
1227 free_pool_memory(results);
1232 free_pool_memory(changer);
1233 free_pool_memory(results);
1234 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1238 static void autochangercmd()
1245 * This test assumes that the append test has been done,
1246 * then it tests the fsf function.
1248 static int fsf_test()
1250 bool set_off = false;
1252 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1253 "This test is essential to Bacula.\n\n"
1254 "I'm going to write five files then test forward spacing\n\n"));
1258 weofcmd(); /* end file 0 */
1261 weofcmd(); /* end file 1 */
1265 weofcmd(); /* end file 2 */
1268 weofcmd(); /* end file 3 */
1270 weofcmd(); /* end file 4 */
1271 if (dev_cap(dev, CAP_TWOEOF)) {
1277 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1279 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1282 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1283 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1285 if (dev->file != 1) {
1289 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1291 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1294 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1295 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1297 if (dev->file != 3) {
1302 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1304 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1307 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1308 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1310 if (dev->file != 4) {
1314 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1315 " Fast Forward Space File = no\n\n"
1316 "to your Device resource for this drive.\n"));
1320 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1322 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1324 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1325 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1326 if (dev->file != 5) {
1329 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1333 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1334 if (dev_cap(dev, CAP_FASTFSF)) {
1335 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1336 "I am turning it off then retrying the test.\n"));
1337 dev->capabilities &= ~CAP_FASTFSF;
1341 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1342 "Some systems, e.g. OpenBSD, require you to set\n"
1343 " Use MTIOCGET= no\n"
1344 "in your device resource. Use with caution.\n"));
1353 * This is a general test of Bacula's functions
1354 * needed to read and write the tape.
1356 static void testcmd()
1360 if (!write_read_test()) {
1363 if (!position_test()) {
1367 stat = append_test();
1368 if (stat == 1) { /* OK get out */
1371 if (stat == -1) { /* first test failed */
1372 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1373 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1374 "Setting \"Hardware End of Medium = no\n"
1375 " and \"Fast Forward Space File = no\n"
1376 "and retrying append test.\n\n"));
1377 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1378 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1379 stat = append_test();
1381 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1382 " Hardware End of Medium = No\n\n"
1383 " Fast Forward Space File = No\n"
1384 "to your Device resource in the Storage conf file.\n"));
1388 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1391 /* Wrong count after append */
1393 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1394 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1395 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1396 stat = append_test();
1398 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1399 " Hardware End of Medium = No\n"
1400 " Fast Forward Space File = No\n"
1401 " BSF at EOM = yes\n\n"
1402 "to your Device resource in the Storage conf file.\n"));
1409 Pmsg0(-1, _("\nAppend test failed.\n\n"
1410 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1411 "Unable to correct the problem. You MUST fix this\n"
1412 "problem before Bacula can use your tape drive correctly\n"
1413 "\nPerhaps running Bacula in fixed block mode will work.\n"
1414 "Do so by setting:\n\n"
1415 "Minimum Block Size = nnn\n"
1416 "Maximum Block Size = nnn\n\n"
1417 "in your Storage daemon's Device definition.\n"
1418 "nnn must match your tape driver's block size, which\n"
1419 "can be determined by reading your tape manufacturers\n"
1420 "information, and the information on your kernel dirver.\n"
1421 "Fixed block sizes, however, are not normally an ideal solution.\n"
1423 "Some systems, e.g. OpenBSD, require you to set\n"
1424 " Use MTIOCGET= no\n"
1425 "in your device resource. Use with caution.\n"));
1430 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1431 "Please double check it ...\n"
1432 "=== Sample correct output ===\n"
1433 "1 block of 64448 bytes in file 1\n"
1434 "End of File mark.\n"
1435 "2 blocks of 64448 bytes in file 2\n"
1436 "End of File mark.\n"
1437 "3 blocks of 64448 bytes in file 3\n"
1438 "End of File mark.\n"
1439 "1 block of 64448 bytes in file 4\n"
1440 "End of File mark.\n"
1441 "Total files=4, blocks=7, bytes = 451,136\n"
1442 "=== End sample correct output ===\n\n"
1443 "If the above scan output is not identical to the\n"
1444 "sample output, you MUST correct the problem\n"
1445 "or Bacula will not be able to write multiple Jobs to \n"
1449 re_read_block_test();
1452 fsf_test(); /* do fast forward space file test */
1454 autochanger_test(); /* do autochanger test */
1458 /* Forward space a file */
1459 static void fsfcmd()
1463 num = atoi(argk[1]);
1468 if (!dev->fsf(num)) {
1469 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1473 Pmsg0(0, _("Forward spaced 1 file.\n"));
1476 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1480 /* Forward space a record */
1481 static void fsrcmd()
1485 num = atoi(argk[1]);
1490 if (!dev->fsr(num)) {
1491 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1495 Pmsg0(0, _("Forward spaced 1 record.\n"));
1498 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1504 * Write a Bacula block to the tape
1508 DEV_BLOCK *block = dcr->block;
1509 DEV_RECORD *rec = dcr->rec;
1512 sm_check(__FILE__, __LINE__, false);
1515 dump_block(block, "test");
1518 i = block->buf_len - 100;
1520 rec->data = check_pool_memory_size(rec->data, i);
1521 memset(rec->data, i & 0xFF, i);
1523 sm_check(__FILE__, __LINE__, false);
1524 if (!write_record_to_block(block, rec)) {
1525 Pmsg0(0, _("Error writing record to block.\n"));
1528 if (!write_block_to_dev(dcr)) {
1529 Pmsg0(0, _("Error writing block to device.\n"));
1532 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1534 Pmsg0(0, _("Wrote block to device.\n"));
1537 sm_check(__FILE__, __LINE__, false);
1538 sm_check(__FILE__, __LINE__, false);
1542 * Read a record from the tape
1549 if (!get_cmd(_("Enter length to read: "))) {
1553 if (len < 0 || len > 1000000) {
1554 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1557 buf = (char *)malloc(len);
1558 stat = read(dev->fd, buf, len);
1559 if (stat > 0 && stat <= len) {
1563 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1564 len, stat, be.strerror());
1570 * Scan tape by reading block by block. Report what is
1571 * on the tape. Note, this command does raw reads, and as such
1572 * will not work with fixed block size devices.
1574 static void scancmd()
1577 int blocks, tot_blocks, tot_files;
1583 blocks = block_size = tot_blocks = 0;
1585 if (dev->state & ST_EOT) {
1586 Pmsg0(0, _("End of tape\n"));
1589 update_pos_dev(dev);
1590 tot_files = dev->file;
1591 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1593 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1596 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1597 dev->dev_name, be.strerror());
1598 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1601 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1604 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1609 Dmsg1(200, "read status = %d\n", stat);
1611 if (stat != block_size) {
1612 update_pos_dev(dev);
1615 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1618 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1624 if (stat == 0) { /* EOF */
1625 update_pos_dev(dev);
1626 printf(_("End of File mark.\n"));
1627 /* Two reads of zero means end of tape */
1628 if (dev->state & ST_EOF)
1629 dev->state |= ST_EOT;
1631 dev->state |= ST_EOF;
1634 if (dev->state & ST_EOT) {
1635 printf(_("End of tape\n"));
1638 } else { /* Got data */
1639 dev->state &= ~ST_EOF;
1645 update_pos_dev(dev);
1646 tot_files = dev->file - tot_files;
1647 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1648 edit_uint64_with_commas(bytes, ec1));
1653 * Scan tape by reading Bacula block by block. Report what is
1654 * on the tape. This function reads Bacula blocks, so if your
1655 * Device resource is correctly defined, it should work with
1656 * either variable or fixed block sizes.
1658 static void scan_blocks()
1660 int blocks, tot_blocks, tot_files;
1661 uint32_t block_size;
1663 DEV_BLOCK *block = dcr->block;
1665 char buf1[100], buf2[100];
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", dev->bstrerror());
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"), dev->bstrerror());
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(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1741 stream_to_ascii(buf2, 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), dev->bstrerror());
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;
1777 char buf1[100], buf2[100];
1780 uint32_t min_block_size;
1791 "This command simulates Bacula writing to a tape.\n"
1792 "It requires either one or two blank tapes, which it\n"
1793 "will label and write.\n\n"
1794 "If you have an autochanger configured, it will use\n"
1795 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1796 "be prompted to insert the tapes when necessary.\n\n"
1797 "It will print a status approximately\n"
1798 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1799 "selected the simple test option, after writing the first tape\n"
1800 "it will rewind it and re-read the last block written.\n\n"
1801 "If you have selected the multiple tape test, when the first tape\n"
1802 "fills, it will ask for a second, and after writing a few more \n"
1803 "blocks, it will stop. Then it will begin re-reading the\n"
1805 "This may take a long time -- hours! ...\n\n"));
1807 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1808 "or the complete multiple tape (m) test: (s/m) "));
1809 if (cmd[0] == 's') {
1810 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1812 } else if (cmd[0] == 'm') {
1813 Pmsg0(-1, _("Multiple tape test selected.\n"));
1816 Pmsg0(000, _("Command aborted.\n"));
1820 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1821 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1823 /* Use fixed block size to simplify read back */
1824 min_block_size = dev->min_block_size;
1825 dev->min_block_size = dev->max_block_size;
1826 set_volume_name("TestVolume1", 1);
1828 if (!dev->rewind(dcr)) {
1829 Pmsg0(000, _("Rewind failed.\n"));
1831 if (!dev->weof(1)) {
1832 Pmsg0(000, _("Write EOF failed.\n"));
1835 dev->set_append(); /* force volume to be relabeled */
1838 * Acquire output device for writing. Note, after acquiring a
1839 * device, we MUST release it, which is done at the end of this
1842 Dmsg0(100, "just before acquire_device\n");
1843 if (!acquire_device_for_append(dcr)) {
1844 set_jcr_job_status(jcr, JS_ErrorTerminated);
1847 block = jcr->dcr->block;
1849 Dmsg0(100, "Just after acquire_device_for_append\n");
1851 * Write Begin Session Record
1853 if (!write_session_label(dcr, SOS_LABEL)) {
1854 set_jcr_job_status(jcr, JS_ErrorTerminated);
1855 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1859 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1861 memset(&rec, 0, sizeof(rec));
1862 rec.data = get_memory(100000); /* max record size */
1864 #define REC_SIZE 32768
1865 rec.data_len = REC_SIZE;
1868 * Put some random data in the record
1870 fd = open("/dev/urandom", O_RDONLY);
1872 read(fd, rec.data, rec.data_len);
1875 uint32_t *p = (uint32_t *)rec.data;
1876 srandom(time(NULL));
1877 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1883 * Generate data as if from File daemon, write to device
1885 jcr->dcr->VolFirstIndex = 0;
1886 time(&jcr->run_time); /* start counting time for rates */
1887 (void)localtime_r(&jcr->run_time, &tm);
1888 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1890 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1892 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1894 for (file_index = 0; ok && !job_canceled(jcr); ) {
1895 rec.VolSessionId = jcr->VolSessionId;
1896 rec.VolSessionTime = jcr->VolSessionTime;
1897 rec.FileIndex = ++file_index;
1898 rec.Stream = STREAM_FILE_DATA;
1900 /* Mix up the data just a bit */
1901 uint32_t *lp = (uint32_t *)rec.data;
1903 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1907 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1908 rec.FileIndex, rec.VolSessionId,
1909 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1912 while (!write_record_to_block(block, &rec)) {
1914 * When we get here we have just filled a block
1916 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1919 /* Write block to tape */
1920 if (!flush_block(block, 1)) {
1924 /* Every 5000 blocks (approx 322MB) report where we are.
1926 if ((block->BlockNumber % 5000) == 0) {
1928 now -= jcr->run_time;
1930 now = 1; /* prevent divide error */
1932 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1933 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1934 block->BlockNumber, dev->block_num,
1935 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1937 /* Every 32000 blocks (approx 2GB) write an EOF.
1939 if ((block->BlockNumber % 32000) == 0) {
1941 (void)localtime_r(&now, &tm);
1942 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1943 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1944 flush_block(block, 0);
1948 /* Get out after writing 10 blocks to the second tape */
1949 if (++BlockNumber > 10 && stop != 0) { /* get out */
1954 Pmsg0(000, _("Not OK\n"));
1957 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1958 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1959 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1960 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1962 /* Get out after writing 10 blocks to the second tape */
1963 if (BlockNumber > 10 && stop != 0) { /* get out */
1965 Pmsg1(-1, "Done writing %s records ...\n",
1966 edit_uint64_with_commas(write_count, ed1));
1971 Dmsg0(100, "Write_end_session_label()\n");
1972 /* Create Job status for end of session label */
1973 if (!job_canceled(jcr) && ok) {
1974 set_jcr_job_status(jcr, JS_Terminated);
1976 set_jcr_job_status(jcr, JS_ErrorTerminated);
1978 if (!write_session_label(dcr, EOS_LABEL)) {
1979 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
1982 /* Write out final block of this session */
1983 if (!write_block_to_device(dcr)) {
1984 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1987 Pmsg0(-1, _("Wrote End of Session label.\n"));
1989 /* Save last block info for second tape */
1990 last_block_num2 = last_block_num;
1991 last_file2 = last_file;
1993 free_block(last_block2);
1995 last_block2 = dup_block(last_block);
1998 sprintf(buf, "%s/btape.state", working_directory);
1999 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2001 write(fd, &btape_state_level, sizeof(btape_state_level));
2002 write(fd, &simple, sizeof(simple));
2003 write(fd, &last_block_num1, sizeof(last_block_num1));
2004 write(fd, &last_block_num2, sizeof(last_block_num2));
2005 write(fd, &last_file1, sizeof(last_file1));
2006 write(fd, &last_file2, sizeof(last_file2));
2007 write(fd, last_block1->buf, last_block1->buf_len);
2008 write(fd, last_block2->buf, last_block2->buf_len);
2009 write(fd, first_block->buf, first_block->buf_len);
2011 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2012 last_block_num1, last_block_num2);
2015 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2020 (void)localtime_r(&now, &tm);
2021 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2023 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2024 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2027 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2028 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2031 jcr->dcr->block = block;
2034 dev->min_block_size = min_block_size;
2035 free_memory(rec.data);
2039 * Read two tapes written by the "fill" command and ensure
2040 * that the data is valid. If stop==1 we simulate full read back
2041 * of two tapes. If stop==-1 we simply read the last block and
2042 * verify that it is correct.
2044 static void unfillcmd()
2048 last_block1 = new_block(dev);
2049 last_block2 = new_block(dev);
2050 first_block = new_block(dev);
2051 sprintf(buf, "%s/btape.state", working_directory);
2052 fd = open(buf, O_RDONLY);
2054 uint32_t state_level;
2055 read(fd, &state_level, sizeof(btape_state_level));
2056 read(fd, &simple, sizeof(simple));
2057 read(fd, &last_block_num1, sizeof(last_block_num1));
2058 read(fd, &last_block_num2, sizeof(last_block_num2));
2059 read(fd, &last_file1, sizeof(last_file1));
2060 read(fd, &last_file2, sizeof(last_file2));
2061 read(fd, last_block1->buf, last_block1->buf_len);
2062 read(fd, last_block2->buf, last_block2->buf_len);
2063 read(fd, first_block->buf, first_block->buf_len);
2065 if (state_level != btape_state_level) {
2066 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2067 "the fill command.\n"));
2072 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2073 "You must redo the fill command.\n"), buf, be.strerror());
2080 static void do_unfill()
2082 DEV_BLOCK *block = dcr->block;
2089 Dmsg0(20, "Enter do_unfill\n");
2090 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2091 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2095 time(&jcr->run_time); /* start counting time for rates */
2099 free_block(last_block);
2101 last_block_num = last_block_num1;
2102 last_file = last_file1;
2103 last_block = last_block1;
2106 /* Multiple Volume tape */
2107 /* Close device so user can use autochanger if desired */
2108 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2111 autochanger = autoload_device(dcr, 1, NULL);
2114 get_cmd(_("Mount first tape. Press enter when ready: "));
2118 free_restore_volume_list(jcr);
2119 jcr->dcr = new_dcr(jcr, dev);
2120 set_volume_name("TestVolume1", 1);
2122 create_restore_volume_list(jcr);
2124 dev->num_writers = 0;
2125 if (!acquire_device_for_read(dcr)) {
2126 Pmsg1(-1, "%s", dev->errmsg);
2130 * We now have the first tape mounted.
2131 * Note, re-reading last block may have caused us to
2132 * loose track of where we are (block number unknown).
2134 Pmsg0(-1, _("Rewinding.\n"));
2135 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2138 /* Read the first 10000 records */
2139 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2140 dev->file, dev->block_num);
2142 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2143 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2144 last_file, last_block_num);
2145 if (!dev->reposition(last_file, last_block_num)) {
2146 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2149 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2150 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2151 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2154 if (compare_blocks(last_block, block)) {
2156 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2158 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2165 /* restore info for last block on second Volume */
2166 last_block_num = last_block_num2;
2167 last_file = last_file2;
2168 last_block = last_block2;
2170 /* Multiple Volume tape */
2171 /* Close device so user can use autochanger if desired */
2172 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2176 free_restore_volume_list(jcr);
2177 set_volume_name("TestVolume2", 2);
2179 create_restore_volume_list(jcr);
2180 autochanger = autoload_device(dcr, 1, NULL);
2183 get_cmd(_("Mount second tape. Press enter when ready: "));
2187 if (!acquire_device_for_read(dcr)) {
2188 Pmsg1(-1, "%s", dev->errmsg);
2192 /* Space to "first" block which is last block not written
2193 * on the previous tape.
2195 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2196 if (!dev->reposition(0, 1)) {
2197 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2200 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2201 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2202 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2205 if (compare_blocks(first_block, block)) {
2206 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2209 /* Now find and compare the last block */
2210 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2211 last_file, last_block_num);
2212 if (!dev->reposition(last_file, last_block_num)) {
2213 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2216 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2217 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2218 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2221 if (compare_blocks(last_block, block)) {
2222 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2226 free_block(last_block1);
2227 free_block(last_block2);
2228 free_block(first_block);
2231 /* Read 10000 records then stop */
2232 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2234 DEVICE *dev = dcr->dev;
2236 if (quickie_count == 10000) {
2237 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2239 return quickie_count < 10000;
2242 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2245 uint32_t CheckSum, block_len;
2248 p = last_block->buf;
2250 unser_begin(q, BLKHDR2_LENGTH);
2251 unser_uint32(CheckSum);
2252 unser_uint32(block_len);
2253 while (q < (block->buf+block_len)) {
2260 dump_block(last_block, _("Last block written"));
2262 dump_block(block, _("Block read back"));
2263 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2264 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2265 "that was read back differ. The test FAILED !!!!\n"
2266 "This must be corrected before you use Bacula\n"
2267 "to write multi-tape Volumes.!!!!\n"));
2271 dump_block(last_block, _("Last block written"));
2272 dump_block(block, _("Block read back"));
2282 * Write current block to tape regardless of whether or
2283 * not it is full. If the tape fills, attempt to
2284 * acquire another tape.
2286 static int flush_block(DEV_BLOCK *block, int dump)
2290 uint32_t this_file, this_block_num;
2294 this_block = new_block(dev);
2297 last_block = new_block(dev);
2300 this_file = dev->file;
2301 this_block_num = dev->block_num;
2302 if (!write_block_to_dev(dcr)) {
2303 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2304 last_file, last_block_num, this_block_num);
2307 * This is 1st tape, so save first tape info separate
2308 * from second tape info
2310 last_block_num1 = last_block_num;
2311 last_file1 = last_file;
2312 last_block1 = dup_block(last_block);
2313 last_block2 = dup_block(last_block);
2314 first_block = dup_block(block); /* first block second tape */
2317 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2318 (unsigned)file_index, block->BlockNumber, block->block_len);
2319 dump_block(last_block, _("Last block written"));
2321 dump_block(block, _("Block not written"));
2324 eot_block = block->BlockNumber;
2325 eot_block_len = block->block_len;
2326 eot_FileIndex = file_index;
2330 now -= jcr->run_time;
2332 now = 1; /* don't divide by zero */
2334 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2335 vol_size = dev->VolCatInfo.VolCatBytes;
2336 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2337 dev->file, dev->block_num,
2338 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2341 stop = -1; /* stop, but do simplified test */
2343 /* Full test in progress */
2344 if (!fixup_device_block_write_error(jcr->dcr)) {
2345 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2350 BlockNumber = 0; /* start counting for second tape */
2353 return 1; /* end of tape reached */
2356 /* Save contents after write so that the header is serialized */
2357 memcpy(this_block->buf, block->buf, this_block->buf_len);
2360 * Note, we always read/write to block, but we toggle
2361 * copying it to one or another of two allocated blocks.
2362 * Switch blocks so that the block just successfully written is
2363 * always in last_block.
2365 tblock = last_block;
2366 last_block = this_block;
2367 this_block = tblock;
2368 last_file = this_file;
2369 last_block_num = this_block_num;
2377 * First we label the tape, then we fill
2378 * it with data get a new tape and write a few blocks.
2380 static void qfillcmd()
2382 DEV_BLOCK *block = dcr->block;
2383 DEV_RECORD *rec = dcr->rec;
2386 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2388 get_cmd(_("How many blocks do you want to write? (1000): "));
2395 sm_check(__FILE__, __LINE__, false);
2397 i = block->buf_len - 100;
2399 rec->data = check_pool_memory_size(rec->data, i);
2400 memset(rec->data, i & 0xFF, i);
2403 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2404 for (i=0; i < count; i++) {
2409 if (!write_record_to_block(block, rec)) {
2410 Pmsg0(0, _("Error writing record to block.\n"));
2413 if (!write_block_to_dev(dcr)) {
2414 Pmsg0(0, _("Error writing block to device.\n"));
2420 if (dev_cap(dev, CAP_TWOEOF)) {
2427 sm_check(__FILE__, __LINE__, false);
2431 * Fill a tape using raw write() command
2433 static void rawfill_cmd()
2435 DEV_BLOCK *block = dcr->block;
2438 uint32_t block_num = 0;
2443 fd = open("/dev/urandom", O_RDONLY);
2445 read(fd, block->buf, block->buf_len);
2448 uint32_t *p = (uint32_t *)block->buf;
2449 srandom(time(NULL));
2450 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2454 p = (uint32_t *)block->buf;
2455 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2458 stat = write(dev->fd, block->buf, block->buf_len);
2459 if (stat == (int)block->buf_len) {
2460 if ((block_num++ % 100) == 0) {
2465 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2475 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2476 be.strerror(my_errno));
2482 * Fill a tape using Bacula block writes
2484 static void bfill_cmd()
2486 DEV_BLOCK *block = dcr->block;
2487 uint32_t block_num = 0;
2493 fd = open("/dev/urandom", O_RDONLY);
2495 read(fd, block->buf, block->buf_len);
2498 uint32_t *p = (uint32_t *)block->buf;
2499 srandom(time(NULL));
2500 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2504 p = (uint32_t *)block->buf;
2505 Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2508 block->binbuf = block->buf_len;
2509 block->bufp = block->buf + block->binbuf;
2510 if (!write_block_to_dev(dcr)) {
2513 if ((block_num++ % 100) == 0) {
2518 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2524 printf(_("Write failed at block %u.\n"), block_num);
2529 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2530 static struct cmdstruct commands[] = {
2531 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2532 {NT_("bsf"), bsfcmd, _("backspace file")},
2533 {NT_("bsr"), bsrcmd, _("backspace record")},
2534 {NT_("bfill"), bfill_cmd, _("fill tape using Bacula writes")},
2535 {NT_("cap"), capcmd, _("list device capabilities")},
2536 {NT_("clear"), clearcmd, _("clear tape errors")},
2537 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2538 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2539 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2540 {NT_("unfill"), unfillcmd, _("read filled tape")},
2541 {NT_("fsf"), fsfcmd, _("forward space a file")},
2542 {NT_("fsr"), fsrcmd, _("forward space a record")},
2543 {NT_("help"), helpcmd, _("print this command")},
2544 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2545 {NT_("load"), loadcmd, _("load a tape")},
2546 {NT_("quit"), quitcmd, _("quit btape")},
2547 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2548 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2549 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2550 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2551 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2552 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2553 {NT_("status"), statcmd, _("print tape status")},
2554 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2555 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2556 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2557 {NT_("rr"), rrcmd, _("read a single record")},
2558 {NT_("qfill"), qfillcmd, _("quick fill command")}
2560 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2568 while (get_cmd("*")) {
2569 sm_check(__FILE__, __LINE__, false);
2571 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2572 for (i=0; i<comsize; i++) /* search for command */
2573 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2574 (*commands[i].func)(); /* go execute command */
2579 Pmsg1(0, _("%s is an illegal command\n"), cmd);
2585 static void helpcmd()
2589 printf(_("Interactive commands:\n"));
2590 printf(_(" Command Description\n ======= ===========\n"));
2591 for (i=0; i<comsize; i++)
2592 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2599 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2600 "\nVersion: %s (%s)\n\n"
2601 "Usage: btape <options> <device_name>\n"
2602 " -b <file> specify bootstrap file\n"
2603 " -c <file> set configuration file to file\n"
2604 " -d <nn> set debug level to nn\n"
2605 " -p proceed inspite of I/O errors\n"
2606 " -s turn off signals\n"
2608 " -? print this message.\n"
2609 "\n"), VERSION, BDATE);
2614 * Get next input command from terminal. This
2615 * routine is REALLY primitive, and should be enhanced
2616 * to have correct backspacing, etc.
2619 get_cmd(const char *prompt)
2623 fprintf(stdout, prompt);
2625 /* We really should turn off echoing and pretty this
2629 while ((ch = fgetc(stdin)) != EOF) {
2631 strip_trailing_junk(cmd);
2633 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2646 /* Dummies to replace askdir.c */
2647 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2648 bool dir_send_job_status(JCR *jcr) {return 1;}
2650 bool dir_update_volume_info(DCR *dcr, bool relabel)
2656 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2658 Dmsg0(20, "Enter dir_get_volume_info\n");
2659 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2663 bool dir_create_jobmedia_record(DCR *dcr)
2665 dcr->WroteVol = false;
2670 bool dir_find_next_appendable_volume(DCR *dcr)
2672 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2673 return dcr->VolumeName[0] != 0;
2676 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2678 DEVICE *dev = dcr->dev;
2679 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2680 if (dcr->VolumeName[0] == 0) {
2681 return dir_ask_sysop_to_create_appendable_volume(dcr);
2684 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2685 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2686 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2689 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2690 dcr->VolumeName, dev->print_name());
2696 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2699 DEVICE *dev = dcr->dev;
2700 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2702 set_volume_name("TestVolume1", 1);
2704 set_volume_name("TestVolume2", 2);
2706 /* Close device so user can use autochanger if desired */
2707 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2710 autochanger = autoload_device(dcr, 1, NULL);
2713 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2724 static bool my_mount_next_read_volume(DCR *dcr)
2727 JCR *jcr = dcr->jcr;
2728 DEV_BLOCK *block = dcr->block;
2730 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2731 Pmsg2(000, _("End of Volume \"%s\" %d records.\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);
2757 if (!acquire_device_for_read(dcr)) {
2758 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2761 return true; /* next volume mounted */
2764 static void set_volume_name(const char *VolName, int volnum)
2766 DCR *dcr = jcr->dcr;
2767 VolumeName = VolName;
2769 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2770 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2771 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2772 dcr->VolCatInfo.Slot = volnum;