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();
71 static void fillcmd();
72 static void qfillcmd();
73 static void statcmd();
74 static void unfillcmd();
75 static int flush_block(DEV_BLOCK *block, int dump);
76 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
77 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
78 static bool my_mount_next_read_volume(DCR *dcr);
79 static void scan_blocks();
80 static void set_volume_name(const char *VolName, int volnum);
81 static void rawfill_cmd();
82 static void bfill_cmd();
83 static bool open_the_device();
84 static void autochangercmd();
85 static void do_unfill();
88 /* Static variables */
89 #define CONFIG_FILE "bacula-sd.conf"
90 char *configfile = NULL;
92 #define MAX_CMD_ARGS 30
95 static char *argk[MAX_CMD_ARGS];
96 static char *argv[MAX_CMD_ARGS];
99 static int quickie_count = 0;
100 static uint64_t write_count = 0;
101 static BSR *bsr = NULL;
102 static int signals = TRUE;
105 static uint64_t vol_size;
106 static uint64_t VolBytes;
109 static int32_t file_index;
110 static int end_of_tape = 0;
111 static uint32_t LastBlock = 0;
112 static uint32_t eot_block;
113 static uint32_t eot_block_len;
114 static uint32_t eot_FileIndex;
115 static int dumped = 0;
116 static DEV_BLOCK *last_block1 = NULL;
117 static DEV_BLOCK *last_block2 = NULL;
118 static DEV_BLOCK *last_block = NULL;
119 static DEV_BLOCK *this_block = NULL;
120 static DEV_BLOCK *first_block = NULL;
121 static uint32_t last_file1 = 0;
122 static uint32_t last_file2 = 0;
123 static uint32_t last_file = 0;
124 static uint32_t last_block_num1 = 0;
125 static uint32_t last_block_num2 = 0;
126 static uint32_t last_block_num = 0;
127 static uint32_t BlockNumber = 0;
128 static bool simple = true;
130 static const char *VolumeName = NULL;
131 static int vol_num = 0;
133 static JCR *jcr = NULL;
137 static void terminate_btape(int sig);
138 int get_cmd(const char *prompt);
141 /*********************************************************************
143 * Bacula tape testing program
146 int main(int margc, char *margv[])
153 setlocale(LC_ALL, "");
154 bindtextdomain("bacula", LOCALEDIR);
155 textdomain("bacula");
159 if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
160 Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
161 TAPE_BSIZE, B_DEV_BSIZE);
163 if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
164 Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
166 if (sizeof(boffset_t) < 8) {
167 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. boffset_t=%d should be 8 or more !!!!!\n\n\n"),
171 bsnprintf(buf, sizeof(buf), "%u", x32);
172 i = bsscanf(buf, "%lu", &y32);
173 if (i != 1 || x32 != y32) {
174 Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
180 bsnprintf(buf, sizeof(buf), "%" llu, x64);
181 i = bsscanf(buf, "%llu", &y64);
182 if (i != 1 || x64 != y64) {
183 Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
188 printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
190 working_directory = "/tmp";
191 my_name_is(margc, margv, "btape");
192 init_msg(NULL, NULL);
196 while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
198 case 'b': /* bootstrap file */
199 bsr = parse_bsr(NULL, optarg);
200 // dump_bsr(bsr, true);
203 case 'c': /* specify config file */
204 if (configfile != NULL) {
207 configfile = bstrdup(optarg);
210 case 'd': /* set debug level */
211 debug_level = atoi(optarg);
212 if (debug_level <= 0) {
239 cmd = get_pool_memory(PM_FNAME);
240 args = get_pool_memory(PM_FNAME);
243 init_signals(terminate_btape);
246 if (configfile == NULL) {
247 configfile = bstrdup(CONFIG_FILE);
250 daemon_start_time = time(NULL);
252 parse_config(configfile);
255 /* See if we can open a device */
257 Pmsg0(000, _("No archive name specified.\n"));
260 } else if (margc != 1) {
261 Pmsg0(000, _("Improper number of arguments specified.\n"));
266 jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
275 Pmsg0(000, _("btape does not work with DVD storage.\n"));
279 if (!dev->is_tape()) {
280 Pmsg0(000, _("btape only works with tape storage.\n"));
285 if (!open_the_device()) {
289 Dmsg0(200, "Do tape commands\n");
297 static void terminate_btape(int stat)
300 sm_check(__FILE__, __LINE__, false);
304 free_config_resources();
306 free_pool_memory(args);
310 free_pool_memory(cmd);
327 if (debug_level > 10)
328 print_memory_pool_stats();
331 free_block(this_block);
336 close_memory_pool(); /* free memory in pool */
337 term_last_jobs_list();
343 static bool open_the_device()
347 block = new_block(dev);
349 Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
350 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
351 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
356 Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
357 dev->set_append(); /* put volume in append mode */
370 * Write a label to the tape
372 static void labelcmd()
375 pm_strcpy(cmd, VolumeName);
377 if (!get_cmd(_("Enter Volume Name: "))) {
382 if (!dev->is_open()) {
383 if (!first_open_device(dcr)) {
384 Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
389 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
390 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
394 * Read the tape label
396 static void readlabelcmd()
398 int save_debug_level = debug_level;
401 stat = read_dev_volume_label(dcr);
404 Pmsg0(0, _("Volume has no label.\n"));
407 Pmsg0(0, _("Volume label read correctly.\n"));
410 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
413 Pmsg0(0, _("Volume name error\n"));
415 case VOL_CREATE_ERROR:
416 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
418 case VOL_VERSION_ERROR:
419 Pmsg0(0, _("Volume version error.\n"));
421 case VOL_LABEL_ERROR:
422 Pmsg0(0, _("Bad Volume label type.\n"));
425 Pmsg0(0, _("Unknown error.\n"));
430 dump_volume_label(dev);
431 debug_level = save_debug_level;
436 * Load the tape should have prevously been taken
437 * off line, otherwise this command is not necessary.
439 static void loadcmd()
442 if (!load_dev(dev)) {
443 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
445 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
451 static void rewindcmd()
453 if (!dev->rewind(dcr)) {
454 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
457 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
462 * Clear any tape error
464 static void clearcmd()
470 * Write and end of file on the tape
472 static void weofcmd()
482 if (!dev->weof(num)) {
483 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
487 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
490 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
496 /* Go to the end of the medium -- raw command
497 * The idea was orginally that the end of the Bacula
498 * medium would be flagged differently. This is not
499 * currently the case. So, this is identical to the
504 if (!dev->eod(dcr)) {
505 Pmsg1(0, "%s", dev->bstrerror());
508 Pmsg0(0, _("Moved to end of medium.\n"));
513 * Go to the end of the medium (either hardware determined
514 * or defined by two eofs.
534 if (!dev->bsf(num)) {
535 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
537 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
553 if (!dev->bsr(num)) {
554 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
556 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
561 * List device capabilities as defined in the
566 printf(_("Configured device capabilities:\n"));
567 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
568 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
569 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
570 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
571 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
572 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
573 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
574 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
575 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
576 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
577 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
578 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
579 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
580 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
581 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
584 printf(_("Device status:\n"));
585 printf("%sOPENED ", dev->is_open() ? "" : "!");
586 printf("%sTAPE ", dev->is_tape() ? "" : "!");
587 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
588 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
589 printf("%sAPPEND ", dev->can_append() ? "" : "!");
590 printf("%sREAD ", dev->can_read() ? "" : "!");
591 printf("%sEOT ", dev->at_eot() ? "" : "!");
592 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
593 printf("%sEOF ", dev->at_eof() ? "" : "!");
594 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
595 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
598 printf(_("Device parameters:\n"));
599 printf("Device name: %s\n", dev->dev_name);
600 printf("File=%u block=%u\n", dev->file, dev->block_num);
601 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
603 printf(_("Status:\n"));
609 * Test writting larger and larger records.
610 * This is a torture test for records.
612 static void rectestcmd()
618 Pmsg0(0, _("Test writting larger and larger records.\n"
619 "This is a torture test for records.\nI am going to write\n"
620 "larger and larger records. It will stop when the record size\n"
621 "plus the header exceeds the block size (by default about 64K)\n"));
624 get_cmd(_("Do you want to continue? (y/n): "));
626 Pmsg0(000, _("Command aborted.\n"));
630 sm_check(__FILE__, __LINE__, false);
631 block = new_block(dev);
634 for (i=1; i<500000; i++) {
635 rec->data = check_pool_memory_size(rec->data, i);
636 memset(rec->data, i & 0xFF, i);
638 sm_check(__FILE__, __LINE__, false);
639 if (write_record_to_block(block, rec)) {
642 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
646 sm_check(__FILE__, __LINE__, false);
650 sm_check(__FILE__, __LINE__, false);
654 * This test attempts to re-read a block written by Bacula
655 * normally at the end of the tape. Bacula will then back up
656 * over the two eof marks, backup over the record and reread
657 * it to make sure it is valid. Bacula can skip this validation
658 * if you set "Backward space record = no"
660 static int re_read_block_test()
662 DEV_BLOCK *block = dcr->block;
667 if (!(dev->capabilities & CAP_BSR)) {
668 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
672 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
673 "I'm going to write three records and an EOF\n"
674 "then backup over the EOF and re-read the last record.\n"
675 "Bacula does this after writing the last block on the\n"
676 "tape to verify that the block was written correctly.\n\n"
677 "This is not an *essential* feature ...\n\n"));
681 rec->data = check_pool_memory_size(rec->data, block->buf_len);
682 len = rec->data_len = block->buf_len-100;
683 memset(rec->data, 1, rec->data_len);
684 if (!write_record_to_block(block, rec)) {
685 Pmsg0(0, _("Error writing record to block.\n"));
688 if (!write_block_to_dev(dcr)) {
689 Pmsg0(0, _("Error writing block to device.\n"));
692 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
694 memset(rec->data, 2, rec->data_len);
695 if (!write_record_to_block(block, rec)) {
696 Pmsg0(0, _("Error writing record to block.\n"));
699 if (!write_block_to_dev(dcr)) {
700 Pmsg0(0, _("Error writing block to device.\n"));
703 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
705 memset(rec->data, 3, rec->data_len);
706 if (!write_record_to_block(block, rec)) {
707 Pmsg0(0, _("Error writing record to block.\n"));
710 if (!write_block_to_dev(dcr)) {
711 Pmsg0(0, _("Error writing block to device.\n"));
714 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
717 if (dev_cap(dev, CAP_TWOEOF)) {
721 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
724 if (dev_cap(dev, CAP_TWOEOF)) {
726 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
730 Pmsg0(0, _("Backspaced over EOF OK.\n"));
732 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
735 Pmsg0(0, _("Backspace record OK.\n"));
736 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
738 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
741 memset(rec->data, 0, rec->data_len);
742 if (!read_record_from_block(block, rec)) {
744 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
747 for (int i=0; i<len; i++) {
748 if (rec->data[i] != 3) {
749 Pmsg0(0, _("Bad data in record. Test failed!\n"));
753 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
754 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
761 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
762 "this function to verify the last block written to the\n"
763 "tape. Bacula will skip the last block verification\n"
765 "Backward Space Record = No\n\n"
766 "to your Storage daemon's Device resource definition.\n"));
773 * This test writes Bacula blocks to the tape in
774 * several files. It then rewinds the tape and attepts
775 * to read these blocks back checking the data.
777 static int write_read_test()
785 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
786 "I'm going to write 1000 records and an EOF\n"
787 "then write 1000 records and an EOF, then rewind,\n"
788 "and re-read the data to verify that it is correct.\n\n"
789 "This is an *essential* feature ...\n\n"));
792 if (!dev->rewind(dcr)) {
793 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
796 rec->data = check_pool_memory_size(rec->data, block->buf_len);
797 rec->data_len = block->buf_len-100;
798 len = rec->data_len/sizeof(i);
799 for (i=1; i<=1000; 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 for (i=1001; i<=2000; i++) {
816 p = (int *)rec->data;
817 for (j=0; j<len; j++) {
820 if (!write_record_to_block(block, rec)) {
821 Pmsg0(0, _("Error writing record to block.\n"));
824 if (!write_block_to_dev(dcr)) {
825 Pmsg0(0, _("Error writing block to device.\n"));
829 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
831 if (dev_cap(dev, CAP_TWOEOF)) {
834 if (!dev->rewind(dcr)) {
835 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
838 Pmsg0(0, _("Rewind OK.\n"));
840 for (i=1; i<=2000; i++) {
842 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
844 if (dev_state(dev, ST_EOF)) {
845 Pmsg0(-1, _("Got EOF on tape.\n"));
850 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
853 memset(rec->data, 0, rec->data_len);
854 if (!read_record_from_block(block, rec)) {
856 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
859 p = (int *)rec->data;
860 for (j=0; j<len; j++) {
862 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
868 if (i == 1000 || i == 2000) {
869 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
872 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
881 * This test writes Bacula blocks to the tape in
882 * several files. It then rewinds the tape and attepts
883 * to read these blocks back checking the data.
885 static int position_test()
887 DEV_BLOCK *block = dcr->block;
893 int file = 0, blk = 0;
895 bool got_eof = false;
897 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
898 "I'm going to write 1000 records and an EOF\n"
899 "then write 1000 records and an EOF, then rewind,\n"
900 "and position to a few blocks and verify that it is correct.\n\n"
901 "This is an *essential* feature ...\n\n"));
904 if (!dev->rewind(dcr)) {
905 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
908 rec->data = check_pool_memory_size(rec->data, block->buf_len);
909 rec->data_len = block->buf_len-100;
910 len = rec->data_len/sizeof(i);
911 for (i=1; i<=1000; 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 for (i=1001; i<=2000; i++) {
928 p = (int *)rec->data;
929 for (j=0; j<len; j++) {
932 if (!write_record_to_block(block, rec)) {
933 Pmsg0(0, _("Error writing record to block.\n"));
936 if (!write_block_to_dev(dcr)) {
937 Pmsg0(0, _("Error writing block to device.\n"));
941 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
943 if (dev_cap(dev, CAP_TWOEOF)) {
946 if (!dev->rewind(dcr)) {
947 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
950 Pmsg0(0, _("Rewind OK.\n"));
954 /* Set up next item to read based on where we are */
990 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
991 if (!dev->reposition(dcr, file, blk)) {
992 Pmsg0(0, _("Reposition error.\n"));
996 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
998 if (dev_state(dev, ST_EOF)) {
999 Pmsg0(-1, _("Got EOF on tape.\n"));
1005 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1006 recno, file, blk, be.strerror(dev->dev_errno));
1007 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1008 " set to variable blocking as normally used by Bacula.\n"
1009 " Please see the Tape Testing chapter in the manual and \n"
1010 " look for using mt with defblksize and setoptions\n"
1011 "If your tape drive block size is correct, then perhaps\n"
1012 " your SCSI driver is *really* stupid and does not\n"
1013 " correctly report the file:block after a FSF. In this\n"
1014 " case try setting:\n"
1015 " Fast Forward Space File = no\n"
1016 " in your Device resource.\n"));
1020 memset(rec->data, 0, rec->data_len);
1021 if (!read_record_from_block(block, rec)) {
1023 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1026 p = (int *)rec->data;
1027 for (j=0; j<len; j++) {
1028 if (p[j] != recno) {
1029 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1034 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1036 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1048 * This test writes some records, then writes an end of file,
1049 * rewinds the tape, moves to the end of the data and attepts
1050 * to append to the tape. This function is essential for
1051 * Bacula to be able to write multiple jobs to the tape.
1053 static int append_test()
1055 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1056 "This test is essential to Bacula.\n\n"
1057 "I'm going to write one record in file 0,\n"
1058 " two records in file 1,\n"
1059 " and three records in file 2\n\n"));
1063 weofcmd(); /* end file 0 */
1066 weofcmd(); /* end file 1 */
1070 weofcmd(); /* end file 2 */
1071 if (dev_cap(dev, CAP_TWOEOF)) {
1074 dev->close(); /* release device */
1075 if (!open_the_device()) {
1079 Pmsg0(0, _("Now moving to end of medium.\n"));
1081 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1082 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1084 if (dev->file != 3) {
1088 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1091 if (dev_cap(dev, CAP_TWOEOF)) {
1095 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1096 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1098 Pmsg0(-1, _("End scanning the tape.\n"));
1099 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1100 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1102 if (dev->file != 4) {
1110 * This test exercises the autochanger
1112 static int autochanger_test()
1114 POOLMEM *results, *changer;
1115 int slot, status, loaded;
1116 int timeout = dcr->device->max_changer_wait;
1119 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1120 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1123 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1124 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1128 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1129 "To test the autochanger you must have a blank tape\n"
1130 " that I can write on in Slot 1.\n"));
1131 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1134 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1138 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1140 results = get_pool_memory(PM_MESSAGE);
1141 changer = get_pool_memory(PM_FNAME);
1145 dcr->VolCatInfo.Slot = slot;
1146 /* Find out what is loaded, zero means device is unloaded */
1147 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1148 changer = edit_device_codes(dcr, changer,
1149 dcr->device->changer_command, "loaded");
1150 status = run_program(changer, timeout, results);
1151 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1153 loaded = atoi(results);
1156 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1157 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1161 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1163 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1165 Dmsg1(100, "Results from loaded query=%s\n", results);
1167 dcr->VolCatInfo.Slot = loaded;
1168 /* We are going to load a new tape, so close the device */
1170 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1171 loaded, dev->drive_index);
1172 changer = edit_device_codes(dcr, changer,
1173 dcr->device->changer_command, "unload");
1174 status = run_program(changer, timeout, results);
1175 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1178 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1179 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1188 dcr->VolCatInfo.Slot = slot;
1189 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1190 slot, dev->drive_index);
1191 changer = edit_device_codes(dcr, changer,
1192 dcr->device->changer_command, "load");
1193 Dmsg1(100, "Changer=%s\n", changer);
1195 status = run_program(changer, timeout, results);
1197 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1198 slot, dev->drive_index);
1201 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1202 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1206 if (!open_the_device()) {
1210 * Start with sleep_time 0 then increment by 30 seconds if we get
1213 bmicrosleep(sleep_time, 0);
1214 if (!dev->rewind(dcr) || !dev->weof(1)) {
1215 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1217 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1218 "a longer sleep time in the mtx-script in the load) case.\n"
1219 "Adding a 30 second sleep and trying again ...\n"));
1223 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1226 if (!dev->weof(1)) {
1227 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1230 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1234 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1236 "to your mtx-changer script in the load) case.\n\n"),
1239 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1242 free_pool_memory(changer);
1243 free_pool_memory(results);
1248 free_pool_memory(changer);
1249 free_pool_memory(results);
1250 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1254 static void autochangercmd()
1261 * This test assumes that the append test has been done,
1262 * then it tests the fsf function.
1264 static int fsf_test()
1266 bool set_off = false;
1268 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1269 "This test is essential to Bacula.\n\n"
1270 "I'm going to write five files then test forward spacing\n\n"));
1274 weofcmd(); /* end file 0 */
1277 weofcmd(); /* end file 1 */
1281 weofcmd(); /* end file 2 */
1284 weofcmd(); /* end file 3 */
1286 weofcmd(); /* end file 4 */
1287 if (dev_cap(dev, CAP_TWOEOF)) {
1293 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1295 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1298 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1299 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1301 if (dev->file != 1) {
1305 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1307 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1310 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1311 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1313 if (dev->file != 3) {
1318 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1320 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1323 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1324 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1326 if (dev->file != 4) {
1330 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1331 " Fast Forward Space File = no\n\n"
1332 "to your Device resource for this drive.\n"));
1336 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1338 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1340 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1341 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1342 if (dev->file != 5) {
1345 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1349 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1350 if (dev_cap(dev, CAP_FASTFSF)) {
1351 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1352 "I am turning it off then retrying the test.\n"));
1353 dev->capabilities &= ~CAP_FASTFSF;
1357 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1358 "Some systems, e.g. OpenBSD, require you to set\n"
1359 " Use MTIOCGET= no\n"
1360 "in your device resource. Use with caution.\n"));
1369 * This is a general test of Bacula's functions
1370 * needed to read and write the tape.
1372 static void testcmd()
1376 if (!write_read_test()) {
1379 if (!position_test()) {
1383 stat = append_test();
1384 if (stat == 1) { /* OK get out */
1387 if (stat == -1) { /* first test failed */
1388 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1389 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1390 "Setting \"Hardware End of Medium = no\n"
1391 " and \"Fast Forward Space File = no\n"
1392 "and retrying append test.\n\n"));
1393 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1394 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1395 stat = append_test();
1397 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1398 " Hardware End of Medium = No\n\n"
1399 " Fast Forward Space File = No\n"
1400 "to your Device resource in the Storage conf file.\n"));
1404 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1407 /* Wrong count after append */
1409 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1410 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1411 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1412 stat = append_test();
1414 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1415 " Hardware End of Medium = No\n"
1416 " Fast Forward Space File = No\n"
1417 " BSF at EOM = yes\n\n"
1418 "to your Device resource in the Storage conf file.\n"));
1425 Pmsg0(-1, _("\nAppend test failed.\n\n"
1426 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1427 "Unable to correct the problem. You MUST fix this\n"
1428 "problem before Bacula can use your tape drive correctly\n"
1429 "\nPerhaps running Bacula in fixed block mode will work.\n"
1430 "Do so by setting:\n\n"
1431 "Minimum Block Size = nnn\n"
1432 "Maximum Block Size = nnn\n\n"
1433 "in your Storage daemon's Device definition.\n"
1434 "nnn must match your tape driver's block size, which\n"
1435 "can be determined by reading your tape manufacturers\n"
1436 "information, and the information on your kernel dirver.\n"
1437 "Fixed block sizes, however, are not normally an ideal solution.\n"
1439 "Some systems, e.g. OpenBSD, require you to set\n"
1440 " Use MTIOCGET= no\n"
1441 "in your device resource. Use with caution.\n"));
1446 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1447 "Please double check it ...\n"
1448 "=== Sample correct output ===\n"
1449 "1 block of 64448 bytes in file 1\n"
1450 "End of File mark.\n"
1451 "2 blocks of 64448 bytes in file 2\n"
1452 "End of File mark.\n"
1453 "3 blocks of 64448 bytes in file 3\n"
1454 "End of File mark.\n"
1455 "1 block of 64448 bytes in file 4\n"
1456 "End of File mark.\n"
1457 "Total files=4, blocks=7, bytes = 451,136\n"
1458 "=== End sample correct output ===\n\n"
1459 "If the above scan output is not identical to the\n"
1460 "sample output, you MUST correct the problem\n"
1461 "or Bacula will not be able to write multiple Jobs to \n"
1465 re_read_block_test();
1468 fsf_test(); /* do fast forward space file test */
1470 autochanger_test(); /* do autochanger test */
1474 /* Forward space a file */
1475 static void fsfcmd()
1479 num = atoi(argk[1]);
1484 if (!dev->fsf(num)) {
1485 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1489 Pmsg0(0, _("Forward spaced 1 file.\n"));
1492 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1496 /* Forward space a record */
1497 static void fsrcmd()
1501 num = atoi(argk[1]);
1506 if (!dev->fsr(num)) {
1507 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1511 Pmsg0(0, _("Forward spaced 1 record.\n"));
1514 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1519 * Read a Bacula block from the tape
1523 dev->open(dcr, OPEN_READ_ONLY);
1524 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1528 * Write a Bacula block to the tape
1532 DEV_BLOCK *block = dcr->block;
1533 DEV_RECORD *rec = dcr->rec;
1536 if (!dev->is_open()) {
1539 sm_check(__FILE__, __LINE__, false);
1542 dump_block(block, "test");
1545 i = block->buf_len - 100;
1547 rec->data = check_pool_memory_size(rec->data, i);
1548 memset(rec->data, i & 0xFF, i);
1550 sm_check(__FILE__, __LINE__, false);
1551 if (!write_record_to_block(block, rec)) {
1552 Pmsg0(0, _("Error writing record to block.\n"));
1555 if (!write_block_to_dev(dcr)) {
1556 Pmsg0(0, _("Error writing block to device.\n"));
1559 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1561 Pmsg0(0, _("Wrote block to device.\n"));
1564 sm_check(__FILE__, __LINE__, false);
1565 sm_check(__FILE__, __LINE__, false);
1569 * Read a record from the tape
1576 if (!get_cmd(_("Enter length to read: "))) {
1580 if (len < 0 || len > 1000000) {
1581 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1584 buf = (char *)malloc(len);
1585 stat = read(dev->fd, buf, len);
1586 if (stat > 0 && stat <= len) {
1590 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1591 len, stat, be.strerror());
1597 * Scan tape by reading block by block. Report what is
1598 * on the tape. Note, this command does raw reads, and as such
1599 * will not work with fixed block size devices.
1601 static void scancmd()
1604 int blocks, tot_blocks, tot_files;
1610 blocks = block_size = tot_blocks = 0;
1612 if (dev->state & ST_EOT) {
1613 Pmsg0(0, _("End of tape\n"));
1616 dev->update_pos(dcr);
1617 tot_files = dev->file;
1618 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1620 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1623 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1624 dev->dev_name, be.strerror());
1625 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1628 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1631 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1636 Dmsg1(200, "read status = %d\n", stat);
1638 if (stat != block_size) {
1639 dev->update_pos(dcr);
1642 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1645 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1651 if (stat == 0) { /* EOF */
1652 dev->update_pos(dcr);
1653 printf(_("End of File mark.\n"));
1654 /* Two reads of zero means end of tape */
1655 if (dev->state & ST_EOF)
1656 dev->state |= ST_EOT;
1658 dev->state |= ST_EOF;
1661 if (dev->state & ST_EOT) {
1662 printf(_("End of tape\n"));
1665 } else { /* Got data */
1666 dev->state &= ~ST_EOF;
1672 dev->update_pos(dcr);
1673 tot_files = dev->file - tot_files;
1674 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1675 edit_uint64_with_commas(bytes, ec1));
1680 * Scan tape by reading Bacula block by block. Report what is
1681 * on the tape. This function reads Bacula blocks, so if your
1682 * Device resource is correctly defined, it should work with
1683 * either variable or fixed block sizes.
1685 static void scan_blocks()
1687 int blocks, tot_blocks, tot_files;
1688 uint32_t block_size;
1690 DEV_BLOCK *block = dcr->block;
1692 char buf1[100], buf2[100];
1694 blocks = block_size = tot_blocks = 0;
1698 dev->update_pos(dcr);
1699 tot_files = dev->file;
1701 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1702 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1703 if (dev->state & ST_EOT) {
1706 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1709 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1715 if (dev->state & ST_EOF) {
1718 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1721 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1725 printf(_("End of File mark.\n"));
1728 if (dev->state & ST_SHORT) {
1731 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1734 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1738 printf(_("Short block read.\n"));
1741 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1744 if (block->block_len != block_size) {
1747 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1750 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1754 block_size = block->block_len;
1758 bytes += block->block_len;
1759 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1760 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1761 block->VolSessionId, block->VolSessionTime);
1763 DEV_RECORD *rec = new_record();
1764 read_record_from_block(block, rec);
1765 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1766 block->BlockNumber, dev->block_num, block->block_len,
1767 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1768 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1771 } else if (verbose > 1) {
1772 dump_block(block, "");
1777 tot_files = dev->file - tot_files;
1778 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1779 edit_uint64_with_commas(bytes, ec1));
1783 static void statcmd()
1785 int debug = debug_level;
1787 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1789 dump_volume_label(dev);
1791 debug_level = debug;
1796 * First we label the tape, then we fill
1797 * it with data get a new tape and write a few blocks.
1799 static void fillcmd()
1802 DEV_BLOCK *block = dcr->block;
1804 char buf1[100], buf2[100];
1807 uint32_t min_block_size;
1818 "This command simulates Bacula writing to a tape.\n"
1819 "It requires either one or two blank tapes, which it\n"
1820 "will label and write.\n\n"
1821 "If you have an autochanger configured, it will use\n"
1822 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1823 "be prompted to insert the tapes when necessary.\n\n"
1824 "It will print a status approximately\n"
1825 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1826 "selected the simple test option, after writing the first tape\n"
1827 "it will rewind it and re-read the last block written.\n\n"
1828 "If you have selected the multiple tape test, when the first tape\n"
1829 "fills, it will ask for a second, and after writing a few more \n"
1830 "blocks, it will stop. Then it will begin re-reading the\n"
1832 "This may take a long time -- hours! ...\n\n"));
1834 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1835 "or the complete multiple tape (m) test: (s/m) "));
1836 if (cmd[0] == 's') {
1837 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1839 } else if (cmd[0] == 'm') {
1840 Pmsg0(-1, _("Multiple tape test selected.\n"));
1843 Pmsg0(000, _("Command aborted.\n"));
1847 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1848 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1850 /* Use fixed block size to simplify read back */
1851 min_block_size = dev->min_block_size;
1852 dev->min_block_size = dev->max_block_size;
1853 set_volume_name("TestVolume1", 1);
1854 dir_ask_sysop_to_create_appendable_volume(dcr);
1855 dev->set_append(); /* force volume to be relabeled */
1858 * Acquire output device for writing. Note, after acquiring a
1859 * device, we MUST release it, which is done at the end of this
1862 Dmsg0(100, "just before acquire_device\n");
1863 if (!acquire_device_for_append(dcr)) {
1864 set_jcr_job_status(jcr, JS_ErrorTerminated);
1867 block = jcr->dcr->block;
1869 Dmsg0(100, "Just after acquire_device_for_append\n");
1871 * Write Begin Session Record
1873 if (!write_session_label(dcr, SOS_LABEL)) {
1874 set_jcr_job_status(jcr, JS_ErrorTerminated);
1875 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1879 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1881 memset(&rec, 0, sizeof(rec));
1882 rec.data = get_memory(100000); /* max record size */
1884 #define REC_SIZE 32768
1885 rec.data_len = REC_SIZE;
1888 * Put some random data in the record
1890 fd = open("/dev/urandom", O_RDONLY);
1892 read(fd, rec.data, rec.data_len);
1895 uint32_t *p = (uint32_t *)rec.data;
1896 srandom(time(NULL));
1897 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1903 * Generate data as if from File daemon, write to device
1905 jcr->dcr->VolFirstIndex = 0;
1906 time(&jcr->run_time); /* start counting time for rates */
1907 (void)localtime_r(&jcr->run_time, &tm);
1908 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1910 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1912 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1914 for (file_index = 0; ok && !job_canceled(jcr); ) {
1915 rec.VolSessionId = jcr->VolSessionId;
1916 rec.VolSessionTime = jcr->VolSessionTime;
1917 rec.FileIndex = ++file_index;
1918 rec.Stream = STREAM_FILE_DATA;
1920 /* Mix up the data just a bit */
1921 uint32_t *lp = (uint32_t *)rec.data;
1923 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1927 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1928 rec.FileIndex, rec.VolSessionId,
1929 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1932 while (!write_record_to_block(block, &rec)) {
1934 * When we get here we have just filled a block
1936 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1939 /* Write block to tape */
1940 if (!flush_block(block, 1)) {
1944 /* Every 5000 blocks (approx 322MB) report where we are.
1946 if ((block->BlockNumber % 5000) == 0) {
1948 now -= jcr->run_time;
1950 now = 1; /* prevent divide error */
1952 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1953 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1954 block->BlockNumber, dev->block_num,
1955 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1957 /* Every 32000 blocks (approx 2GB) write an EOF.
1959 if ((block->BlockNumber % 32000) == 0) {
1961 (void)localtime_r(&now, &tm);
1962 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1963 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1964 flush_block(block, 0);
1968 /* Get out after writing 10 blocks to the second tape */
1969 if (++BlockNumber > 10 && stop != 0) { /* get out */
1974 Pmsg0(000, _("Not OK\n"));
1977 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1978 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1979 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1980 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1982 /* Get out after writing 10 blocks to the second tape */
1983 if (BlockNumber > 10 && stop != 0) { /* get out */
1985 Pmsg1(-1, "Done writing %s records ...\n",
1986 edit_uint64_with_commas(write_count, ed1));
1991 Dmsg0(100, "Write_end_session_label()\n");
1992 /* Create Job status for end of session label */
1993 if (!job_canceled(jcr) && ok) {
1994 set_jcr_job_status(jcr, JS_Terminated);
1996 set_jcr_job_status(jcr, JS_ErrorTerminated);
1998 if (!write_session_label(dcr, EOS_LABEL)) {
1999 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2002 /* Write out final block of this session */
2003 if (!write_block_to_device(dcr)) {
2004 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2007 Pmsg0(-1, _("Wrote End of Session label.\n"));
2009 /* Save last block info for second tape */
2010 last_block_num2 = last_block_num;
2011 last_file2 = last_file;
2013 free_block(last_block2);
2015 last_block2 = dup_block(last_block);
2018 sprintf(buf, "%s/btape.state", working_directory);
2019 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2021 write(fd, &btape_state_level, sizeof(btape_state_level));
2022 write(fd, &simple, sizeof(simple));
2023 write(fd, &last_block_num1, sizeof(last_block_num1));
2024 write(fd, &last_block_num2, sizeof(last_block_num2));
2025 write(fd, &last_file1, sizeof(last_file1));
2026 write(fd, &last_file2, sizeof(last_file2));
2027 write(fd, last_block1->buf, last_block1->buf_len);
2028 write(fd, last_block2->buf, last_block2->buf_len);
2029 write(fd, first_block->buf, first_block->buf_len);
2031 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2032 last_block_num1, last_block_num2);
2035 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2040 (void)localtime_r(&now, &tm);
2041 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2043 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2044 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2047 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2048 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2051 jcr->dcr->block = block;
2054 dev->min_block_size = min_block_size;
2055 free_memory(rec.data);
2059 * Read two tapes written by the "fill" command and ensure
2060 * that the data is valid. If stop==1 we simulate full read back
2061 * of two tapes. If stop==-1 we simply read the last block and
2062 * verify that it is correct.
2064 static void unfillcmd()
2068 last_block1 = new_block(dev);
2069 last_block2 = new_block(dev);
2070 first_block = new_block(dev);
2071 sprintf(buf, "%s/btape.state", working_directory);
2072 fd = open(buf, O_RDONLY);
2074 uint32_t state_level;
2075 read(fd, &state_level, sizeof(btape_state_level));
2076 read(fd, &simple, sizeof(simple));
2077 read(fd, &last_block_num1, sizeof(last_block_num1));
2078 read(fd, &last_block_num2, sizeof(last_block_num2));
2079 read(fd, &last_file1, sizeof(last_file1));
2080 read(fd, &last_file2, sizeof(last_file2));
2081 read(fd, last_block1->buf, last_block1->buf_len);
2082 read(fd, last_block2->buf, last_block2->buf_len);
2083 read(fd, first_block->buf, first_block->buf_len);
2085 if (state_level != btape_state_level) {
2086 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2087 "the fill command.\n"));
2092 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2093 "You must redo the fill command.\n"), buf, be.strerror());
2100 static void do_unfill()
2102 DEV_BLOCK *block = dcr->block;
2109 Dmsg0(20, "Enter do_unfill\n");
2110 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2111 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2115 time(&jcr->run_time); /* start counting time for rates */
2119 free_block(last_block);
2122 last_block_num = last_block_num1;
2123 last_file = last_file1;
2124 last_block = last_block1;
2126 free_restore_volume_list(jcr);
2128 bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2129 create_restore_volume_list(jcr);
2130 if (jcr->VolList != NULL) {
2131 jcr->VolList->Slot = 1;
2132 if (jcr->VolList->next != NULL) {
2133 jcr->VolList->next->Slot = 2;
2137 set_volume_name("TestVolume1", 1);
2140 /* Multiple Volume tape */
2141 /* Close device so user can use autochanger if desired */
2142 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2145 autochanger = autoload_device(dcr, 1, NULL);
2146 if (autochanger != 1) {
2148 get_cmd(_("Mount first tape. Press enter when ready: "));
2153 dev->num_writers = 0;
2154 if (!acquire_device_for_read(dcr)) {
2155 Pmsg1(-1, "%s", dev->errmsg);
2159 * We now have the first tape mounted.
2160 * Note, re-reading last block may have caused us to
2161 * loose track of where we are (block number unknown).
2163 Pmsg0(-1, _("Rewinding.\n"));
2164 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2167 /* Read the first 10000 records */
2168 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2169 dev->file, dev->block_num);
2171 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2172 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2173 last_file, last_block_num);
2174 if (!dev->reposition(dcr, last_file, last_block_num)) {
2175 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2178 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2179 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2180 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2183 if (compare_blocks(last_block, block)) {
2185 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2187 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2194 /* restore info for last block on second Volume */
2195 last_block_num = last_block_num2;
2196 last_file = last_file2;
2197 last_block = last_block2;
2199 /* Multiple Volume tape */
2200 /* Close device so user can use autochanger if desired */
2201 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2205 set_volume_name("TestVolume2", 2);
2207 autochanger = autoload_device(dcr, 1, NULL);
2208 if (autochanger != 1) {
2210 get_cmd(_("Mount second tape. Press enter when ready: "));
2214 if (!acquire_device_for_read(dcr)) {
2215 Pmsg1(-1, "%s", dev->errmsg);
2219 /* Space to "first" block which is last block not written
2220 * on the previous tape.
2222 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2223 if (!dev->reposition(dcr, 0, 1)) {
2224 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2227 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2228 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2229 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2232 if (compare_blocks(first_block, block)) {
2233 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2236 /* Now find and compare the last block */
2237 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2238 last_file, last_block_num);
2239 if (!dev->reposition(dcr, last_file, last_block_num)) {
2240 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2243 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2244 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2245 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2248 if (compare_blocks(last_block, block)) {
2249 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2253 free_block(last_block1);
2254 free_block(last_block2);
2255 free_block(first_block);
2258 /* Read 10000 records then stop */
2259 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2261 DEVICE *dev = dcr->dev;
2263 if (quickie_count == 10000) {
2264 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2266 return quickie_count < 10000;
2269 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2272 uint32_t CheckSum, block_len;
2275 p = last_block->buf;
2277 unser_begin(q, BLKHDR2_LENGTH);
2278 unser_uint32(CheckSum);
2279 unser_uint32(block_len);
2280 while (q < (block->buf+block_len)) {
2287 dump_block(last_block, _("Last block written"));
2289 dump_block(block, _("Block read back"));
2290 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2291 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2292 "that was read back differ. The test FAILED !!!!\n"
2293 "This must be corrected before you use Bacula\n"
2294 "to write multi-tape Volumes.!!!!\n"));
2298 dump_block(last_block, _("Last block written"));
2299 dump_block(block, _("Block read back"));
2309 * Write current block to tape regardless of whether or
2310 * not it is full. If the tape fills, attempt to
2311 * acquire another tape.
2313 static int flush_block(DEV_BLOCK *block, int dump)
2317 uint32_t this_file, this_block_num;
2321 this_block = new_block(dev);
2324 last_block = new_block(dev);
2327 this_file = dev->file;
2328 this_block_num = dev->block_num;
2329 if (!write_block_to_dev(dcr)) {
2330 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2331 last_file, last_block_num, this_block_num);
2334 * This is 1st tape, so save first tape info separate
2335 * from second tape info
2337 last_block_num1 = last_block_num;
2338 last_file1 = last_file;
2339 last_block1 = dup_block(last_block);
2340 last_block2 = dup_block(last_block);
2341 first_block = dup_block(block); /* first block second tape */
2344 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2345 (unsigned)file_index, block->BlockNumber, block->block_len);
2346 dump_block(last_block, _("Last block written"));
2348 dump_block(block, _("Block not written"));
2351 eot_block = block->BlockNumber;
2352 eot_block_len = block->block_len;
2353 eot_FileIndex = file_index;
2357 now -= jcr->run_time;
2359 now = 1; /* don't divide by zero */
2361 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2362 vol_size = dev->VolCatInfo.VolCatBytes;
2363 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2364 dev->file, dev->block_num,
2365 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2368 stop = -1; /* stop, but do simplified test */
2370 /* Full test in progress */
2371 if (!fixup_device_block_write_error(jcr->dcr)) {
2372 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2377 BlockNumber = 0; /* start counting for second tape */
2380 return 1; /* end of tape reached */
2383 /* Save contents after write so that the header is serialized */
2384 memcpy(this_block->buf, block->buf, this_block->buf_len);
2387 * Note, we always read/write to block, but we toggle
2388 * copying it to one or another of two allocated blocks.
2389 * Switch blocks so that the block just successfully written is
2390 * always in last_block.
2392 tblock = last_block;
2393 last_block = this_block;
2394 this_block = tblock;
2395 last_file = this_file;
2396 last_block_num = this_block_num;
2404 * First we label the tape, then we fill
2405 * it with data get a new tape and write a few blocks.
2407 static void qfillcmd()
2409 DEV_BLOCK *block = dcr->block;
2410 DEV_RECORD *rec = dcr->rec;
2413 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2415 get_cmd(_("How many blocks do you want to write? (1000): "));
2422 sm_check(__FILE__, __LINE__, false);
2424 i = block->buf_len - 100;
2426 rec->data = check_pool_memory_size(rec->data, i);
2427 memset(rec->data, i & 0xFF, i);
2430 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2431 for (i=0; i < count; i++) {
2436 if (!write_record_to_block(block, rec)) {
2437 Pmsg0(0, _("Error writing record to block.\n"));
2440 if (!write_block_to_dev(dcr)) {
2441 Pmsg0(0, _("Error writing block to device.\n"));
2447 if (dev_cap(dev, CAP_TWOEOF)) {
2454 sm_check(__FILE__, __LINE__, false);
2458 * Fill a tape using raw write() command
2460 static void rawfill_cmd()
2462 DEV_BLOCK *block = dcr->block;
2465 uint32_t block_num = 0;
2470 fd = open("/dev/urandom", O_RDONLY);
2472 read(fd, block->buf, block->buf_len);
2475 uint32_t *p = (uint32_t *)block->buf;
2476 srandom(time(NULL));
2477 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2481 p = (uint32_t *)block->buf;
2482 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2485 if (dev->is_tape()) {
2486 stat = tape_write(dev->fd, block->buf, block->buf_len);
2488 stat = write(dev->fd, block->buf, block->buf_len);
2490 if (stat == (int)block->buf_len) {
2491 if ((block_num++ % 100) == 0) {
2496 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2506 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2507 be.strerror(my_errno));
2513 * Fill a tape using Bacula block writes
2515 static void bfill_cmd()
2517 DEV_BLOCK *block = dcr->block;
2518 uint32_t block_num = 0;
2524 fd = open("/dev/urandom", O_RDONLY);
2526 read(fd, block->buf, block->buf_len);
2529 uint32_t *p = (uint32_t *)block->buf;
2530 srandom(time(NULL));
2531 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2535 p = (uint32_t *)block->buf;
2536 Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2539 block->binbuf = block->buf_len;
2540 block->bufp = block->buf + block->binbuf;
2541 if (!write_block_to_dev(dcr)) {
2544 if ((block_num++ % 100) == 0) {
2549 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2555 printf(_("Write failed at block %u.\n"), block_num);
2560 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2561 static struct cmdstruct commands[] = {
2562 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2563 {NT_("bsf"), bsfcmd, _("backspace file")},
2564 {NT_("bsr"), bsrcmd, _("backspace record")},
2565 {NT_("bfill"), bfill_cmd, _("fill tape using Bacula writes")},
2566 {NT_("cap"), capcmd, _("list device capabilities")},
2567 {NT_("clear"), clearcmd, _("clear tape errors")},
2568 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2569 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2570 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2571 {NT_("unfill"), unfillcmd, _("read filled tape")},
2572 {NT_("fsf"), fsfcmd, _("forward space a file")},
2573 {NT_("fsr"), fsrcmd, _("forward space a record")},
2574 {NT_("help"), helpcmd, _("print this command")},
2575 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2576 {NT_("load"), loadcmd, _("load a tape")},
2577 {NT_("quit"), quitcmd, _("quit btape")},
2578 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2579 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2580 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2581 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2582 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2583 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2584 {NT_("status"), statcmd, _("print tape status")},
2585 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2586 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2587 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2588 {NT_("rr"), rrcmd, _("read a single record")},
2589 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2590 {NT_("qfill"), qfillcmd, _("quick fill command")}
2592 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2600 while (!quit && get_cmd("*")) {
2601 sm_check(__FILE__, __LINE__, false);
2603 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2604 for (i=0; i<comsize; i++) /* search for command */
2605 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2606 (*commands[i].func)(); /* go execute command */
2611 Pmsg1(0, _("\"%s\" is an illegal command\n"), cmd);
2616 static void helpcmd()
2620 printf(_("Interactive commands:\n"));
2621 printf(_(" Command Description\n ======= ===========\n"));
2622 for (i=0; i<comsize; i++)
2623 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2630 "Copyright (C) 2000-%s Kern Sibbald.\n"
2631 "\nVersion: %s (%s)\n\n"
2632 "Usage: btape <options> <device_name>\n"
2633 " -b <file> specify bootstrap file\n"
2634 " -c <file> set configuration file to file\n"
2635 " -d <nn> set debug level to nn\n"
2636 " -p proceed inspite of I/O errors\n"
2637 " -s turn off signals\n"
2639 " -? print this message.\n"
2640 "\n"), BYEAR, VERSION, BDATE);
2645 * Get next input command from terminal. This
2646 * routine is REALLY primitive, and should be enhanced
2647 * to have correct backspacing, etc.
2650 get_cmd(const char *prompt)
2654 fprintf(stdout, prompt);
2656 /* We really should turn off echoing and pretty this
2660 while ((ch = fgetc(stdin)) != EOF) {
2662 strip_trailing_junk(cmd);
2664 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2677 /* Dummies to replace askdir.c */
2678 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2679 bool dir_send_job_status(JCR *jcr) {return 1;}
2681 bool dir_update_volume_info(DCR *dcr, bool relabel)
2687 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2689 Dmsg0(20, "Enter dir_get_volume_info\n");
2690 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2694 bool dir_create_jobmedia_record(DCR *dcr)
2696 dcr->WroteVol = false;
2701 bool dir_find_next_appendable_volume(DCR *dcr)
2703 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2704 return dcr->VolumeName[0] != 0;
2707 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2709 DEVICE *dev = dcr->dev;
2710 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2711 if (dcr->VolumeName[0] == 0) {
2712 return dir_ask_sysop_to_create_appendable_volume(dcr);
2714 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2715 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2716 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2719 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2720 dcr->VolumeName, dev->print_name());
2727 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2730 DEVICE *dev = dcr->dev;
2731 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2733 set_volume_name("TestVolume1", 1);
2735 set_volume_name("TestVolume2", 2);
2737 /* Close device so user can use autochanger if desired */
2738 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2741 autochanger = autoload_device(dcr, 1, NULL);
2742 if (autochanger != 1) {
2743 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2754 static bool my_mount_next_read_volume(DCR *dcr)
2757 JCR *jcr = dcr->jcr;
2758 DEV_BLOCK *block = dcr->block;
2760 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2761 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2764 if (LastBlock != block->BlockNumber) {
2765 VolBytes += block->block_len;
2767 LastBlock = block->BlockNumber;
2769 now -= jcr->run_time;
2773 kbs = (double)VolBytes / (1000.0 * (double)now);
2774 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2775 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2777 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2782 set_volume_name("TestVolume2", 2);
2785 if (!acquire_device_for_read(dcr)) {
2786 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2789 return true; /* next volume mounted */
2792 static void set_volume_name(const char *VolName, int volnum)
2794 DCR *dcr = jcr->dcr;
2795 VolumeName = VolName;
2797 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2798 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2799 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2800 dcr->VolCatInfo.Slot = volnum;
2801 dcr->VolCatInfo.InChanger = true;