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(off_t) < 8) {
167 Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. off_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());
388 write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
389 Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
393 * Read the tape label
395 static void readlabelcmd()
397 int save_debug_level = debug_level;
400 stat = read_dev_volume_label(dcr);
403 Pmsg0(0, _("Volume has no label.\n"));
406 Pmsg0(0, _("Volume label read correctly.\n"));
409 Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
412 Pmsg0(0, _("Volume name error\n"));
414 case VOL_CREATE_ERROR:
415 Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
417 case VOL_VERSION_ERROR:
418 Pmsg0(0, _("Volume version error.\n"));
420 case VOL_LABEL_ERROR:
421 Pmsg0(0, _("Bad Volume label type.\n"));
424 Pmsg0(0, _("Unknown error.\n"));
429 dump_volume_label(dev);
430 debug_level = save_debug_level;
435 * Load the tape should have prevously been taken
436 * off line, otherwise this command is not necessary.
438 static void loadcmd()
441 if (!load_dev(dev)) {
442 Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
444 Pmsg1(0, _("Loaded %s\n"), dev->print_name());
450 static void rewindcmd()
452 if (!dev->rewind(dcr)) {
453 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
456 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
461 * Clear any tape error
463 static void clearcmd()
469 * Write and end of file on the tape
471 static void weofcmd()
481 if (!dev->weof(num)) {
482 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
486 Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
489 Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
495 /* Go to the end of the medium -- raw command
496 * The idea was orginally that the end of the Bacula
497 * medium would be flagged differently. This is not
498 * currently the case. So, this is identical to the
503 if (!dev->eod(dcr)) {
504 Pmsg1(0, "%s", dev->bstrerror());
507 Pmsg0(0, _("Moved to end of medium.\n"));
512 * Go to the end of the medium (either hardware determined
513 * or defined by two eofs.
533 if (!dev->bsf(num)) {
534 Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
536 Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
552 if (!dev->bsr(num)) {
553 Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
555 Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
560 * List device capabilities as defined in the
565 printf(_("Configured device capabilities:\n"));
566 printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
567 printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
568 printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
569 printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
570 printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
571 printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
572 printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
573 printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
574 printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
575 printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
576 printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
577 printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
578 printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
579 printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
580 printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
583 printf(_("Device status:\n"));
584 printf("%sOPENED ", dev->is_open() ? "" : "!");
585 printf("%sTAPE ", dev->is_tape() ? "" : "!");
586 printf("%sLABEL ", dev->is_labeled() ? "" : "!");
587 printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
588 printf("%sAPPEND ", dev->can_append() ? "" : "!");
589 printf("%sREAD ", dev->can_read() ? "" : "!");
590 printf("%sEOT ", dev->at_eot() ? "" : "!");
591 printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
592 printf("%sEOF ", dev->at_eof() ? "" : "!");
593 printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
594 printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
597 printf(_("Device parameters:\n"));
598 printf("Device name: %s\n", dev->dev_name);
599 printf("File=%u block=%u\n", dev->file, dev->block_num);
600 printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
602 printf(_("Status:\n"));
608 * Test writting larger and larger records.
609 * This is a torture test for records.
611 static void rectestcmd()
617 Pmsg0(0, _("Test writting larger and larger records.\n"
618 "This is a torture test for records.\nI am going to write\n"
619 "larger and larger records. It will stop when the record size\n"
620 "plus the header exceeds the block size (by default about 64K)\n"));
623 get_cmd(_("Do you want to continue? (y/n): "));
625 Pmsg0(000, _("Command aborted.\n"));
629 sm_check(__FILE__, __LINE__, false);
630 block = new_block(dev);
633 for (i=1; i<500000; i++) {
634 rec->data = check_pool_memory_size(rec->data, i);
635 memset(rec->data, i & 0xFF, i);
637 sm_check(__FILE__, __LINE__, false);
638 if (write_record_to_block(block, rec)) {
641 Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
645 sm_check(__FILE__, __LINE__, false);
649 sm_check(__FILE__, __LINE__, false);
653 * This test attempts to re-read a block written by Bacula
654 * normally at the end of the tape. Bacula will then back up
655 * over the two eof marks, backup over the record and reread
656 * it to make sure it is valid. Bacula can skip this validation
657 * if you set "Backward space record = no"
659 static int re_read_block_test()
661 DEV_BLOCK *block = dcr->block;
666 if (!(dev->capabilities & CAP_BSR)) {
667 Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
671 Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
672 "I'm going to write three records and an EOF\n"
673 "then backup over the EOF and re-read the last record.\n"
674 "Bacula does this after writing the last block on the\n"
675 "tape to verify that the block was written correctly.\n\n"
676 "This is not an *essential* feature ...\n\n"));
680 rec->data = check_pool_memory_size(rec->data, block->buf_len);
681 len = rec->data_len = block->buf_len-100;
682 memset(rec->data, 1, rec->data_len);
683 if (!write_record_to_block(block, rec)) {
684 Pmsg0(0, _("Error writing record to block.\n"));
687 if (!write_block_to_dev(dcr)) {
688 Pmsg0(0, _("Error writing block to device.\n"));
691 Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
693 memset(rec->data, 2, rec->data_len);
694 if (!write_record_to_block(block, rec)) {
695 Pmsg0(0, _("Error writing record to block.\n"));
698 if (!write_block_to_dev(dcr)) {
699 Pmsg0(0, _("Error writing block to device.\n"));
702 Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
704 memset(rec->data, 3, rec->data_len);
705 if (!write_record_to_block(block, rec)) {
706 Pmsg0(0, _("Error writing record to block.\n"));
709 if (!write_block_to_dev(dcr)) {
710 Pmsg0(0, _("Error writing block to device.\n"));
713 Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
716 if (dev_cap(dev, CAP_TWOEOF)) {
720 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
723 if (dev_cap(dev, CAP_TWOEOF)) {
725 Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
729 Pmsg0(0, _("Backspaced over EOF OK.\n"));
731 Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
734 Pmsg0(0, _("Backspace record OK.\n"));
735 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
737 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
740 memset(rec->data, 0, rec->data_len);
741 if (!read_record_from_block(block, rec)) {
743 Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
746 for (int i=0; i<len; i++) {
747 if (rec->data[i] != 3) {
748 Pmsg0(0, _("Bad data in record. Test failed!\n"));
752 Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
753 Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
760 Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
761 "this function to verify the last block written to the\n"
762 "tape. Bacula will skip the last block verification\n"
764 "Backward Space Record = No\n\n"
765 "to your Storage daemon's Device resource definition.\n"));
772 * This test writes Bacula blocks to the tape in
773 * several files. It then rewinds the tape and attepts
774 * to read these blocks back checking the data.
776 static int write_read_test()
784 Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
785 "I'm going to write 1000 records and an EOF\n"
786 "then write 1000 records and an EOF, then rewind,\n"
787 "and re-read the data to verify that it is correct.\n\n"
788 "This is an *essential* feature ...\n\n"));
791 if (!dev->rewind(dcr)) {
792 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
795 rec->data = check_pool_memory_size(rec->data, block->buf_len);
796 rec->data_len = block->buf_len-100;
797 len = rec->data_len/sizeof(i);
798 for (i=1; i<=1000; i++) {
799 p = (int *)rec->data;
800 for (j=0; j<len; j++) {
803 if (!write_record_to_block(block, rec)) {
804 Pmsg0(0, _("Error writing record to block.\n"));
807 if (!write_block_to_dev(dcr)) {
808 Pmsg0(0, _("Error writing block to device.\n"));
812 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
814 for (i=1001; i<=2000; i++) {
815 p = (int *)rec->data;
816 for (j=0; j<len; j++) {
819 if (!write_record_to_block(block, rec)) {
820 Pmsg0(0, _("Error writing record to block.\n"));
823 if (!write_block_to_dev(dcr)) {
824 Pmsg0(0, _("Error writing block to device.\n"));
828 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
830 if (dev_cap(dev, CAP_TWOEOF)) {
833 if (!dev->rewind(dcr)) {
834 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
837 Pmsg0(0, _("Rewind OK.\n"));
839 for (i=1; i<=2000; i++) {
841 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
843 if (dev_state(dev, ST_EOF)) {
844 Pmsg0(-1, _("Got EOF on tape.\n"));
849 Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
852 memset(rec->data, 0, rec->data_len);
853 if (!read_record_from_block(block, rec)) {
855 Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
858 p = (int *)rec->data;
859 for (j=0; j<len; j++) {
861 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
867 if (i == 1000 || i == 2000) {
868 Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
871 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
880 * This test writes Bacula blocks to the tape in
881 * several files. It then rewinds the tape and attepts
882 * to read these blocks back checking the data.
884 static int position_test()
886 DEV_BLOCK *block = dcr->block;
892 int file = 0, blk = 0;
894 bool got_eof = false;
896 Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
897 "I'm going to write 1000 records and an EOF\n"
898 "then write 1000 records and an EOF, then rewind,\n"
899 "and position to a few blocks and verify that it is correct.\n\n"
900 "This is an *essential* feature ...\n\n"));
903 if (!dev->rewind(dcr)) {
904 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
907 rec->data = check_pool_memory_size(rec->data, block->buf_len);
908 rec->data_len = block->buf_len-100;
909 len = rec->data_len/sizeof(i);
910 for (i=1; i<=1000; i++) {
911 p = (int *)rec->data;
912 for (j=0; j<len; j++) {
915 if (!write_record_to_block(block, rec)) {
916 Pmsg0(0, _("Error writing record to block.\n"));
919 if (!write_block_to_dev(dcr)) {
920 Pmsg0(0, _("Error writing block to device.\n"));
924 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
926 for (i=1001; i<=2000; i++) {
927 p = (int *)rec->data;
928 for (j=0; j<len; j++) {
931 if (!write_record_to_block(block, rec)) {
932 Pmsg0(0, _("Error writing record to block.\n"));
935 if (!write_block_to_dev(dcr)) {
936 Pmsg0(0, _("Error writing block to device.\n"));
940 Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
942 if (dev_cap(dev, CAP_TWOEOF)) {
945 if (!dev->rewind(dcr)) {
946 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
949 Pmsg0(0, _("Rewind OK.\n"));
953 /* Set up next item to read based on where we are */
989 Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
990 if (!dev->reposition(dcr, file, blk)) {
991 Pmsg0(0, _("Reposition error.\n"));
995 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
997 if (dev_state(dev, ST_EOF)) {
998 Pmsg0(-1, _("Got EOF on tape.\n"));
1004 Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1005 recno, file, blk, be.strerror(dev->dev_errno));
1006 Pmsg0(0, _("This may be because the tape drive block size is not\n"
1007 " set to variable blocking as normally used by Bacula.\n"
1008 " Please see the Tape Testing chapter in the manual and \n"
1009 " look for using mt with defblksize and setoptions\n"
1010 "If your tape drive block size is correct, then perhaps\n"
1011 " your SCSI driver is *really* stupid and does not\n"
1012 " correctly report the file:block after a FSF. In this\n"
1013 " case try setting:\n"
1014 " Fast Forward Space File = no\n"
1015 " in your Device resource.\n"));
1019 memset(rec->data, 0, rec->data_len);
1020 if (!read_record_from_block(block, rec)) {
1022 Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1025 p = (int *)rec->data;
1026 for (j=0; j<len; j++) {
1027 if (p[j] != recno) {
1028 Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1033 Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1035 Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1047 * This test writes some records, then writes an end of file,
1048 * rewinds the tape, moves to the end of the data and attepts
1049 * to append to the tape. This function is essential for
1050 * Bacula to be able to write multiple jobs to the tape.
1052 static int append_test()
1054 Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1055 "This test is essential to Bacula.\n\n"
1056 "I'm going to write one record in file 0,\n"
1057 " two records in file 1,\n"
1058 " and three records in file 2\n\n"));
1062 weofcmd(); /* end file 0 */
1065 weofcmd(); /* end file 1 */
1069 weofcmd(); /* end file 2 */
1070 if (dev_cap(dev, CAP_TWOEOF)) {
1073 dev->close(); /* release device */
1074 if (!open_the_device()) {
1078 Pmsg0(0, _("Now moving to end of medium.\n"));
1080 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1081 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1083 if (dev->file != 3) {
1087 Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1090 if (dev_cap(dev, CAP_TWOEOF)) {
1094 Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1095 Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1097 Pmsg0(-1, _("End scanning the tape.\n"));
1098 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1099 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1101 if (dev->file != 4) {
1109 * This test exercises the autochanger
1111 static int autochanger_test()
1113 POOLMEM *results, *changer;
1114 int slot, status, loaded;
1115 int timeout = dcr->device->max_changer_wait;
1118 Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1119 if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1122 if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1123 Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1127 Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1128 "To test the autochanger you must have a blank tape\n"
1129 " that I can write on in Slot 1.\n"));
1130 if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1133 if (cmd[0] != 'y' && cmd[0] != 'Y') {
1137 Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1139 results = get_pool_memory(PM_MESSAGE);
1140 changer = get_pool_memory(PM_FNAME);
1144 dcr->VolCatInfo.Slot = slot;
1145 /* Find out what is loaded, zero means device is unloaded */
1146 Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1147 changer = edit_device_codes(dcr, changer,
1148 dcr->device->changer_command, "loaded");
1149 status = run_program(changer, timeout, results);
1150 Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1152 loaded = atoi(results);
1155 Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1156 Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1160 Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1162 Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1164 Dmsg1(100, "Results from loaded query=%s\n", results);
1166 dcr->VolCatInfo.Slot = loaded;
1167 /* We are going to load a new tape, so close the device */
1169 Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1170 loaded, dev->drive_index);
1171 changer = edit_device_codes(dcr, changer,
1172 dcr->device->changer_command, "unload");
1173 status = run_program(changer, timeout, results);
1174 Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1177 Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1178 Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1187 dcr->VolCatInfo.Slot = slot;
1188 Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1189 slot, dev->drive_index);
1190 changer = edit_device_codes(dcr, changer,
1191 dcr->device->changer_command, "load");
1192 Dmsg1(100, "Changer=%s\n", changer);
1194 status = run_program(changer, timeout, results);
1196 Pmsg2(-1, _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1197 slot, dev->drive_index);
1200 Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1201 Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1205 if (!open_the_device()) {
1209 * Start with sleep_time 0 then increment by 30 seconds if we get
1212 bmicrosleep(sleep_time, 0);
1213 if (!dev->rewind(dcr) || !dev->weof(1)) {
1214 Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1216 Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1217 "a longer sleep time in the mtx-script in the load) case.\n"
1218 "Adding a 30 second sleep and trying again ...\n"));
1222 Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1225 if (!dev->weof(1)) {
1226 Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1229 Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1233 Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1235 "to your mtx-changer script in the load) case.\n\n"),
1238 Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1241 free_pool_memory(changer);
1242 free_pool_memory(results);
1247 free_pool_memory(changer);
1248 free_pool_memory(results);
1249 Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1253 static void autochangercmd()
1260 * This test assumes that the append test has been done,
1261 * then it tests the fsf function.
1263 static int fsf_test()
1265 bool set_off = false;
1267 Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1268 "This test is essential to Bacula.\n\n"
1269 "I'm going to write five files then test forward spacing\n\n"));
1273 weofcmd(); /* end file 0 */
1276 weofcmd(); /* end file 1 */
1280 weofcmd(); /* end file 2 */
1283 weofcmd(); /* end file 3 */
1285 weofcmd(); /* end file 4 */
1286 if (dev_cap(dev, CAP_TWOEOF)) {
1292 Pmsg0(0, _("Now forward spacing 1 file.\n"));
1294 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1297 Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1298 dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1300 if (dev->file != 1) {
1304 Pmsg0(0, _("Now forward spacing 2 files.\n"));
1306 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1309 Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1310 dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1312 if (dev->file != 3) {
1317 Pmsg0(0, _("Now forward spacing 4 files.\n"));
1319 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1322 Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1323 dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1325 if (dev->file != 4) {
1329 Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1330 " Fast Forward Space File = no\n\n"
1331 "to your Device resource for this drive.\n"));
1335 Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1337 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1339 Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1340 dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1341 if (dev->file != 5) {
1344 Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1348 Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1349 if (dev_cap(dev, CAP_FASTFSF)) {
1350 Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1351 "I am turning it off then retrying the test.\n"));
1352 dev->capabilities &= ~CAP_FASTFSF;
1356 Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1357 "Some systems, e.g. OpenBSD, require you to set\n"
1358 " Use MTIOCGET= no\n"
1359 "in your device resource. Use with caution.\n"));
1368 * This is a general test of Bacula's functions
1369 * needed to read and write the tape.
1371 static void testcmd()
1375 if (!write_read_test()) {
1378 if (!position_test()) {
1382 stat = append_test();
1383 if (stat == 1) { /* OK get out */
1386 if (stat == -1) { /* first test failed */
1387 if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1388 Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1389 "Setting \"Hardware End of Medium = no\n"
1390 " and \"Fast Forward Space File = no\n"
1391 "and retrying append test.\n\n"));
1392 dev->capabilities &= ~CAP_EOM; /* turn off eom */
1393 dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1394 stat = append_test();
1396 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1397 " Hardware End of Medium = No\n\n"
1398 " Fast Forward Space File = No\n"
1399 "to your Device resource in the Storage conf file.\n"));
1403 Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1406 /* Wrong count after append */
1408 Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1409 "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1410 dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1411 stat = append_test();
1413 Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1414 " Hardware End of Medium = No\n"
1415 " Fast Forward Space File = No\n"
1416 " BSF at EOM = yes\n\n"
1417 "to your Device resource in the Storage conf file.\n"));
1424 Pmsg0(-1, _("\nAppend test failed.\n\n"
1425 "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1426 "Unable to correct the problem. You MUST fix this\n"
1427 "problem before Bacula can use your tape drive correctly\n"
1428 "\nPerhaps running Bacula in fixed block mode will work.\n"
1429 "Do so by setting:\n\n"
1430 "Minimum Block Size = nnn\n"
1431 "Maximum Block Size = nnn\n\n"
1432 "in your Storage daemon's Device definition.\n"
1433 "nnn must match your tape driver's block size, which\n"
1434 "can be determined by reading your tape manufacturers\n"
1435 "information, and the information on your kernel dirver.\n"
1436 "Fixed block sizes, however, are not normally an ideal solution.\n"
1438 "Some systems, e.g. OpenBSD, require you to set\n"
1439 " Use MTIOCGET= no\n"
1440 "in your device resource. Use with caution.\n"));
1445 Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1446 "Please double check it ...\n"
1447 "=== Sample correct output ===\n"
1448 "1 block of 64448 bytes in file 1\n"
1449 "End of File mark.\n"
1450 "2 blocks of 64448 bytes in file 2\n"
1451 "End of File mark.\n"
1452 "3 blocks of 64448 bytes in file 3\n"
1453 "End of File mark.\n"
1454 "1 block of 64448 bytes in file 4\n"
1455 "End of File mark.\n"
1456 "Total files=4, blocks=7, bytes = 451,136\n"
1457 "=== End sample correct output ===\n\n"
1458 "If the above scan output is not identical to the\n"
1459 "sample output, you MUST correct the problem\n"
1460 "or Bacula will not be able to write multiple Jobs to \n"
1464 re_read_block_test();
1467 fsf_test(); /* do fast forward space file test */
1469 autochanger_test(); /* do autochanger test */
1473 /* Forward space a file */
1474 static void fsfcmd()
1478 num = atoi(argk[1]);
1483 if (!dev->fsf(num)) {
1484 Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1488 Pmsg0(0, _("Forward spaced 1 file.\n"));
1491 Pmsg1(0, _("Forward spaced %d files.\n"), num);
1495 /* Forward space a record */
1496 static void fsrcmd()
1500 num = atoi(argk[1]);
1505 if (!dev->fsr(num)) {
1506 Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1510 Pmsg0(0, _("Forward spaced 1 record.\n"));
1513 Pmsg1(0, _("Forward spaced %d records.\n"), num);
1518 * Read a Bacula block from the tape
1522 dev->open(dcr, OPEN_READ_ONLY);
1523 read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1527 * Write a Bacula block to the tape
1531 DEV_BLOCK *block = dcr->block;
1532 DEV_RECORD *rec = dcr->rec;
1536 sm_check(__FILE__, __LINE__, false);
1539 dump_block(block, "test");
1542 i = block->buf_len - 100;
1544 rec->data = check_pool_memory_size(rec->data, i);
1545 memset(rec->data, i & 0xFF, i);
1547 sm_check(__FILE__, __LINE__, false);
1548 if (!write_record_to_block(block, rec)) {
1549 Pmsg0(0, _("Error writing record to block.\n"));
1552 if (!write_block_to_dev(dcr)) {
1553 Pmsg0(0, _("Error writing block to device.\n"));
1556 Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1558 Pmsg0(0, _("Wrote block to device.\n"));
1561 sm_check(__FILE__, __LINE__, false);
1562 sm_check(__FILE__, __LINE__, false);
1566 * Read a record from the tape
1573 if (!get_cmd(_("Enter length to read: "))) {
1577 if (len < 0 || len > 1000000) {
1578 Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1581 buf = (char *)malloc(len);
1582 stat = read(dev->fd, buf, len);
1583 if (stat > 0 && stat <= len) {
1587 Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1588 len, stat, be.strerror());
1594 * Scan tape by reading block by block. Report what is
1595 * on the tape. Note, this command does raw reads, and as such
1596 * will not work with fixed block size devices.
1598 static void scancmd()
1601 int blocks, tot_blocks, tot_files;
1607 blocks = block_size = tot_blocks = 0;
1609 if (dev->state & ST_EOT) {
1610 Pmsg0(0, _("End of tape\n"));
1613 dev->update_pos(dcr);
1614 tot_files = dev->file;
1615 Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1617 if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1620 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1621 dev->dev_name, be.strerror());
1622 Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1625 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1628 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1633 Dmsg1(200, "read status = %d\n", stat);
1635 if (stat != block_size) {
1636 dev->update_pos(dcr);
1639 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1642 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1648 if (stat == 0) { /* EOF */
1649 dev->update_pos(dcr);
1650 printf(_("End of File mark.\n"));
1651 /* Two reads of zero means end of tape */
1652 if (dev->state & ST_EOF)
1653 dev->state |= ST_EOT;
1655 dev->state |= ST_EOF;
1658 if (dev->state & ST_EOT) {
1659 printf(_("End of tape\n"));
1662 } else { /* Got data */
1663 dev->state &= ~ST_EOF;
1669 dev->update_pos(dcr);
1670 tot_files = dev->file - tot_files;
1671 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1672 edit_uint64_with_commas(bytes, ec1));
1677 * Scan tape by reading Bacula block by block. Report what is
1678 * on the tape. This function reads Bacula blocks, so if your
1679 * Device resource is correctly defined, it should work with
1680 * either variable or fixed block sizes.
1682 static void scan_blocks()
1684 int blocks, tot_blocks, tot_files;
1685 uint32_t block_size;
1687 DEV_BLOCK *block = dcr->block;
1689 char buf1[100], buf2[100];
1691 blocks = block_size = tot_blocks = 0;
1695 dev->update_pos(dcr);
1696 tot_files = dev->file;
1698 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1699 Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1700 if (dev->state & ST_EOT) {
1703 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1706 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1712 if (dev->state & ST_EOF) {
1715 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1718 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1722 printf(_("End of File mark.\n"));
1725 if (dev->state & ST_SHORT) {
1728 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1731 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1735 printf(_("Short block read.\n"));
1738 printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1741 if (block->block_len != block_size) {
1744 printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1747 printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1751 block_size = block->block_len;
1755 bytes += block->block_len;
1756 Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1757 block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1758 block->VolSessionId, block->VolSessionTime);
1760 DEV_RECORD *rec = new_record();
1761 read_record_from_block(block, rec);
1762 Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1763 block->BlockNumber, dev->block_num, block->block_len,
1764 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1765 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1768 } else if (verbose > 1) {
1769 dump_block(block, "");
1774 tot_files = dev->file - tot_files;
1775 printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1776 edit_uint64_with_commas(bytes, ec1));
1780 static void statcmd()
1782 int debug = debug_level;
1784 Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1786 dump_volume_label(dev);
1788 debug_level = debug;
1793 * First we label the tape, then we fill
1794 * it with data get a new tape and write a few blocks.
1796 static void fillcmd()
1799 DEV_BLOCK *block = dcr->block;
1801 char buf1[100], buf2[100];
1804 uint32_t min_block_size;
1815 "This command simulates Bacula writing to a tape.\n"
1816 "It requires either one or two blank tapes, which it\n"
1817 "will label and write.\n\n"
1818 "If you have an autochanger configured, it will use\n"
1819 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1820 "be prompted to insert the tapes when necessary.\n\n"
1821 "It will print a status approximately\n"
1822 "every 322 MB, and write an EOF every 3.2 GB. If you have\n"
1823 "selected the simple test option, after writing the first tape\n"
1824 "it will rewind it and re-read the last block written.\n\n"
1825 "If you have selected the multiple tape test, when the first tape\n"
1826 "fills, it will ask for a second, and after writing a few more \n"
1827 "blocks, it will stop. Then it will begin re-reading the\n"
1829 "This may take a long time -- hours! ...\n\n"));
1831 get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1832 "or the complete multiple tape (m) test: (s/m) "));
1833 if (cmd[0] == 's') {
1834 Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1836 } else if (cmd[0] == 'm') {
1837 Pmsg0(-1, _("Multiple tape test selected.\n"));
1840 Pmsg0(000, _("Command aborted.\n"));
1844 Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1845 Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1847 /* Use fixed block size to simplify read back */
1848 min_block_size = dev->min_block_size;
1849 dev->min_block_size = dev->max_block_size;
1850 set_volume_name("TestVolume1", 1);
1852 if (!dev->rewind(dcr)) {
1853 Pmsg0(000, _("Rewind failed.\n"));
1855 if (!dev->weof(1)) {
1856 Pmsg0(000, _("Write EOF failed.\n"));
1859 dev->set_append(); /* force volume to be relabeled */
1862 * Acquire output device for writing. Note, after acquiring a
1863 * device, we MUST release it, which is done at the end of this
1866 Dmsg0(100, "just before acquire_device\n");
1867 if (!acquire_device_for_append(dcr)) {
1868 set_jcr_job_status(jcr, JS_ErrorTerminated);
1871 block = jcr->dcr->block;
1873 Dmsg0(100, "Just after acquire_device_for_append\n");
1875 * Write Begin Session Record
1877 if (!write_session_label(dcr, SOS_LABEL)) {
1878 set_jcr_job_status(jcr, JS_ErrorTerminated);
1879 Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1883 Pmsg0(-1, _("Wrote Start of Session label.\n"));
1885 memset(&rec, 0, sizeof(rec));
1886 rec.data = get_memory(100000); /* max record size */
1888 #define REC_SIZE 32768
1889 rec.data_len = REC_SIZE;
1892 * Put some random data in the record
1894 fd = open("/dev/urandom", O_RDONLY);
1896 read(fd, rec.data, rec.data_len);
1899 uint32_t *p = (uint32_t *)rec.data;
1900 srandom(time(NULL));
1901 for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1907 * Generate data as if from File daemon, write to device
1909 jcr->dcr->VolFirstIndex = 0;
1910 time(&jcr->run_time); /* start counting time for rates */
1911 (void)localtime_r(&jcr->run_time, &tm);
1912 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1914 Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1916 Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1918 for (file_index = 0; ok && !job_canceled(jcr); ) {
1919 rec.VolSessionId = jcr->VolSessionId;
1920 rec.VolSessionTime = jcr->VolSessionTime;
1921 rec.FileIndex = ++file_index;
1922 rec.Stream = STREAM_FILE_DATA;
1924 /* Mix up the data just a bit */
1925 uint32_t *lp = (uint32_t *)rec.data;
1927 for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1931 Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1932 rec.FileIndex, rec.VolSessionId,
1933 stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1936 while (!write_record_to_block(block, &rec)) {
1938 * When we get here we have just filled a block
1940 Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1943 /* Write block to tape */
1944 if (!flush_block(block, 1)) {
1948 /* Every 5000 blocks (approx 322MB) report where we are.
1950 if ((block->BlockNumber % 5000) == 0) {
1952 now -= jcr->run_time;
1954 now = 1; /* prevent divide error */
1956 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1957 Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1958 block->BlockNumber, dev->block_num,
1959 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1961 /* Every 32000 blocks (approx 2GB) write an EOF.
1963 if ((block->BlockNumber % 32000) == 0) {
1965 (void)localtime_r(&now, &tm);
1966 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1967 Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1968 flush_block(block, 0);
1972 /* Get out after writing 10 blocks to the second tape */
1973 if (++BlockNumber > 10 && stop != 0) { /* get out */
1978 Pmsg0(000, _("Not OK\n"));
1981 jcr->JobBytes += rec.data_len; /* increment bytes this job */
1982 Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1983 FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1984 stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1986 /* Get out after writing 10 blocks to the second tape */
1987 if (BlockNumber > 10 && stop != 0) { /* get out */
1989 Pmsg1(-1, "Done writing %s records ...\n",
1990 edit_uint64_with_commas(write_count, ed1));
1995 Dmsg0(100, "Write_end_session_label()\n");
1996 /* Create Job status for end of session label */
1997 if (!job_canceled(jcr) && ok) {
1998 set_jcr_job_status(jcr, JS_Terminated);
2000 set_jcr_job_status(jcr, JS_ErrorTerminated);
2002 if (!write_session_label(dcr, EOS_LABEL)) {
2003 Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2006 /* Write out final block of this session */
2007 if (!write_block_to_device(dcr)) {
2008 Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2011 Pmsg0(-1, _("Wrote End of Session label.\n"));
2013 /* Save last block info for second tape */
2014 last_block_num2 = last_block_num;
2015 last_file2 = last_file;
2017 free_block(last_block2);
2019 last_block2 = dup_block(last_block);
2022 sprintf(buf, "%s/btape.state", working_directory);
2023 fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2025 write(fd, &btape_state_level, sizeof(btape_state_level));
2026 write(fd, &simple, sizeof(simple));
2027 write(fd, &last_block_num1, sizeof(last_block_num1));
2028 write(fd, &last_block_num2, sizeof(last_block_num2));
2029 write(fd, &last_file1, sizeof(last_file1));
2030 write(fd, &last_file2, sizeof(last_file2));
2031 write(fd, last_block1->buf, last_block1->buf_len);
2032 write(fd, last_block2->buf, last_block2->buf_len);
2033 write(fd, first_block->buf, first_block->buf_len);
2035 Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2036 last_block_num1, last_block_num2);
2039 Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2044 (void)localtime_r(&now, &tm);
2045 strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2047 Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2048 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2051 Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2052 buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2055 jcr->dcr->block = block;
2058 dev->min_block_size = min_block_size;
2059 free_memory(rec.data);
2063 * Read two tapes written by the "fill" command and ensure
2064 * that the data is valid. If stop==1 we simulate full read back
2065 * of two tapes. If stop==-1 we simply read the last block and
2066 * verify that it is correct.
2068 static void unfillcmd()
2072 last_block1 = new_block(dev);
2073 last_block2 = new_block(dev);
2074 first_block = new_block(dev);
2075 sprintf(buf, "%s/btape.state", working_directory);
2076 fd = open(buf, O_RDONLY);
2078 uint32_t state_level;
2079 read(fd, &state_level, sizeof(btape_state_level));
2080 read(fd, &simple, sizeof(simple));
2081 read(fd, &last_block_num1, sizeof(last_block_num1));
2082 read(fd, &last_block_num2, sizeof(last_block_num2));
2083 read(fd, &last_file1, sizeof(last_file1));
2084 read(fd, &last_file2, sizeof(last_file2));
2085 read(fd, last_block1->buf, last_block1->buf_len);
2086 read(fd, last_block2->buf, last_block2->buf_len);
2087 read(fd, first_block->buf, first_block->buf_len);
2089 if (state_level != btape_state_level) {
2090 Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2091 "the fill command.\n"));
2096 Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2097 "You must redo the fill command.\n"), buf, be.strerror());
2104 static void do_unfill()
2106 DEV_BLOCK *block = dcr->block;
2113 Dmsg0(20, "Enter do_unfill\n");
2114 dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2115 dev->capabilities &= ~CAP_LABEL; /* don't label anything here */
2119 time(&jcr->run_time); /* start counting time for rates */
2123 free_block(last_block);
2126 last_block_num = last_block_num1;
2127 last_file = last_file1;
2128 last_block = last_block1;
2131 /* Multiple Volume tape */
2132 /* Close device so user can use autochanger if desired */
2133 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2136 autochanger = autoload_device(dcr, 1, NULL);
2139 get_cmd(_("Mount first tape. Press enter when ready: "));
2143 free_restore_volume_list(jcr);
2144 jcr->dcr = new_dcr(jcr, dev);
2145 set_volume_name("TestVolume1", 1);
2147 create_restore_volume_list(jcr);
2149 dev->num_writers = 0;
2150 if (!acquire_device_for_read(dcr)) {
2151 Pmsg1(-1, "%s", dev->errmsg);
2155 * We now have the first tape mounted.
2156 * Note, re-reading last block may have caused us to
2157 * loose track of where we are (block number unknown).
2159 Pmsg0(-1, _("Rewinding.\n"));
2160 if (!dev->rewind(dcr)) { /* get to a known place on tape */
2163 /* Read the first 10000 records */
2164 Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2165 dev->file, dev->block_num);
2167 read_records(dcr, quickie_cb, my_mount_next_read_volume);
2168 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2169 last_file, last_block_num);
2170 if (!dev->reposition(dcr, last_file, last_block_num)) {
2171 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2174 Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2175 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2176 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2179 if (compare_blocks(last_block, block)) {
2181 Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2183 Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2190 /* restore info for last block on second Volume */
2191 last_block_num = last_block_num2;
2192 last_file = last_file2;
2193 last_block = last_block2;
2195 /* Multiple Volume tape */
2196 /* Close device so user can use autochanger if desired */
2197 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2201 free_restore_volume_list(jcr);
2202 set_volume_name("TestVolume2", 2);
2204 create_restore_volume_list(jcr);
2205 autochanger = autoload_device(dcr, 1, NULL);
2208 get_cmd(_("Mount second tape. Press enter when ready: "));
2212 if (!acquire_device_for_read(dcr)) {
2213 Pmsg1(-1, "%s", dev->errmsg);
2217 /* Space to "first" block which is last block not written
2218 * on the previous tape.
2220 Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2221 if (!dev->reposition(dcr, 0, 1)) {
2222 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2225 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2226 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2227 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2230 if (compare_blocks(first_block, block)) {
2231 Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2234 /* Now find and compare the last block */
2235 Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2236 last_file, last_block_num);
2237 if (!dev->reposition(dcr, last_file, last_block_num)) {
2238 Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2241 Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2242 if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2243 Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2246 if (compare_blocks(last_block, block)) {
2247 Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2251 free_block(last_block1);
2252 free_block(last_block2);
2253 free_block(first_block);
2256 /* Read 10000 records then stop */
2257 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2259 DEVICE *dev = dcr->dev;
2261 if (quickie_count == 10000) {
2262 Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2264 return quickie_count < 10000;
2267 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2270 uint32_t CheckSum, block_len;
2273 p = last_block->buf;
2275 unser_begin(q, BLKHDR2_LENGTH);
2276 unser_uint32(CheckSum);
2277 unser_uint32(block_len);
2278 while (q < (block->buf+block_len)) {
2285 dump_block(last_block, _("Last block written"));
2287 dump_block(block, _("Block read back"));
2288 Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2289 Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2290 "that was read back differ. The test FAILED !!!!\n"
2291 "This must be corrected before you use Bacula\n"
2292 "to write multi-tape Volumes.!!!!\n"));
2296 dump_block(last_block, _("Last block written"));
2297 dump_block(block, _("Block read back"));
2307 * Write current block to tape regardless of whether or
2308 * not it is full. If the tape fills, attempt to
2309 * acquire another tape.
2311 static int flush_block(DEV_BLOCK *block, int dump)
2315 uint32_t this_file, this_block_num;
2319 this_block = new_block(dev);
2322 last_block = new_block(dev);
2325 this_file = dev->file;
2326 this_block_num = dev->block_num;
2327 if (!write_block_to_dev(dcr)) {
2328 Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2329 last_file, last_block_num, this_block_num);
2332 * This is 1st tape, so save first tape info separate
2333 * from second tape info
2335 last_block_num1 = last_block_num;
2336 last_file1 = last_file;
2337 last_block1 = dup_block(last_block);
2338 last_block2 = dup_block(last_block);
2339 first_block = dup_block(block); /* first block second tape */
2342 Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2343 (unsigned)file_index, block->BlockNumber, block->block_len);
2344 dump_block(last_block, _("Last block written"));
2346 dump_block(block, _("Block not written"));
2349 eot_block = block->BlockNumber;
2350 eot_block_len = block->block_len;
2351 eot_FileIndex = file_index;
2355 now -= jcr->run_time;
2357 now = 1; /* don't divide by zero */
2359 kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2360 vol_size = dev->VolCatInfo.VolCatBytes;
2361 Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2362 dev->file, dev->block_num,
2363 edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2366 stop = -1; /* stop, but do simplified test */
2368 /* Full test in progress */
2369 if (!fixup_device_block_write_error(jcr->dcr)) {
2370 Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2375 BlockNumber = 0; /* start counting for second tape */
2378 return 1; /* end of tape reached */
2381 /* Save contents after write so that the header is serialized */
2382 memcpy(this_block->buf, block->buf, this_block->buf_len);
2385 * Note, we always read/write to block, but we toggle
2386 * copying it to one or another of two allocated blocks.
2387 * Switch blocks so that the block just successfully written is
2388 * always in last_block.
2390 tblock = last_block;
2391 last_block = this_block;
2392 this_block = tblock;
2393 last_file = this_file;
2394 last_block_num = this_block_num;
2402 * First we label the tape, then we fill
2403 * it with data get a new tape and write a few blocks.
2405 static void qfillcmd()
2407 DEV_BLOCK *block = dcr->block;
2408 DEV_RECORD *rec = dcr->rec;
2411 Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2413 get_cmd(_("How many blocks do you want to write? (1000): "));
2420 sm_check(__FILE__, __LINE__, false);
2422 i = block->buf_len - 100;
2424 rec->data = check_pool_memory_size(rec->data, i);
2425 memset(rec->data, i & 0xFF, i);
2428 Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2429 for (i=0; i < count; i++) {
2434 if (!write_record_to_block(block, rec)) {
2435 Pmsg0(0, _("Error writing record to block.\n"));
2438 if (!write_block_to_dev(dcr)) {
2439 Pmsg0(0, _("Error writing block to device.\n"));
2445 if (dev_cap(dev, CAP_TWOEOF)) {
2452 sm_check(__FILE__, __LINE__, false);
2456 * Fill a tape using raw write() command
2458 static void rawfill_cmd()
2460 DEV_BLOCK *block = dcr->block;
2463 uint32_t block_num = 0;
2468 fd = open("/dev/urandom", O_RDONLY);
2470 read(fd, block->buf, block->buf_len);
2473 uint32_t *p = (uint32_t *)block->buf;
2474 srandom(time(NULL));
2475 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2479 p = (uint32_t *)block->buf;
2480 Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2483 if (dev->is_tape()) {
2484 stat = tape_write(dev->fd, block->buf, block->buf_len);
2486 stat = write(dev->fd, block->buf, block->buf_len);
2488 if (stat == (int)block->buf_len) {
2489 if ((block_num++ % 100) == 0) {
2494 for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2504 printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2505 be.strerror(my_errno));
2511 * Fill a tape using Bacula block writes
2513 static void bfill_cmd()
2515 DEV_BLOCK *block = dcr->block;
2516 uint32_t block_num = 0;
2522 fd = open("/dev/urandom", O_RDONLY);
2524 read(fd, block->buf, block->buf_len);
2527 uint32_t *p = (uint32_t *)block->buf;
2528 srandom(time(NULL));
2529 for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2533 p = (uint32_t *)block->buf;
2534 Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2537 block->binbuf = block->buf_len;
2538 block->bufp = block->buf + block->binbuf;
2539 if (!write_block_to_dev(dcr)) {
2542 if ((block_num++ % 100) == 0) {
2547 for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2553 printf(_("Write failed at block %u.\n"), block_num);
2558 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2559 static struct cmdstruct commands[] = {
2560 {NT_("autochanger"),autochangercmd, _("test autochanger")},
2561 {NT_("bsf"), bsfcmd, _("backspace file")},
2562 {NT_("bsr"), bsrcmd, _("backspace record")},
2563 {NT_("bfill"), bfill_cmd, _("fill tape using Bacula writes")},
2564 {NT_("cap"), capcmd, _("list device capabilities")},
2565 {NT_("clear"), clearcmd, _("clear tape errors")},
2566 {NT_("eod"), eodcmd, _("go to end of Bacula data for append")},
2567 {NT_("eom"), eomcmd, _("go to the physical end of medium")},
2568 {NT_("fill"), fillcmd, _("fill tape, write onto second volume")},
2569 {NT_("unfill"), unfillcmd, _("read filled tape")},
2570 {NT_("fsf"), fsfcmd, _("forward space a file")},
2571 {NT_("fsr"), fsrcmd, _("forward space a record")},
2572 {NT_("help"), helpcmd, _("print this command")},
2573 {NT_("label"), labelcmd, _("write a Bacula label to the tape")},
2574 {NT_("load"), loadcmd, _("load a tape")},
2575 {NT_("quit"), quitcmd, _("quit btape")},
2576 {NT_("rawfill"), rawfill_cmd, _("use write() to fill tape")},
2577 {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2578 {NT_("rectest"), rectestcmd, _("test record handling functions")},
2579 {NT_("rewind"), rewindcmd, _("rewind the tape")},
2580 {NT_("scan"), scancmd, _("read() tape block by block to EOT and report")},
2581 {NT_("scanblocks"),scan_blocks, _("Bacula read block by block to EOT and report")},
2582 {NT_("status"), statcmd, _("print tape status")},
2583 {NT_("test"), testcmd, _("General test Bacula tape functions")},
2584 {NT_("weof"), weofcmd, _("write an EOF on the tape")},
2585 {NT_("wr"), wrcmd, _("write a single Bacula block")},
2586 {NT_("rr"), rrcmd, _("read a single record")},
2587 {NT_("rb"), rbcmd, _("read a single Bacula block")},
2588 {NT_("qfill"), qfillcmd, _("quick fill command")}
2590 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2598 while (!quit && get_cmd("*")) {
2599 sm_check(__FILE__, __LINE__, false);
2601 parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2602 for (i=0; i<comsize; i++) /* search for command */
2603 if (argc > 0 && fstrsch(argk[0], commands[i].key)) {
2604 (*commands[i].func)(); /* go execute command */
2609 Pmsg1(0, _("\"%s\" is an illegal command\n"), cmd);
2614 static void helpcmd()
2618 printf(_("Interactive commands:\n"));
2619 printf(_(" Command Description\n ======= ===========\n"));
2620 for (i=0; i<comsize; i++)
2621 printf(" %-10s %s\n", commands[i].key, commands[i].help);
2628 "Copyright (C) 2000-%s Kern Sibbald.\n"
2629 "\nVersion: %s (%s)\n\n"
2630 "Usage: btape <options> <device_name>\n"
2631 " -b <file> specify bootstrap file\n"
2632 " -c <file> set configuration file to file\n"
2633 " -d <nn> set debug level to nn\n"
2634 " -p proceed inspite of I/O errors\n"
2635 " -s turn off signals\n"
2637 " -? print this message.\n"
2638 "\n"), BYEAR, VERSION, BDATE);
2643 * Get next input command from terminal. This
2644 * routine is REALLY primitive, and should be enhanced
2645 * to have correct backspacing, etc.
2648 get_cmd(const char *prompt)
2652 fprintf(stdout, prompt);
2654 /* We really should turn off echoing and pretty this
2658 while ((ch = fgetc(stdin)) != EOF) {
2660 strip_trailing_junk(cmd);
2662 } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2675 /* Dummies to replace askdir.c */
2676 bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2677 bool dir_send_job_status(JCR *jcr) {return 1;}
2679 bool dir_update_volume_info(DCR *dcr, bool relabel)
2685 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
2687 Dmsg0(20, "Enter dir_get_volume_info\n");
2688 bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2692 bool dir_create_jobmedia_record(DCR *dcr)
2694 dcr->WroteVol = false;
2699 bool dir_find_next_appendable_volume(DCR *dcr)
2701 Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2702 return dcr->VolumeName[0] != 0;
2705 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2707 DEVICE *dev = dcr->dev;
2708 Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2709 if (dcr->VolumeName[0] == 0) {
2710 return dir_ask_sysop_to_create_appendable_volume(dcr);
2712 Pmsg1(-1, "%s", dev->errmsg); /* print reason */
2713 if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2714 fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2717 fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2718 dcr->VolumeName, dev->print_name());
2725 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2728 DEVICE *dev = dcr->dev;
2729 Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2731 set_volume_name("TestVolume1", 1);
2733 set_volume_name("TestVolume2", 2);
2735 /* Close device so user can use autochanger if desired */
2736 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2739 autochanger = autoload_device(dcr, 1, NULL);
2741 fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2753 static bool my_mount_next_read_volume(DCR *dcr)
2756 JCR *jcr = dcr->jcr;
2757 DEV_BLOCK *block = dcr->block;
2759 Dmsg0(20, "Enter my_mount_next_read_volume\n");
2760 Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2763 if (LastBlock != block->BlockNumber) {
2764 VolBytes += block->block_len;
2766 LastBlock = block->BlockNumber;
2768 now -= jcr->run_time;
2772 kbs = (double)VolBytes / (1000.0 * (double)now);
2773 Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2774 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2776 if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2781 free_restore_volume_list(jcr);
2783 set_volume_name("TestVolume2", 2);
2785 create_restore_volume_list(jcr);
2786 if (!acquire_device_for_read(dcr)) {
2787 Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2790 return true; /* next volume mounted */
2793 static void set_volume_name(const char *VolName, int volnum)
2795 DCR *dcr = jcr->dcr;
2796 VolumeName = VolName;
2798 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2799 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2800 bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2801 dcr->VolCatInfo.Slot = volnum;