/* External subroutines */
extern void free_config_resources();
-extern char *edit_device_codes(JCR *jcr, char *omsg, const char *imsg, const char *cmd);
/* Exported variables */
int quit = 0;
static void statcmd();
static void unfillcmd();
static int flush_block(DEV_BLOCK *block, int dump);
-static bool quickie_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec);
+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(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+static bool my_mount_next_read_volume(DCR *dcr);
static void scan_blocks();
static void set_volume_name(const char *VolName, int volnum);
static void rawfill_cmd();
char buf[1000];
/* Sanity checks */
- if (TAPE_BSIZE % DEV_BSIZE != 0 || TAPE_BSIZE / DEV_BSIZE == 0) {
+ if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
- TAPE_BSIZE, DEV_BSIZE);
+ TAPE_BSIZE, B_DEV_BSIZE);
}
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);
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);
}
free_block(this_block);
}
+ stop_watchdog();
term_msg();
close_memory_pool(); /* free memory in pool */
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, OPEN_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);
}
}
Pmsg1(000, "open_dev %s OK\n", dev_name(dev));
+ dev->state |= ST_APPEND;
unlock_device(dev);
free_block(block);
return true;
static void labelcmd()
{
if (VolumeName) {
- pm_strcpy(&cmd, VolumeName);
+ pm_strcpy(cmd, VolumeName);
} else {
if (!get_cmd("Enter Volume Name: ")) {
return;
{
int save_debug_level = debug_level;
int stat;
- DEV_BLOCK *block;
- block = new_block(dev);
- stat = read_dev_volume_label(dcr, block);
+ stat = read_dev_volume_label(dcr);
switch (stat) {
case VOL_NO_LABEL:
Pmsg0(0, "Volume has no label.\n");
debug_level = 20;
dump_volume_label(dev);
debug_level = save_debug_level;
- free_block(block);
}
printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
+ printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
*/
static int re_read_block_test()
{
- DEV_BLOCK *block;
+ DEV_BLOCK *block = dcr->block;
DEV_RECORD *rec;
int stat = 0;
int len;
"tape to verify that the block was written correctly.\n\n"
"This is not an *essential* feature ...\n\n"));
rewindcmd();
- block = new_block(dev);
+ empty_block(block);
rec = new_record();
rec->data = check_pool_memory_size(rec->data, block->buf_len);
len = rec->data_len = block->buf_len-100;
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
} else {
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
} else {
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
} else {
goto bail_out;
}
Pmsg0(0, "Backspace record OK.\n");
- if (!read_block_from_dev(dcr, block, NO_BLOCK_NUMBER_CHECK)) {
- Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
+ if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
+ berrno be;
+ Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
goto bail_out;
}
memset(rec->data, 0, rec->data_len);
if (!read_record_from_block(block, rec)) {
- Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
+ berrno be;
+ Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
goto bail_out;
}
for (int i=0; i<len; i++) {
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"
"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);
+ block = dcr->block;
rec = new_record();
if (!rewind_dev(dev)) {
Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
}
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
}
}
for (i=1; i<=2000; i++) {
read_again:
- if (!read_block_from_dev(dcr, block, NO_BLOCK_NUMBER_CHECK)) {
+ if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
+ berrno be;
if (dev_state(dev, ST_EOF)) {
Pmsg0(-1, _("Got EOF on tape.\n"));
- goto read_again;
+ if (i == 1001) {
+ goto read_again;
+ }
}
- Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
+ Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.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));
+ berrno be;
+ Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
goto bail_out;
}
p = (int *)rec->data;
stat = 1;
bail_out:
- free_block(block);
free_record(rec);
return stat;
}
*/
static int position_test()
{
- DEV_BLOCK *block;
+ DEV_BLOCK *block = dcr->block;
DEV_RECORD *rec;
int stat = 0;
int len, i, j;
int recno = 0;
int file = 0, blk = 0;
int *p;
+ bool got_eof = false;
Pmsg0(-1, _("\n=== Write, rewind, and position 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 position to a few blocks and verify that it is correct.\n\n"
"This is an *essential* feature ...\n\n"));
- block = new_block(dev);
+ empty_block(block);
rec = new_record();
if (!rewind_dev(dev)) {
Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
}
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
}
goto bail_out;
}
read_again:
- if (!read_block_from_dev(dcr, block, NO_BLOCK_NUMBER_CHECK)) {
+ if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
+ berrno be;
if (dev_state(dev, ST_EOF)) {
Pmsg0(-1, _("Got EOF on tape.\n"));
- goto read_again;
+ if (!got_eof) {
+ got_eof = true;
+ goto read_again;
+ }
}
- Pmsg1(0, _("Read block failed! ERR=%s\n\n"), strerror(dev->dev_errno));
+ Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
+ recno, file, blk, be.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"));
+ " look for using mt with defblksize and setoptions\n"
+ "If your tape drive block size is correct, then perhaps\n"
+ " your SCSI driver is *really* stupid and does not\n"
+ " correctly report the file:block after a FSF. In this\n"
+ " case try setting:\n"
+ " Fast Forward Space File = no\n"
+ " in your Device resource.\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));
+ berrno be;
+ Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
goto bail_out;
}
p = (int *)rec->data;
goto bail_out;
}
}
- Pmsg0(-1, _("Block re-read correctly.\n"));
+ Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
}
Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
stat = 1;
bail_out:
- free_block(block);
free_record(rec);
return stat;
}
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 = atoi(results);
} else {
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());
+ Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
goto bail_out;
}
if (loaded) {
}
Dmsg1(100, "Results from loaded query=%s\n", results);
if (loaded) {
- jcr->VolCatInfo.Slot = 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);
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());
+ Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
}
}
*/
slot = 1;
- jcr->VolCatInfo.Slot = slot;
+ 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");
slot, dev->drive_index);
} else {
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());
+ Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
goto bail_out;
}
if (!open_the_device()) {
goto bail_out;
}
+ /*
+ * Start with sleep_time 0 then increment by 30 seconds if we get
+ * a failure.
+ */
bmicrosleep(sleep_time, 0);
- if (!rewind_dev(dev)) {
+ if (!rewind_dev(dev) || weof_dev(dev,1) < 0) {
Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
clrerror_dev(dev, -1);
Pmsg0(-1, "\nThe test failed, probably because you need to put\n"
*/
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();
- dump_block(block, "test");
+ empty_block(block);
+ if (verbose > 1) {
+ dump_block(block, "test");
+ }
i = block->buf_len - 100;
ASSERT (i > 0);
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
} else {
bail_out:
sm_check(__FILE__, __LINE__, false);
- free_record(rec);
- free_block(block);
sm_check(__FILE__, __LINE__, false);
}
if (stat > 0 && stat <= len) {
errno = 0;
}
+ berrno be;
Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
- len, stat, strerror(errno));
+ len, stat, be.strerror());
free(buf);
}
Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
for (;;) {
if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
+ berrno be;
clrerror_dev(dev, -1);
- Mmsg2(&dev->errmsg, "read error on %s. ERR=%s.\n",
- dev->dev_name, strerror(dev->dev_errno));
+ Mmsg2(dev->errmsg, "read error on %s. ERR=%s.\n",
+ dev->dev_name, be.strerror());
Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
if (blocks > 0)
printf("%d block%s of %d bytes in file %d\n",
int blocks, tot_blocks, tot_files;
uint32_t block_size;
uint64_t bytes;
- DEV_BLOCK *block;
+ DEV_BLOCK *block = dcr->block;
char ec1[50];
- block = new_block(dev);
blocks = block_size = tot_blocks = 0;
bytes = 0;
+ empty_block(block);
update_pos_dev(dev);
tot_files = dev->file;
for (;;) {
- if (!read_block_from_device(dcr, 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) {
}
bail_out:
- free_block(block);
tot_files = dev->file - tot_files;
printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
edit_uint64_with_commas(bytes, ec1));
static void fillcmd()
{
DEV_RECORD rec;
- DEV_BLOCK *block;
+ DEV_BLOCK *block = dcr->block;
char ec1[50];
int fd;
uint32_t i;
/* Use fixed block size to simplify read back */
min_block_size = dev->min_block_size;
dev->min_block_size = dev->max_block_size;
+ set_volume_name("TestVolume1", 1);
+
+ rewind_dev(dev);
+ weof_dev(dev, 1);
+ dev->state &= ~ST_APPEND; /* force volume to be relabeled */
/*
* Acquire output device for writing. Note, after acquiring a
/*
* Write Begin Session Record
*/
- if (!write_session_label(dcr, 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;
}
- Pmsg0(-1, "Wrote Start Of Session label.\n");
+ Pmsg0(-1, "Wrote Start of Session label.\n");
memset(&rec, 0, sizeof(rec));
rec.data = get_memory(100000); /* max record size */
} else if (!ok) {
set_jcr_job_status(jcr, JS_ErrorTerminated);
}
- if (!write_session_label(dcr, 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;
}
/* Write out final block of this session */
- if (!write_block_to_device(dcr, block)) {
+ 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"));
+ Pmsg0(-1, _("Wrote End of Session label.\n"));
/* Save last block info for second tape */
last_block_num2 = last_block_num;
Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
last_block_num1, last_block_num2);
} else {
+ berrno be;
Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
- strerror(errno));
+ be.strerror());
}
- /* Release the device if multiple tapes being used */
- if (!simple && !release_device(jcr)) {
- Pmsg0(-1, _("Error in release_device\n"));
- ok = false;
- }
+ Pmsg4(-1, _("\n\nDone filling tape%s at %d:%d. Now beginning re-read of %stape ...\n"),
+ simple?"":"s", jcr->dcr->dev->file, jcr->dcr->dev->block_num, simple?"":"first ");
- Pmsg2(-1, _("\n\nDone filling tape%s. Now beginning re-read of %stape ...\n"),
- simple?"":"s", simple?"":"first ");
+ jcr->dcr->block = block;
+ /* Release the device if multiple tapes being used */
+// if (!simple && !release_device(jcr)) {
+// Pmsg0(-1, _("Error in release_device\n"));
+// ok = false;
+// }
do_unfill();
return;
}
} else {
+ berrno be;
Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
- "You must redo the fill command.\n", buf, strerror(errno));
+ "You must redo the fill command.\n", buf, be.strerror());
return;
}
do_unfill();
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 */
jcr->bsr = NULL;
create_vol_list(jcr);
close_dev(dev);
- dev->state &= ~ST_READ;
+ dev->state &= ~(ST_READ|ST_APPEND);
+ dev->num_writers = 0;
if (!acquire_device_for_read(jcr)) {
Pmsg1(-1, "%s", dev->errmsg);
goto bail_out;
* Note, re-reading last block may have caused us to
* loose track of where we are (block number unknown).
*/
- rewind_dev(dev); /* get to a known place on tape */
+ if (!rewind_dev(dev)) { /* get to a known place on tape */
+ goto bail_out;
+ }
/* Read the first 1000 records */
Pmsg0(-1, _("Reading the first 1000 records.\n"));
+ quickie_count = 0;
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));
+ goto bail_out;
}
Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
- if (!read_block_from_device(dcr, 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;
}
goto bail_out;
}
Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
- if (!read_block_from_device(dcr, 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;
}
goto bail_out;
}
Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
- if (!read_block_from_device(dcr, 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;
}
}
bail_out:
- free_block(block);
free_block(last_block1);
free_block(last_block2);
free_block(first_block);
}
/* Read 1000 records then stop */
-static bool quickie_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
+static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
{
+ DEVICE *dev = dcr->dev;
+ if (dev->file != 0) {
+ Pmsg3(-1, "ERROR! device at %d:%d count=%d\n", dev->file, dev->block_num,
+ quickie_count);
+ return false;
+ }
quickie_count++;
- return quickie_count <= 1000;
+ if (quickie_count == 1000) {
+ Pmsg2(-1, "1000 records read now at %d:%d\n", dev->file, dev->block_num);
+ }
+ return quickie_count < 1000;
}
static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
static int flush_block(DEV_BLOCK *block, int dump)
{
char ec1[50];
- lock_device(dev);
DEV_BLOCK *tblock;
uint32_t this_file, this_block_num;
+ lock_device(dev);
if (!this_block) {
this_block = new_block(dev);
}
/* Copy block */
this_file = dev->file;
this_block_num = dev->block_num;
- if (!write_block_to_dev(dcr, 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) {
}
kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
vol_size = dev->VolCatInfo.VolCatBytes;
- Pmsg2(000, "End of tape. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
+ Pmsg4(000, "End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
+ dev->file, dev->block_num,
edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
if (simple) {
stop = -1; /* stop, but do simplified test */
} else {
/* Full test in progress */
- if (!fixup_device_block_write_error(jcr->dcr, block)) {
+ if (!fixup_device_block_write_error(jcr->dcr)) {
Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
ok = false;
unlock_device(dev);
memcpy(this_block->buf, block->buf, this_block->buf_len);
/*
- * Toggle between two allocated blocks for efficiency.
+ * Note, we always read/write to block, but we toggle
+ * copying it to one or another of two allocated blocks.
* Switch blocks so that the block just successfully written is
* always in last_block.
*/
*/
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");
}
sm_check(__FILE__, __LINE__, false);
- block = new_block(dev);
- rec = new_record();
i = block->buf_len - 100;
ASSERT (i > 0);
Pmsg0(0, _("Error writing record to block.\n"));
goto bail_out;
}
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
Pmsg0(0, _("Error writing block to device.\n"));
goto bail_out;
}
bail_out:
sm_check(__FILE__, __LINE__, false);
- free_record(rec);
- free_block(block);
- sm_check(__FILE__, __LINE__, false);
-
}
/*
*/
static void rawfill_cmd()
{
- DEV_BLOCK *block;
+ DEV_BLOCK *block = dcr->block;
int stat;
int fd;
uint32_t block_num = 0;
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);
}
my_errno = errno;
printf("\n");
+ berrno be;
printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
- strerror(my_errno));
+ be.strerror(my_errno));
weofcmd();
- free_block(block);
}
*/
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);
*p = block_num;
block->binbuf = block->buf_len;
block->bufp = block->buf + block->binbuf;
- if (!write_block_to_dev(dcr, block)) {
+ if (!write_block_to_dev(dcr)) {
break;
}
if ((block_num++ % 100) == 0) {
printf("\n");
printf("Write failed at block %u.\n", block_num);
weofcmd();
- free_block(block);
}
bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
{
- JCR *jcr = dcr->jcr;
Dmsg0(20, "Enter dir_get_volume_info\n");
- bstrncpy(jcr->VolCatInfo.VolCatName, jcr->VolumeName, sizeof(jcr->VolCatInfo.VolCatName));
+ bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
return 1;
}
bool dir_find_next_appendable_volume(DCR *dcr)
{
- JCR *jcr = dcr->jcr;
Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
- return jcr->VolumeName[0] != 0;
+ return dcr->VolumeName[0] != 0;
}
bool dir_ask_sysop_to_mount_volume(DCR *dcr)
{
DEVICE *dev = dcr->dev;
- JCR *jcr = dcr->jcr;
Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
- if (jcr->VolumeName[0] == 0) {
+ if (dcr->VolumeName[0] == 0) {
return dir_ask_sysop_to_create_appendable_volume(dcr);
}
/* Close device so user can use autochanger if desired */
}
force_close_dev(dev);
Pmsg1(-1, "%s", dev->errmsg); /* print reason */
- if (jcr->VolumeName[0] == 0 || strcmp(jcr->VolumeName, "TestVolume2") == 0) {
+ 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: ",
- jcr->VolumeName, dev_name(dev));
+ dcr->VolumeName, dev_name(dev));
}
getchar();
return true;
{
bool autochanger;
DEVICE *dev = dcr->dev;
- JCR *jcr = dcr->jcr;
Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
if (stop == 0) {
set_volume_name("TestVolume1", 1);
dev_name(dev));
getchar();
}
- open_device(jcr, dev);
+ open_device(dcr);
labelcmd();
VolumeName = NULL;
BlockNumber = 0;
return true;
}
-static bool 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;
Dmsg0(20, "Enter my_mount_next_read_volume\n");
- Pmsg1(000, "End of Volume \"%s\"\n", jcr->VolumeName);
+ Pmsg1(000, "End of Volume \"%s\"\n", dcr->VolumeName);
if (LastBlock != block->BlockNumber) {
VolBytes += block->block_len;
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 false;
}
close_dev(dev);
dev->state &= ~ST_READ;
if (!acquire_device_for_read(jcr)) {
- Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), jcr->VolumeName);
+ Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), dcr->VolumeName);
return false;
}
return true; /* next volume mounted */
DCR *dcr = jcr->dcr;
VolumeName = VolName;
vol_num = volnum;
- pm_strcpy(&jcr->VolumeName, VolName);
bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
- bstrncpy(jcr->VolCatInfo.VolCatName, VolName, sizeof(jcr->VolCatInfo.VolCatName));
bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
- jcr->VolCatInfo.Slot = volnum;
dcr->VolCatInfo.Slot = volnum;
}