X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fbtape.c;h=06dc096814113cfc0a6bc0594b956505bf2633db;hb=1c31d780ff8befc9ef13c681d991bf235cb5f735;hp=ca18e1d8026f75edfedefe07ba4e8a31196f70ca;hpb=d14e039674602515d0dc065db5d856f7aea21d43;p=bacula%2Fbacula diff --git a/bacula/src/stored/btape.c b/bacula/src/stored/btape.c index ca18e1d802..06dc096814 100644 --- a/bacula/src/stored/btape.c +++ b/bacula/src/stored/btape.c @@ -45,14 +45,16 @@ int quit = 0; char buf[100000]; int bsize = TAPE_BSIZE; char VolName[MAX_NAME_LENGTH]; +bool forge_on = false; /* * If you change the format of the state file, * increment this value */ -static uint32_t btape_state_level = 1; +static uint32_t btape_state_level = 2; DEVICE *dev = NULL; +DCR *dcr; DEVRES *device = NULL; @@ -70,14 +72,14 @@ static void qfillcmd(); static void statcmd(); static void unfillcmd(); static int flush_block(DEV_BLOCK *block, int dump); -static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec); -static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block); +static bool quickie_cb(DCR *dcr, DEV_RECORD *rec); +static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block); +static bool my_mount_next_read_volume(DCR *dcr); static void scan_blocks(); -static void set_volume_name(char *VolName, int volnum); +static void set_volume_name(const char *VolName, int volnum); static void rawfill_cmd(); static void bfill_cmd(); static bool open_the_device(); -static char *edit_device_codes(JCR *jcr, char *omsg, char *imsg, char *cmd); static void autochangercmd(); static void do_unfill(); @@ -93,10 +95,11 @@ static char *argk[MAX_CMD_ARGS]; static char *argv[MAX_CMD_ARGS]; static int argc; +static int quickie_count = 0; static BSR *bsr = NULL; static int signals = TRUE; -static int ok; -static int stop; +static bool ok; +static int stop = 0; static uint64_t vol_size; static uint64_t VolBytes; static time_t now; @@ -108,22 +111,29 @@ static uint32_t eot_block; static uint32_t eot_block_len; static uint32_t eot_FileIndex; static int dumped = 0; +static DEV_BLOCK *last_block1 = NULL; +static DEV_BLOCK *last_block2 = NULL; static DEV_BLOCK *last_block = NULL; static DEV_BLOCK *this_block = NULL; +static DEV_BLOCK *first_block = NULL; +static uint32_t last_file1 = 0; +static uint32_t last_file2 = 0; static uint32_t last_file = 0; +static uint32_t last_block_num1 = 0; +static uint32_t last_block_num2 = 0; static uint32_t last_block_num = 0; static uint32_t BlockNumber = 0; -static int simple = FALSE; +static bool simple = true; -static char *VolumeName = NULL; -static int vol_num; +static const char *VolumeName = NULL; +static int vol_num = 0; static JCR *jcr = NULL; static void usage(); static void terminate_btape(int sig); -int get_cmd(char *prompt); +int get_cmd(const char *prompt); /********************************************************************* @@ -133,7 +143,10 @@ int get_cmd(char *prompt); */ int main(int margc, char *margv[]) { - int ch; + int ch, i; + uint32_t x32, y32; + uint64_t x64, y64; + char buf[1000]; /* Sanity checks */ if (TAPE_BSIZE % DEV_BSIZE != 0 || TAPE_BSIZE / DEV_BSIZE == 0) { @@ -143,6 +156,26 @@ int main(int margc, char *margv[]) if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) { Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE); } + if (sizeof(off_t) < 8) { + Pmsg1(-1, "\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n", + sizeof(off_t)); + } + x32 = 123456789; + bsnprintf(buf, sizeof(buf), "%u", x32); + i = bsscanf(buf, "%u", &y32); + if (i != 1 || x32 != y32) { + Pmsg3(-1, "32 bit printf/scanf problem. i=%d x32=%u y32=%u\n", i, x32, y32); + exit(1); + } + x64 = 123456789; + x64 = x64 << 32; + x64 += 123456789; + bsnprintf(buf, sizeof(buf), "%" llu, x64); + i = bsscanf(buf, "%llu", &y64); + if (i != 1 || x64 != y64) { + Pmsg3(-1, "64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n", i, x64, y64); + exit(1); + } printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE); @@ -150,7 +183,7 @@ int main(int margc, char *margv[]) my_name_is(margc, margv, "btape"); init_msg(NULL, NULL); - while ((ch = getopt(margc, margv, "b:c:d:sv?")) != -1) { + while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) { switch (ch) { case 'b': /* bootstrap file */ bsr = parse_bsr(NULL, optarg); @@ -171,8 +204,12 @@ int main(int margc, char *margv[]) } break; + case 'p': + forge_on = true; + break; + case 's': - signals = FALSE; + signals = false; break; case 'v': @@ -216,12 +253,15 @@ int main(int margc, char *margv[]) exit(1); } - jcr = setup_jcr("btape", margv[0], bsr, NULL); - dev = setup_to_access_device(jcr, 0); /* acquire for write */ + jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */ + if (!jcr) { + exit(1); + } + dev = jcr->dcr->dev; if (!dev) { exit(1); } - dev->max_volume_size = 0; + dcr = jcr->dcr; if (!open_the_device()) { goto terminate; } @@ -237,7 +277,7 @@ terminate: static void terminate_btape(int stat) { - sm_check(__FILE__, __LINE__, False); + sm_check(__FILE__, __LINE__, false); if (configfile) { free(configfile); } @@ -251,23 +291,20 @@ static void terminate_btape(int stat) cmd = NULL; } - if (dev) { - term_dev(dev); + if (bsr) { + free_bsr(bsr); } - if (debug_level > 10) - print_memory_pool_stats(); - free_jcr(jcr); jcr = NULL; - if (bsr) { - free_bsr(bsr); + if (dev) { + term_dev(dev); } - if (last_block) { - free_block(last_block); - } + if (debug_level > 10) + print_memory_pool_stats(); + if (this_block) { free_block(this_block); } @@ -275,7 +312,7 @@ static void terminate_btape(int stat) term_msg(); close_memory_pool(); /* free memory in pool */ - sm_dump(False); + sm_dump(false); exit(stat); } @@ -286,15 +323,15 @@ static bool open_the_device() block = new_block(dev); lock_device(dev); if (!(dev->state & ST_OPENED)) { - Dmsg1(200, "Opening device %s\n", jcr->VolumeName); - if (open_dev(dev, jcr->VolumeName, READ_WRITE) < 0) { + Dmsg1(200, "Opening device %s\n", dcr->VolumeName); + if (open_dev(dev, dcr->VolumeName, OPEN_READ_WRITE) < 0) { Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg); unlock_device(dev); free_block(block); return false; } } - Dmsg1(000, "open_dev %s OK\n", dev_name(dev)); + Pmsg1(000, "open_dev %s OK\n", dev_name(dev)); unlock_device(dev); free_block(block); return true; @@ -320,11 +357,13 @@ static void labelcmd() } if (!(dev->state & ST_OPENED)) { - if (!open_device(dev)) { + if (!first_open_device(dev)) { Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev)); } } - write_volume_label_to_dev(jcr, jcr->device, cmd, "Default"); + rewind_dev(dev); + write_new_volume_label_to_dev(dcr, cmd, "Default"); + Pmsg1(-1, "Wrote Volume label for volume \"%s\".\n", cmd); } /* @@ -334,41 +373,38 @@ static void readlabelcmd() { int save_debug_level = debug_level; int stat; - DEV_BLOCK *block; - block = new_block(dev); - stat = read_dev_volume_label(jcr, dev, block); + stat = read_dev_volume_label(dcr); switch (stat) { - case VOL_NO_LABEL: - Pmsg0(0, "Volume has no label.\n"); - break; - case VOL_OK: - Pmsg0(0, "Volume label read correctly.\n"); - break; - case VOL_IO_ERROR: - Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev)); - break; - case VOL_NAME_ERROR: - Pmsg0(0, "Volume name error\n"); - break; - case VOL_CREATE_ERROR: - Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev)); - break; - case VOL_VERSION_ERROR: - Pmsg0(0, "Volume version error.\n"); - break; - case VOL_LABEL_ERROR: - Pmsg0(0, "Bad Volume label type.\n"); - break; - default: - Pmsg0(0, "Unknown error.\n"); - break; + case VOL_NO_LABEL: + Pmsg0(0, "Volume has no label.\n"); + break; + case VOL_OK: + Pmsg0(0, "Volume label read correctly.\n"); + break; + case VOL_IO_ERROR: + Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev)); + break; + case VOL_NAME_ERROR: + Pmsg0(0, "Volume name error\n"); + break; + case VOL_CREATE_ERROR: + Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev)); + break; + case VOL_VERSION_ERROR: + Pmsg0(0, "Volume version error.\n"); + break; + case VOL_LABEL_ERROR: + Pmsg0(0, "Bad Volume label type.\n"); + break; + default: + Pmsg0(0, "Unknown error.\n"); + break; } debug_level = 20; dump_volume_label(dev); debug_level = save_debug_level; - free_block(block); } @@ -505,6 +541,7 @@ static void capcmd() printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!"); printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!"); printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!"); + printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!"); printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!"); printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!"); printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!"); @@ -560,7 +597,7 @@ static void rectestcmd() return; } - sm_check(__FILE__, __LINE__, False); + sm_check(__FILE__, __LINE__, false); block = new_block(dev); rec = new_record(); @@ -568,7 +605,7 @@ static void rectestcmd() rec->data = check_pool_memory_size(rec->data, i); memset(rec->data, i & 0xFF, i); rec->data_len = i; - sm_check(__FILE__, __LINE__, False); + sm_check(__FILE__, __LINE__, false); if (write_record_to_block(block, rec)) { empty_block(block); blkno++; @@ -576,11 +613,11 @@ static void rectestcmd() } else { break; } - sm_check(__FILE__, __LINE__, False); + sm_check(__FILE__, __LINE__, false); } free_record(rec); free_block(block); - sm_check(__FILE__, __LINE__, False); + sm_check(__FILE__, __LINE__, false); } /* @@ -592,7 +629,7 @@ static void rectestcmd() */ static int re_read_block_test() { - DEV_BLOCK *block; + DEV_BLOCK *block = dcr->block; DEV_RECORD *rec; int stat = 0; int len; @@ -603,13 +640,12 @@ static int re_read_block_test() } Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n" - "I'm going to write three records and an eof\n" - "then backup over the eof and re-read the last record.\n" + "I'm going to write three records and an EOF\n" + "then backup over the EOF and re-read the last record.\n" "Bacula does this after writing the last block on the\n" - "tape to verify that the block was written correctly.\n" - "It is not an *essential* feature ...\n\n")); + "tape to verify that the block was written correctly.\n\n" + "This is not an *essential* feature ...\n\n")); rewindcmd(); - block = new_block(dev); rec = new_record(); rec->data = check_pool_memory_size(rec->data, block->buf_len); len = rec->data_len = block->buf_len-100; @@ -618,7 +654,7 @@ static int re_read_block_test() Pmsg0(0, _("Error writing record to block.\n")); goto bail_out; } - if (!write_block_to_dev(jcr, dev, block)) { + if (!write_block_to_dev(dcr)) { Pmsg0(0, _("Error writing block to device.\n")); goto bail_out; } else { @@ -629,7 +665,7 @@ static int re_read_block_test() Pmsg0(0, _("Error writing record to block.\n")); goto bail_out; } - if (!write_block_to_dev(jcr, dev, block)) { + if (!write_block_to_dev(dcr)) { Pmsg0(0, _("Error writing block to device.\n")); goto bail_out; } else { @@ -640,7 +676,7 @@ static int re_read_block_test() Pmsg0(0, _("Error writing record to block.\n")); goto bail_out; } - if (!write_block_to_dev(jcr, dev, block)) { + if (!write_block_to_dev(dcr)) { Pmsg0(0, _("Error writing block to device.\n")); goto bail_out; } else { @@ -666,7 +702,7 @@ static int re_read_block_test() goto bail_out; } Pmsg0(0, "Backspace record OK.\n"); - if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) { + if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) { Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno)); goto bail_out; } @@ -687,7 +723,6 @@ static int re_read_block_test() stat = 1; bail_out: - free_block(block); free_record(rec); if (stat == 0) { Pmsg0(0, _("This is not terribly serious since Bacula only uses\n" @@ -700,6 +735,266 @@ bail_out: return stat; } + +/* + * This test writes Bacula blocks to the tape in + * several files. It then rewinds the tape and attepts + * to read these blocks back checking the data. + */ +static int write_read_test() +{ + DEV_BLOCK *block; + DEV_RECORD *rec; + int stat = 0; + int len, i, j; + int *p; + + Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n" + "I'm going to write 1000 records and an EOF\n" + "then write 1000 records and an EOF, then rewind,\n" + "and re-read the data to verify that it is correct.\n\n" + "This is an *essential* feature ...\n\n")); + block = new_block(dev); + rec = new_record(); + if (!rewind_dev(dev)) { + Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev)); + goto bail_out; + } + rec->data = check_pool_memory_size(rec->data, block->buf_len); + rec->data_len = block->buf_len-100; + len = rec->data_len/sizeof(i); + for (i=1; i<=1000; i++) { + p = (int *)rec->data; + for (j=0; jdata_len); + weofcmd(); + for (i=1001; i<=2000; i++) { + p = (int *)rec->data; + for (j=0; jdata_len); + weofcmd(); + if (dev_cap(dev, CAP_TWOEOF)) { + weofcmd(); + } + if (!rewind_dev(dev)) { + Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev)); + goto bail_out; + } else { + Pmsg0(0, "Rewind OK.\n"); + } + for (i=1; i<=2000; i++) { +read_again: + if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) { + if (dev_state(dev, ST_EOF)) { + Pmsg0(-1, _("Got EOF on tape.\n")); + goto read_again; + } + Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno)); + goto bail_out; + } + memset(rec->data, 0, rec->data_len); + if (!read_record_from_block(block, rec)) { + Pmsg1(0, _("Read record failed! ERR=%s\n"), strerror(dev->dev_errno)); + goto bail_out; + } + p = (int *)rec->data; + for (j=0; jdata = check_pool_memory_size(rec->data, block->buf_len); + rec->data_len = block->buf_len-100; + len = rec->data_len/sizeof(i); + for (i=1; i<=1000; i++) { + p = (int *)rec->data; + for (j=0; jdata_len); + weofcmd(); + for (i=1001; i<=2000; i++) { + p = (int *)rec->data; + for (j=0; jdata_len); + weofcmd(); + if (dev_cap(dev, CAP_TWOEOF)) { + weofcmd(); + } + if (!rewind_dev(dev)) { + Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev)); + goto bail_out; + } else { + Pmsg0(0, "Rewind OK.\n"); + } + + while(ok) { + /* Set up next item to read based on where we are */ + switch (recno) { + case 0: + recno = 5; + file = 0; + blk = 4; + break; + case 5: + recno = 201; + file = 0; + blk = 200; + break; + case 201: + recno = 1000; + file = 0; + blk = 999; + break; + case 1000: + recno = 1001; + file = 1; + blk = 0; + break; + case 1001: + recno = 1601; + file = 1; + blk = 600; + break; + case 1601: + recno = 2000; + file = 1; + blk = 999; + break; + case 2000: + ok = false; + continue; + } + Pmsg2(-1, "Reposition to file:block %d:%d\n", file, blk); + if (!reposition_dev(dev, file, blk)) { + Pmsg0(0, "Reposition error.\n"); + goto bail_out; + } +read_again: + if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) { + if (dev_state(dev, ST_EOF)) { + Pmsg0(-1, _("Got EOF on tape.\n")); + goto read_again; + } + Pmsg1(0, _("Read block failed! ERR=%s\n\n"), strerror(dev->dev_errno)); + Pmsg0(0, _("This may be because the tape drive block size is not\n" + " set to variable blocking as normally used by Bacula.\n" + " Please see the Tape Testing chapter in the manual and \n" + " look for using mt with defblksize and setoptions\n")); + goto bail_out; + } + memset(rec->data, 0, rec->data_len); + if (!read_record_from_block(block, rec)) { + Pmsg1(0, _("Read record failed! ERR=%s\n"), strerror(dev->dev_errno)); + goto bail_out; + } + p = (int *)rec->data; + for (j=0; jfile != 4) { return -2; } - return 1; } @@ -766,9 +1064,10 @@ static int autochanger_test() { POOLMEM *results, *changer; int slot, status, loaded; - int timeout = 120; + int timeout = jcr->device->max_changer_wait; int sleep_time = 0; + Dmsg1(100, "Max changer wait = %d sec\n", timeout); if (!dev_cap(dev, CAP_AUTOCHANGER)) { return 1; } @@ -777,8 +1076,9 @@ static int autochanger_test() return 1; } - Pmsg0(-1, "\nTo test the autochanger you must have a blank tape in Slot 1.\n" - "I'm going to write on it.\n"); + Pmsg0(-1, "\nAh, I see you have an autochanger configured.\n" + "To test the autochanger you must have a blank tape\n" + " that I can write on in Slot 1.\n"); if (!get_cmd("\nDo you wish to continue with the Autochanger test? (y/n): ")) { return 0; } @@ -793,48 +1093,67 @@ static int autochanger_test() try_again: slot = 1; - jcr->VolCatInfo.Slot = slot; + dcr->VolCatInfo.Slot = slot; /* Find out what is loaded, zero means device is unloaded */ Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n")); changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "loaded"); status = run_program(changer, timeout, results); - Dmsg3(100, "run_prog: %s stat=%d result=%s\n", changer, status, results); + Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results); if (status == 0) { loaded = atoi(results); } else { - Pmsg1(-1, _("3991 Bad autochanger \"load slot\" status=%d.\n"), status); - loaded = -1; /* force unload */ + berrno be; + be.set_errno(status); + Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer); + Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror()); goto bail_out; } if (loaded) { Pmsg1(-1, "Slot %d loaded. I am going to unload it.\n", loaded); } else { - Pmsg0(-1, "Nothing loaded into the drive. OK.\n"); + Pmsg0(-1, "Nothing loaded in the drive. OK.\n"); } Dmsg1(100, "Results from loaded query=%s\n", results); if (loaded) { + dcr->VolCatInfo.Slot = loaded; offline_or_rewind_dev(dev); /* We are going to load a new tape, so close the device */ force_close_dev(dev); - Pmsg0(-1, _("3302 Issuing autochanger \"unload\" command.\n")); + Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"), + loaded, dev->drive_index); changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "unload"); - status = run_program(changer, timeout, NULL); + status = run_program(changer, timeout, results); Pmsg2(-1, "unload status=%s %d\n", status==0?"OK":"Bad", status); + if (status != 0) { + berrno be; + be.set_errno(status); + Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer); + Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror()); + } } /* * Load the Slot 1 */ - Pmsg1(-1, _("3303 Issuing autochanger \"load slot %d\" command.\n"), slot); + + slot = 1; + dcr->VolCatInfo.Slot = slot; + Pmsg2(-1, _("3303 Issuing autochanger \"load slot %d %d\" command.\n"), + slot, dev->drive_index); changer = edit_device_codes(jcr, changer, jcr->device->changer_command, "load"); - Dmsg1(200, "Changer=%s\n", changer); - status = run_program(changer, timeout, NULL); + Dmsg1(100, "Changer=%s\n", changer); + force_close_dev(dev); + status = run_program(changer, timeout, results); if (status == 0) { - Pmsg1(-1, _("3304 Autochanger \"load slot %d\" status is OK.\n"), slot); + Pmsg2(-1, _("3303 Autochanger \"load slot %d %d\" status is OK.\n"), + slot, dev->drive_index); } else { - Pmsg1(-1, _("3992 Bad autochanger \"load slot\" status=%d.\n"), status); + berrno be; + be.set_errno(status); + Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer); + Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror()); goto bail_out; } @@ -964,17 +1283,16 @@ test_again: } Pmsg0(-1, "\n"); - Pmsg0(0, _("Now forward spacing 4 more files.\n")); - if (!fsf_dev(dev, 4)) { + Pmsg0(0, _("Now forward spacing 1 more file.\n")); + if (!fsf_dev(dev, 1)) { Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev)); - goto bail_out; } Pmsg2(-1, _("We should be in file 5. I am at file %d. This is %s\n"), dev->file, dev->file == 5 ? "correct!" : "NOT correct!!!!"); if (dev->file != 5) { goto bail_out; } - + Pmsg0(-1, _("\n=== End Forward space files test ===\n\n")); return 1; bail_out: @@ -1002,6 +1320,13 @@ static void testcmd() { int stat; + if (!write_read_test()) { + return; + } + if (!position_test()) { + return; + } + stat = append_test(); if (stat == 1) { /* OK get out */ goto all_done; @@ -1023,8 +1348,8 @@ static void testcmd() goto all_done; } if (stat == -1) { - Pmsg0(-1, "\n\nThat appears not to have corrected the problem.\n"); - goto all_done; + Pmsg0(-1, "\n\nThat appears *NOT* to have corrected the problem.\n"); + goto failed; } /* Wrong count after append */ if (stat == -2) { @@ -1043,6 +1368,7 @@ static void testcmd() } } +failed: Pmsg0(-1, "\nAppend test failed.\n\n"); Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n" "Unable to correct the problem. You MUST fix this\n" @@ -1052,8 +1378,11 @@ static void testcmd() "Minimum Block Size = nnn\n" "Maximum Block Size = nnn\n\n" "in your Storage daemon's Device definition.\n" - "nnn must match your tape driver's block size.\n" - "This, however, is not really an ideal solution.\n"); + "nnn must match your tape driver's block size, which\n" + "can be determined by reading your tape manufacturers\n" + "information, and the information on your kernel dirver.\n" + "Fixed block sizes, however, are not normally an ideal solution.\n"); + return; } all_done: @@ -1083,8 +1412,6 @@ all_done: fsf_test(); /* do fast forward space file test */ autochanger_test(); /* do autochanger test */ - - Pmsg0(-1, _("\n=== End Append files test ===\n")); } @@ -1128,13 +1455,11 @@ static void fsrcmd() */ static void wrcmd() { - DEV_BLOCK *block; - DEV_RECORD *rec; + DEV_BLOCK *block = dcr->block; + DEV_RECORD *rec = dcr->rec; int i; - sm_check(__FILE__, __LINE__, False); - block = new_block(dev); - rec = new_record(); + sm_check(__FILE__, __LINE__, false); dump_block(block, "test"); i = block->buf_len - 100; @@ -1142,12 +1467,12 @@ static void wrcmd() rec->data = check_pool_memory_size(rec->data, i); memset(rec->data, i & 0xFF, i); rec->data_len = i; - sm_check(__FILE__, __LINE__, False); + sm_check(__FILE__, __LINE__, false); if (!write_record_to_block(block, rec)) { Pmsg0(0, _("Error writing record to block.\n")); goto bail_out; } - if (!write_block_to_dev(jcr, dev, block)) { + if (!write_block_to_dev(dcr)) { Pmsg0(0, _("Error writing block to device.\n")); goto bail_out; } else { @@ -1156,10 +1481,8 @@ static void wrcmd() Pmsg0(0, _("Wrote block to device.\n")); bail_out: - sm_check(__FILE__, __LINE__, False); - free_record(rec); - free_block(block); - sm_check(__FILE__, __LINE__, False); + sm_check(__FILE__, __LINE__, false); + sm_check(__FILE__, __LINE__, false); } /* @@ -1215,7 +1538,7 @@ static void scancmd() for (;;) { if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) { clrerror_dev(dev, -1); - Mmsg2(&dev->errmsg, "read error on %s. ERR=%s.\n", + Mmsg2(dev->errmsg, "read error on %s. ERR=%s.\n", dev->dev_name, strerror(dev->dev_errno)); Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev)); if (blocks > 0) @@ -1283,7 +1606,7 @@ static void scan_blocks() update_pos_dev(dev); tot_files = dev->file; for (;;) { - if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) { + if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) { Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev)); if (dev->state & ST_EOT) { if (blocks > 0) { @@ -1369,13 +1692,13 @@ static void statcmd() static void fillcmd() { DEV_RECORD rec; - DEV_BLOCK *block; + DEV_BLOCK *block = dcr->block; char ec1[50]; int fd; uint32_t i; uint32_t min_block_size; - ok = TRUE; + ok = true; stop = 0; vol_num = 0; last_file = 0; @@ -1385,42 +1708,39 @@ static void fillcmd() Pmsg0(-1, "\n\ This command simulates Bacula writing to a tape.\n\ It requires either one or two blank tapes, which it\n\ -will label and write. It will print a status approximately\n\ +will label and write.\n\n\ +If you have an autochanger configured, it will use\n\ +the tapes that are in slots 1 and 2, otherwise, you will\n\ +be prompted to insert the tapes when necessary.\n\n\ +It will print a status approximately\n\ every 322 MB, and write an EOF every 3.2 GB. If you have\n\ selected the simple test option, after writing the first tape\n\ -it will rewind it and re-read the last block written.\n\ +it will rewind it and re-read the last block written.\n\n\ If you have selected the multiple tape test, when the first tape\n\ fills, it will ask for a second, and after writing a few more \n\ blocks, it will stop. Then it will begin re-reading the\n\ two tapes.\n\n\ This may take a long time -- hours! ...\n\n"); - get_cmd("Insert a blank tape then indicate if you want\n" - "to run the simplified test (s) with one tape or\n" - "the complete multiple tape (m) test: (s/m) "); + get_cmd("Do you want to run the simplified test (s) with one tape\n" + "or the complete multiple tape (m) test: (s/m) "); if (cmd[0] == 's') { Pmsg0(-1, "Simple test (single tape) selected.\n"); - simple = TRUE; + simple = true; } else if (cmd[0] == 'm') { - Pmsg0(-1, "Complete multiple tape test selected.\n"); - simple = FALSE; + Pmsg0(-1, "Multiple tape test selected.\n"); + simple = false; } else { Pmsg0(000, "Command aborted.\n"); return; } - set_volume_name("TestVolume1", 1); - labelcmd(); - VolumeName = NULL; - - Dmsg1(20, "Begin append device=%s\n", dev_name(dev)); - + Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1)); /* Use fixed block size to simplify read back */ min_block_size = dev->min_block_size; dev->min_block_size = dev->max_block_size; - block = new_block(dev); /* * Acquire output device for writing. Note, after acquiring a @@ -1428,21 +1748,21 @@ This may take a long time -- hours! ...\n\n"); * subroutine. */ Dmsg0(100, "just before acquire_device\n"); - if (!(dev=acquire_device_for_append(jcr, dev, block))) { + if (!acquire_device_for_append(jcr)) { set_jcr_job_status(jcr, JS_ErrorTerminated); - free_block(block); return; } + block = jcr->dcr->block; Dmsg0(100, "Just after acquire_device_for_append\n"); /* * Write Begin Session Record */ - if (!write_session_label(jcr, block, SOS_LABEL)) { + if (!write_session_label(dcr, SOS_LABEL)) { set_jcr_job_status(jcr, JS_ErrorTerminated); Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"), strerror_dev(dev)); - ok = FALSE; + ok = false; } Pmsg0(-1, "Wrote Start Of Session label.\n"); @@ -1470,7 +1790,7 @@ This may take a long time -- hours! ...\n\n"); /* * Generate data as if from File daemon, write to device */ - jcr->VolFirstIndex = 0; + jcr->dcr->VolFirstIndex = 0; time(&jcr->run_time); /* start counting time for rates */ if (simple) { Pmsg0(-1, "Begin writing Bacula records to tape ...\n"); @@ -1547,7 +1867,7 @@ This may take a long time -- hours! ...\n\n"); break; } } - if (stop > 0) { + if (vol_num > 1) { Dmsg0(100, "Write_end_session_label()\n"); /* Create Job status for end of session label */ if (!job_canceled(jcr) && ok) { @@ -1555,86 +1875,58 @@ This may take a long time -- hours! ...\n\n"); } else if (!ok) { set_jcr_job_status(jcr, JS_ErrorTerminated); } - if (!write_session_label(jcr, block, EOS_LABEL)) { + if (!write_session_label(dcr, EOS_LABEL)) { Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev)); - ok = FALSE; + ok = false; } /* Write out final block of this session */ - if (!write_block_to_device(jcr, dev, block)) { - Pmsg0(-1, _("Set ok=FALSE after write_block_to_device.\n")); - ok = FALSE; + if (!write_block_to_device(dcr)) { + Pmsg0(-1, _("Set ok=false after write_block_to_device.\n")); + ok = false; } Pmsg0(-1, _("Wrote End Of Session label.\n")); + + /* Save last block info for second tape */ + last_block_num2 = last_block_num; + last_file2 = last_file; + if (last_block2) { + free_block(last_block2); + } + last_block2 = dup_block(last_block); } sprintf(buf, "%s/btape.state", working_directory); fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640); if (fd >= 0) { write(fd, &btape_state_level, sizeof(btape_state_level)); - write(fd, &last_block_num, sizeof(last_block_num)); - write(fd, &last_file, sizeof(last_file)); - write(fd, last_block->buf, last_block->buf_len); + write(fd, &simple, sizeof(simple)); + write(fd, &last_block_num1, sizeof(last_block_num1)); + write(fd, &last_block_num2, sizeof(last_block_num2)); + write(fd, &last_file1, sizeof(last_file1)); + write(fd, &last_file2, sizeof(last_file2)); + write(fd, last_block1->buf, last_block1->buf_len); + write(fd, last_block2->buf, last_block2->buf_len); + write(fd, first_block->buf, first_block->buf_len); close(fd); - Pmsg0(-1, "Wrote state file.\n"); + Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n", + last_block_num1, last_block_num2); } else { Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf, strerror(errno)); } - /* Release the device */ - if (!release_device(jcr, dev)) { + /* Release the device if multiple tapes being used */ + if (!simple && !release_device(jcr)) { Pmsg0(-1, _("Error in release_device\n")); - ok = FALSE; + ok = false; } - if (verbose) { - Pmsg0(-1, "\n"); - dump_block(last_block, _("Last block written to tape.\n")); - } - - Pmsg0(-1, _("\n\nDone filling tape. Now beginning re-read of tape ...\n")); - - if (simple) { - do_unfill(); - } else { - /* Multiple Volume tape */ - dumped = 0; - VolBytes = 0; - LastBlock = 0; - block = new_block(dev); - - dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */ - dev->capabilities &= ~CAP_LABEL; /* don't label anything here */ - - end_of_tape = 0; + Pmsg2(-1, _("\n\nDone filling tape%s. Now beginning re-read of %stape ...\n"), + simple?"":"s", simple?"":"first "); + do_unfill(); - time(&jcr->run_time); /* start counting time for rates */ - stop = 0; - file_index = 0; - /* Close device so user can use autochanger if desired */ - if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) { - offline_dev(dev); - } - force_close_dev(dev); - get_cmd(_("Mount first tape. Press enter when ready: ")); - - free_vol_list(jcr); - set_volume_name("TestVolume1", 1); - jcr->bsr = NULL; - create_vol_list(jcr); - close_dev(dev); - dev->state &= ~ST_READ; - if (!acquire_device_for_read(jcr, dev, block)) { - Pmsg1(-1, "%s", dev->errmsg); - goto bail_out; - } - /* Read all records and then second tape */ - read_records(jcr, dev, record_cb, my_mount_next_read_volume); - } -bail_out: dev->min_block_size = min_block_size; - free_block(block); free_memory(rec.data); } @@ -1648,17 +1940,22 @@ static void unfillcmd() { int fd; - if (!last_block) { - last_block = new_block(dev); - } + last_block1 = new_block(dev); + last_block2 = new_block(dev); + first_block = new_block(dev); sprintf(buf, "%s/btape.state", working_directory); fd = open(buf, O_RDONLY); if (fd >= 0) { uint32_t state_level; read(fd, &state_level, sizeof(btape_state_level)); - read(fd, &last_block_num, sizeof(last_block_num)); - read(fd, &last_file, sizeof(last_file)); - read(fd, last_block->buf, last_block->buf_len); + read(fd, &simple, sizeof(simple)); + read(fd, &last_block_num1, sizeof(last_block_num1)); + read(fd, &last_block_num2, sizeof(last_block_num2)); + read(fd, &last_file1, sizeof(last_file1)); + read(fd, &last_file2, sizeof(last_file2)); + read(fd, last_block1->buf, last_block1->buf_len); + read(fd, last_block2->buf, last_block2->buf_len); + read(fd, first_block->buf, first_block->buf_len); close(fd); if (state_level != btape_state_level) { Pmsg0(-1, "\nThe state file level has changed. You must redo\n" @@ -1670,190 +1967,200 @@ static void unfillcmd() "You must redo the fill command.\n", buf, strerror(errno)); return; } - do_unfill(); + this_block = NULL; } static void do_unfill() { - DEV_BLOCK *block; + DEV_BLOCK *block = dcr->block; + bool autochanger; dumped = 0; VolBytes = 0; LastBlock = 0; - block = new_block(dev); + Dmsg0(20, "Enter do_unfill\n"); dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */ dev->capabilities &= ~CAP_LABEL; /* don't label anything here */ end_of_tape = 0; - time(&jcr->run_time); /* start counting time for rates */ stop = 0; file_index = 0; + if (last_block) { + free_block(last_block); + } + last_block_num = last_block_num1; + last_file = last_file1; + last_block = last_block1; + if (!simple) { + /* Multiple Volume tape */ + /* Close device so user can use autochanger if desired */ + if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) { + offline_dev(dev); + } + autochanger = autoload_device(dcr, 1, NULL); + if (!autochanger) { + force_close_dev(dev); + get_cmd(_("Mount first tape. Press enter when ready: ")); + } + free_vol_list(jcr); + jcr->dcr = new_dcr(jcr, dev); + set_volume_name("TestVolume1", 1); + jcr->bsr = NULL; + create_vol_list(jcr); + close_dev(dev); + dev->state &= ~ST_READ; + if (!acquire_device_for_read(jcr)) { + Pmsg1(-1, "%s", dev->errmsg); + goto bail_out; + } + } /* + * We now have the first tape mounted. * Note, re-reading last block may have caused us to - * lose track of where we are (block number unknown). + * loose track of where we are (block number unknown). */ rewind_dev(dev); /* get to a known place on tape */ + /* Read the first 1000 records */ + Pmsg0(-1, _("Reading the first 1000 records.\n")); + read_records(dcr, quickie_cb, my_mount_next_read_volume); Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num, last_file, last_block_num); if (!reposition_dev(dev, last_file, last_block_num)) { Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev)); } Pmsg1(-1, _("Reading block %u.\n"), last_block_num); - if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) { + if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) { Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev)); goto bail_out; } - if (last_block) { - char *p, *q; - uint32_t CheckSum, block_len; - ser_declare; - p = last_block->buf; - q = block->buf; - unser_begin(q, BLKHDR2_LENGTH); - unser_uint32(CheckSum); - unser_uint32(block_len); - while (q < (block->buf+block_len)) { - if (*p == *q) { - p++; - q++; - continue; - } - Pmsg0(-1, "\n"); - dump_block(last_block, _("Last block written")); - Pmsg0(-1, "\n"); - dump_block(block, _("Block read back")); - Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf); - Pmsg0(-1, "\n\n!!!! The last block written and the block\n" - "that was read back differ. The test FAILED !!!!\n" - "This must be corrected before you use Bacula\n" - "to write multi-tape Volumes.!!!!\n"); - goto bail_out; - } - Pmsg0(-1, _("\nThe blocks are identical. Test succeeded.\n\n")); - if (verbose) { - dump_block(last_block, _("Last block written")); - dump_block(block, _("Block read back")); + if (compare_blocks(last_block, block)) { + if (simple) { + Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n")); + } else { + Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n")); } } + if (simple) { + goto bail_out; + } -bail_out: - free_block(block); -} - -/* - * We are called here from "unfill" for each record on the tape. - */ -static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec) -{ - SESSION_LABEL label; + /* restore info for last block on second Volume */ + last_block_num = last_block_num2; + last_file = last_file2; + last_block = last_block2; - if (stop > 1 && !dumped) { /* on second tape */ - dumped = 1; - if (verbose) { - dump_block(block, "First block on second tape"); - } - Pmsg4(-1, "Blk: FileIndex=%d: block=%u size=%d vol=%s\n", - rec->FileIndex, block->BlockNumber, block->block_len, dev->VolHdr.VolName); - Pmsg6(-1, " Rec: VId=%d VT=%d FI=%s Strm=%s len=%d state=%x\n", - rec->VolSessionId, rec->VolSessionTime, - FI_to_ascii(rec->FileIndex), stream_to_ascii(rec->Stream, rec->FileIndex), - rec->data_len, rec->state); - } - if (rec->FileIndex < 0) { - if (verbose > 1) { - dump_label_record(dev, rec, 1); - } - switch (rec->FileIndex) { - case PRE_LABEL: - Pmsg0(-1, "Volume is prelabeled. This tape cannot be scanned.\n"); - return 1;; - case VOL_LABEL: - unser_volume_label(dev, rec); - Pmsg3(-1, "VOL_LABEL: block=%u size=%d vol=%s\n", block->BlockNumber, - block->block_len, dev->VolHdr.VolName); - stop++; - break; - case SOS_LABEL: - unser_session_label(&label, rec); - Pmsg1(-1, "SOS_LABEL: JobId=%u\n", label.JobId); - break; - case EOS_LABEL: - unser_session_label(&label, rec); - Pmsg2(-1, "EOS_LABEL: block=%u JobId=%u\n", block->BlockNumber, - label.JobId); - break; - case EOM_LABEL: - Pmsg0(-1, "EOM_LABEL:\n"); - break; - case EOT_LABEL: /* end of all tapes */ - char ec1[50]; + /* Multiple Volume tape */ + /* Close device so user can use autochanger if desired */ + if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) { + offline_dev(dev); + } - if (LastBlock != block->BlockNumber) { - VolBytes += block->block_len; - } - LastBlock = block->BlockNumber; - now = time(NULL); - now -= jcr->run_time; - if (now <= 0) { - now = 1; - } - kbs = (double)VolBytes / (1000 * now); - Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber, - edit_uint64_with_commas(VolBytes, ec1), (float)kbs); + free_vol_list(jcr); + set_volume_name("TestVolume2", 2); + jcr->bsr = NULL; + create_vol_list(jcr); + autochanger = autoload_device(dcr, 1, NULL); + if (!autochanger) { + force_close_dev(dev); + get_cmd(_("Mount second tape. Press enter when ready: ")); + } - Pmsg0(000, "End of all tapes.\n"); + dev->state &= ~ST_READ; + if (!acquire_device_for_read(jcr)) { + Pmsg1(-1, "%s", dev->errmsg); + goto bail_out; + } - break; - default: - break; - } - return 1; + /* Space to "first" block which is last block not written + * on the previous tape. + */ + Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num); + if (!reposition_dev(dev, 0, 1)) { + Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev)); + goto bail_out; } - if (++file_index != rec->FileIndex) { - Pmsg3(000, "Incorrect FileIndex in Block %u. Got %d, expected %d.\n", - block->BlockNumber, rec->FileIndex, file_index); + Pmsg1(-1, _("Reading block %d.\n"), dev->block_num); + if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) { + Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev)); + goto bail_out; } - /* - * Now check that the right data is in the record. - */ - uint64_t *lp = (uint64_t *)rec->data; - uint64_t val = ~file_index; - for (uint32_t i=0; i < (REC_SIZE-sizeof(uint64_t))/sizeof(uint64_t); i++) { - if (*lp++ != val) { - Pmsg2(000, "Record %d contains bad data in Block %u.\n", - file_index, block->BlockNumber); - break; - } + if (compare_blocks(first_block, block)) { + Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n")); } - if (LastBlock != block->BlockNumber) { - VolBytes += block->block_len; + /* Now find and compare the last block */ + Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num, + last_file, last_block_num); + if (!reposition_dev(dev, last_file, last_block_num)) { + Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev)); + goto bail_out; } - if ((block->BlockNumber != LastBlock) && (block->BlockNumber % 50000) == 0) { - char ec1[50]; - now = time(NULL); - now -= jcr->run_time; - if (now <= 0) { - now = 1; + Pmsg1(-1, _("Reading block %d.\n"), dev->block_num); + if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) { + Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev)); + goto bail_out; + } + if (compare_blocks(last_block, block)) { + Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n")); + } + +bail_out: + free_block(last_block1); + free_block(last_block2); + free_block(first_block); +} + +/* Read 1000 records then stop */ +static bool quickie_cb(DCR *dcr, DEV_RECORD *rec) +{ + quickie_count++; + return quickie_count <= 1000; +} + +static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block) +{ + char *p, *q; + uint32_t CheckSum, block_len; + ser_declare; + + p = last_block->buf; + q = block->buf; + unser_begin(q, BLKHDR2_LENGTH); + unser_uint32(CheckSum); + unser_uint32(block_len); + while (q < (block->buf+block_len)) { + if (*p == *q) { + p++; + q++; + continue; } - kbs = (double)VolBytes / (1000 * now); - Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber, - edit_uint64_with_commas(VolBytes, ec1), (float)kbs); + Pmsg0(-1, "\n"); + dump_block(last_block, _("Last block written")); + Pmsg0(-1, "\n"); + dump_block(block, _("Block read back")); + Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf); + Pmsg0(-1, "\n\n!!!! The last block written and the block\n" + "that was read back differ. The test FAILED !!!!\n" + "This must be corrected before you use Bacula\n" + "to write multi-tape Volumes.!!!!\n"); + return false; } - LastBlock = block->BlockNumber; - if (end_of_tape) { - Pmsg1(000, "End of all blocks. Block=%u\n", block->BlockNumber); + if (verbose) { + dump_block(last_block, _("Last block written")); + dump_block(block, _("Block read back")); } - return 1; + return true; } + + /* * Write current block to tape regardless of whether or * not it is full. If the tape fills, attempt to @@ -1869,26 +2176,38 @@ static int flush_block(DEV_BLOCK *block, int dump) if (!this_block) { this_block = new_block(dev); } + if (!last_block) { + last_block = new_block(dev); + } /* Copy block */ - free_memory(this_block->buf); - memcpy(this_block, block, sizeof(DEV_BLOCK)); - this_block->buf = get_memory(block->buf_len); this_file = dev->file; this_block_num = dev->block_num; - if (!write_block_to_dev(jcr, dev, block)) { + if (!write_block_to_dev(dcr)) { Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n", last_file, last_block_num, this_block_num); + if (vol_num == 1) { + /* + * This is 1st tape, so save first tape info separate + * from second tape info + */ + last_block_num1 = last_block_num; + last_file1 = last_file; + last_block1 = dup_block(last_block); + last_block2 = dup_block(last_block); + first_block = dup_block(block); /* first block second tape */ + } if (verbose) { Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n", (unsigned)file_index, block->BlockNumber, block->block_len); - if (dump) { - dump_block(block, "Block not written"); - } + dump_block(last_block, "Last block written"); + Pmsg0(-1, "\n"); + dump_block(block, "Block not written"); } if (stop == 0) { eot_block = block->BlockNumber; eot_block_len = block->block_len; eot_FileIndex = file_index; + stop = 1; } now = time(NULL); now -= jcr->run_time; @@ -1904,18 +2223,18 @@ static int flush_block(DEV_BLOCK *block, int dump) stop = -1; /* stop, but do simplified test */ } else { /* Full test in progress */ - if (!fixup_device_block_write_error(jcr, dev, block)) { + if (!fixup_device_block_write_error(jcr->dcr)) { Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev)); - ok = FALSE; + ok = false; unlock_device(dev); return 0; } - stop = 1; BlockNumber = 0; /* start counting for second tape */ } unlock_device(dev); return 1; /* end of tape reached */ } + /* Save contents after write so that the header is serialized */ memcpy(this_block->buf, block->buf, this_block->buf_len); @@ -1941,8 +2260,8 @@ static int flush_block(DEV_BLOCK *block, int dump) */ static void qfillcmd() { - DEV_BLOCK *block; - DEV_RECORD *rec; + DEV_BLOCK *block = dcr->block; + DEV_RECORD *rec = dcr->rec; int i, count; Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n"); @@ -1954,9 +2273,7 @@ static void qfillcmd() count = 1000; } - sm_check(__FILE__, __LINE__, False); - block = new_block(dev); - rec = new_record(); + sm_check(__FILE__, __LINE__, false); i = block->buf_len - 100; ASSERT (i > 0); @@ -1974,7 +2291,7 @@ static void qfillcmd() Pmsg0(0, _("Error writing record to block.\n")); goto bail_out; } - if (!write_block_to_dev(jcr, dev, block)) { + if (!write_block_to_dev(dcr)) { Pmsg0(0, _("Error writing block to device.\n")); goto bail_out; } @@ -1988,11 +2305,7 @@ static void qfillcmd() scan_blocks(); bail_out: - sm_check(__FILE__, __LINE__, False); - free_record(rec); - free_block(block); - sm_check(__FILE__, __LINE__, False); - + sm_check(__FILE__, __LINE__, false); } /* @@ -2000,7 +2313,7 @@ bail_out: */ static void rawfill_cmd() { - DEV_BLOCK *block; + DEV_BLOCK *block = dcr->block; int stat; int fd; uint32_t block_num = 0; @@ -2008,7 +2321,6 @@ static void rawfill_cmd() int my_errno; uint32_t i; - block = new_block(dev); fd = open("/dev/urandom", O_RDONLY); if (fd) { read(fd, block->buf, block->buf_len); @@ -2043,7 +2355,6 @@ static void rawfill_cmd() printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat, strerror(my_errno)); weofcmd(); - free_block(block); } @@ -2052,14 +2363,13 @@ static void rawfill_cmd() */ static void bfill_cmd() { - DEV_BLOCK *block; + DEV_BLOCK *block = dcr->block; uint32_t block_num = 0; uint32_t *p; int my_errno; int fd; uint32_t i; - block = new_block(dev); fd = open("/dev/urandom", O_RDONLY); if (fd) { read(fd, block->buf, block->buf_len); @@ -2077,7 +2387,7 @@ static void bfill_cmd() *p = block_num; block->binbuf = block->buf_len; block->bufp = block->buf + block->binbuf; - if (!write_block_to_dev(jcr, dev, block)) { + if (!write_block_to_dev(dcr)) { break; } if ((block_num++ % 100) == 0) { @@ -2093,11 +2403,10 @@ static void bfill_cmd() printf("\n"); printf("Write failed at block %u.\n", block_num); weofcmd(); - free_block(block); } -struct cmdstruct { char *key; void (*func)(); char *help; }; +struct cmdstruct { const char *key; void (*func)(); const char *help; }; static struct cmdstruct commands[] = { {"autochanger", autochangercmd, "test autochanger"}, {"bsf", bsfcmd, "backspace file"}, @@ -2137,7 +2446,7 @@ do_tape_cmds() bool found; while (get_cmd("*")) { - sm_check(__FILE__, __LINE__, False); + sm_check(__FILE__, __LINE__, false); found = false; parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS); for (i=0; i \n" +" -b specify bootstrap file\n" " -c set configuration file to file\n" " -d set debug level to nn\n" +" -p proceed inspite of I/O errors\n" " -s turn off signals\n" -" -t open the default tape device\n" +" -v be verbose\n" " -? print this message.\n" "\n")); @@ -2184,7 +2496,7 @@ static void usage() * to have correct backspacing, etc. */ int -get_cmd(char *prompt) +get_cmd(const char *prompt) { int i = 0; int ch; @@ -2212,56 +2524,95 @@ get_cmd(char *prompt) } /* Dummies to replace askdir.c */ -int dir_get_volume_info(JCR *jcr, enum get_vol_info_rw writing) { return 1;} -int dir_update_volume_info(JCR *jcr, DEVICE *dev, int relabel) { return 1; } -int dir_create_jobmedia_record(JCR *jcr) { return 1; } -int dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;} -int dir_send_job_status(JCR *jcr) {return 1;} +bool dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;} +bool dir_send_job_status(JCR *jcr) {return 1;} + +bool dir_update_volume_info(DCR *dcr, bool relabel) +{ + return 1; +} + + +bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing) +{ + Dmsg0(20, "Enter dir_get_volume_info\n"); + bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName)); + return 1; +} +bool dir_create_jobmedia_record(DCR *dcr) +{ + dcr->WroteVol = false; + return 1; +} -int dir_find_next_appendable_volume(JCR *jcr) +bool dir_find_next_appendable_volume(DCR *dcr) { - return 1; + Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop); + return dcr->VolumeName[0] != 0; } -int dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev) +bool dir_ask_sysop_to_mount_volume(DCR *dcr) { + DEVICE *dev = dcr->dev; + Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n"); + if (dcr->VolumeName[0] == 0) { + return dir_ask_sysop_to_create_appendable_volume(dcr); + } /* Close device so user can use autochanger if desired */ if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) { offline_dev(dev); } force_close_dev(dev); Pmsg1(-1, "%s", dev->errmsg); /* print reason */ - fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ", - jcr->VolumeName, dev_name(dev)); + if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) { + fprintf(stderr, "Mount second Volume on device %s and press return when ready: ", + dev_name(dev)); + } else { + fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ", + dcr->VolumeName, dev_name(dev)); + } getchar(); - return 1; + return true; } -int dir_ask_sysop_to_create_appendable_volume(JCR *jcr, DEVICE *dev) +bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr) { + bool autochanger; + DEVICE *dev = dcr->dev; + Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n"); + if (stop == 0) { + set_volume_name("TestVolume1", 1); + } else { + set_volume_name("TestVolume2", 2); + } /* Close device so user can use autochanger if desired */ if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) { offline_dev(dev); } - force_close_dev(dev); - fprintf(stderr, "Mount next Volume on device %s and press return when ready: ", - dev_name(dev)); - getchar(); - set_volume_name("TestVolume2", 2); + autochanger = autoload_device(dcr, 1, NULL); + if (!autochanger) { + force_close_dev(dev); + fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ", + dev_name(dev)); + getchar(); + } + open_device(dcr); labelcmd(); VolumeName = NULL; BlockNumber = 0; - stop = 1; - return 1; + return true; } -static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) +static bool my_mount_next_read_volume(DCR *dcr) { char ec1[50]; + JCR *jcr = dcr->jcr; + DEV_BLOCK *block = dcr->block; - Pmsg1(000, "End of Volume \"%s\"\n", jcr->VolumeName); + Dmsg0(20, "Enter my_mount_next_read_volume\n"); + Pmsg1(000, "End of Volume \"%s\"\n", dcr->VolumeName); if (LastBlock != block->BlockNumber) { VolBytes += block->block_len; @@ -2276,9 +2627,9 @@ static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber, edit_uint64_with_commas(VolBytes, ec1), (float)kbs); - if (strcmp(jcr->VolumeName, "TestVolume2") == 0) { + if (strcmp(dcr->VolumeName, "TestVolume2") == 0) { end_of_tape = 1; - return 0; + return false; } free_vol_list(jcr); @@ -2287,95 +2638,20 @@ static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) create_vol_list(jcr); close_dev(dev); dev->state &= ~ST_READ; - if (!acquire_device_for_read(jcr, dev, block)) { - Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), jcr->VolumeName); - return 0; + if (!acquire_device_for_read(jcr)) { + Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), dcr->VolumeName); + return false; } - return 1; /* next volume mounted */ + return true; /* next volume mounted */ } -static void set_volume_name(char *VolName, int volnum) +static void set_volume_name(const char *VolName, int volnum) { + DCR *dcr = jcr->dcr; VolumeName = VolName; vol_num = volnum; - pm_strcpy(&jcr->VolumeName, VolName); bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName)); -} - -/* - * Edit codes into ChangerCommand - * %% = % - * %a = archive device name - * %c = changer device name - * %f = Client's name - * %j = Job name - * %o = command - * %s = Slot base 0 - * %S = Slot base 1 - * %v = Volume name - * - * - * omsg = edited output message - * imsg = input string containing edit codes (%x) - * cmd = command string (load, unload, ...) - * - */ -static char *edit_device_codes(JCR *jcr, char *omsg, char *imsg, char *cmd) -{ - char *p; - const char *str; - char add[20]; - - *omsg = 0; - Dmsg1(400, "edit_device_codes: %s\n", imsg); - for (p=imsg; *p; p++) { - if (*p == '%') { - switch (*++p) { - case '%': - str = "%"; - break; - case 'a': - str = dev_name(jcr->device->dev); - break; - case 'c': - str = NPRT(jcr->device->changer_name); - break; - case 'o': - str = NPRT(cmd); - break; - case 's': - sprintf(add, "%d", jcr->VolCatInfo.Slot - 1); - str = add; - break; - case 'S': - sprintf(add, "%d", jcr->VolCatInfo.Slot); - str = add; - break; - case 'j': /* Job name */ - str = jcr->Job; - break; - case 'v': - str = NPRT(jcr->VolumeName); - break; - case 'f': - str = NPRT(jcr->client_name); - break; - - default: - add[0] = '%'; - add[1] = *p; - add[2] = 0; - str = add; - break; - } - } else { - add[0] = *p; - add[1] = 0; - str = add; - } - Dmsg1(400, "add_str %s\n", str); - pm_strcat(&omsg, (char *)str); - Dmsg1(400, "omsg=%s\n", omsg); - } - return omsg; + bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName)); + bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName)); + dcr->VolCatInfo.Slot = volnum; }