X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Flabel.c;h=b600a66ffc0e4329eb1f587df40fd8ec5865e7ad;hb=306f4ac1284013a382baf5b69381f060ce910d5c;hp=d37ef473f720c2fbade3cf02641ed3f2a9687a00;hpb=9e2c1c2c5821d56ad0bf95cc96f34282595e4bf0;p=bacula%2Fbacula diff --git a/bacula/src/stored/label.c b/bacula/src/stored/label.c index d37ef473f7..b600a66ffc 100644 --- a/bacula/src/stored/label.c +++ b/bacula/src/stored/label.c @@ -1,280 +1,534 @@ /* * - * label.c Bacula routines to handle labels + * label.c Bacula routines to handle labels * * Kern Sibbald, MM - * + * * * Version $Id$ */ /* - Copyright (C) 2000-2003 Kern Sibbald and John Walker + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2006 Free Software Foundation Europe e.V. - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of - the License, or (at your option) any later version. + The main author of Bacula is Kern Sibbald, with contributions from + many others, a complete list can be found in the file AUTHORS. + This program is Free Software; you can redistribute it and/or + modify it under the terms of version two of the GNU General Public + License as published by the Free Software Foundation plus additions + that are listed in the file LICENSE. - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - You should have received a copy of the GNU General Public - License along with this program; if not, write to the Free - Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, - MA 02111-1307, USA. + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. - */ + Bacula® is a registered trademark of John Walker. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ #include "bacula.h" /* pull in global headers */ #include "stored.h" /* pull in Storage Deamon headers */ /* Forward referenced functions */ -static void create_volume_label_record(JCR *jcr, DEVICE *dev, DEV_RECORD *rec); - -extern char my_name[]; -extern int debug_level; +static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec); /* * Read the volume label * - * If jcr->VolumeName == NULL, we accept any Bacula Volume - * If jcr->VolumeName[0] == 0, we accept any Bacula Volume - * otherwise jcr->VolumeName must match the Volume. + * If dcr->VolumeName == NULL, we accept any Bacula Volume + * If dcr->VolumeName[0] == 0, we accept any Bacula Volume + * otherwise dcr->VolumeName must match the Volume. * - * If VolName given, ensure that it matches + * If VolName given, ensure that it matches * * Returns VOL_ code as defined in record.h * VOL_NOT_READ - * VOL_OK - * VOL_NO_LABEL - * VOL_IO_ERROR - * VOL_NAME_ERROR - * VOL_CREATE_ERROR - * VOL_VERSION_ERROR - * VOL_LABEL_ERROR - * VOL_NO_MEDIA - */ -int read_dev_volume_label(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) + * VOL_OK good label found + * VOL_NO_LABEL volume not labeled + * VOL_IO_ERROR I/O error reading tape + * VOL_NAME_ERROR label has wrong name + * VOL_CREATE_ERROR Error creating label + * VOL_VERSION_ERROR label has wrong version + * VOL_LABEL_ERROR bad label type + * VOL_NO_MEDIA no media in drive + * + * The dcr block is emptied on return, and the Volume is + * rewound. + */ +int read_dev_volume_label(DCR *dcr) { - char *VolName = jcr->VolumeName; + JCR *jcr = dcr->jcr; + DEVICE *dev = dcr->dev; + char *VolName = dcr->VolumeName; DEV_RECORD *record; - int ok = 0; - - Dmsg3(100, "Enter read_volume_label device=%s vol=%s dev_Vol=%s\n", - dev_name(dev), VolName, dev->VolHdr.VolName); - - if (dev_state(dev, ST_LABEL)) { /* did we already read label? */ + bool ok = false; + DEV_BLOCK *block = dcr->block; + int stat; + bool want_ansi_label; + bool have_ansi_label = false; + + Dmsg4(100, "Enter read_volume_label res=%d device=%s vol=%s dev_Vol=%s\n", + dev->reserved_device, dev->print_name(), VolName, + dev->VolHdr.VolumeName[0]?dev->VolHdr.VolumeName:"*NULL*"); + + if (!dev->is_open()) { + if (dev->open(dcr, OPEN_READ_ONLY) < 0) { + return VOL_IO_ERROR; + } + } + if (dev->is_labeled()) { /* did we already read label? */ /* Compare Volume Names allow special wild card */ - if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolName, VolName) != 0) { - Mmsg(&jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"), - dev_name(dev), VolName, dev->VolHdr.VolName); - /* - * Cancel Job if too many label errors - * => we are in a loop - */ - if (jcr->label_errors++ > 100) { - Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg); - } - return jcr->label_status = VOL_NAME_ERROR; + if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolumeName, VolName) != 0) { + Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"), + dev->print_name(), VolName, dev->VolHdr.VolumeName); + /* + * Cancel Job if too many label errors + * => we are in a loop + */ + if (!dev->poll && jcr->label_errors++ > 100) { + Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg); + } + Dmsg0(150, "return VOL_NAME_ERROR\n"); + stat = VOL_NAME_ERROR; + goto bail_out; } Dmsg0(30, "Leave read_volume_label() VOL_OK\n"); - return jcr->label_status = VOL_OK; /* label already read */ + return VOL_OK; /* label already read */ } - dev->state &= ~(ST_LABEL|ST_APPEND|ST_READ); /* set no label, no append */ + dev->clear_labeled(); + dev->clear_append(); + dev->clear_read(); + dev->label_type = B_BACULA_LABEL; - if (!rewind_dev(dev)) { - Mmsg(&jcr->errmsg, _("Couldn't rewind device %s ERR=%s\n"), dev_name(dev), - strerror_dev(dev)); - return jcr->label_status = VOL_NO_MEDIA; + if (!dev->rewind(dcr)) { + Mmsg(jcr->errmsg, _("Couldn't rewind device %s: ERR=%s\n"), + dev->print_name(), dev->print_errmsg()); + Dmsg1(30, "return VOL_NO_MEDIA: %s", jcr->errmsg); + return VOL_NO_MEDIA; } bstrncpy(dev->VolHdr.Id, "**error**", sizeof(dev->VolHdr.Id)); - /* Read the Volume label block */ + /* Read ANSI/IBM label if so requested */ + + want_ansi_label = dcr->VolCatInfo.LabelType != B_BACULA_LABEL || + dcr->device->label_type != B_BACULA_LABEL; + if (want_ansi_label || dev->has_cap(CAP_CHECKLABELS)) { + stat = read_ansi_ibm_label(dcr); + /* If we want a label and didn't find it, return error */ + if (want_ansi_label && stat != VOL_OK) { + goto bail_out; + } + if (stat == VOL_NAME_ERROR || stat == VOL_LABEL_ERROR) { + Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"), + dev->print_name(), VolName, dev->VolHdr.VolumeName); + if (!dev->poll && jcr->label_errors++ > 100) { + Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg); + } + goto bail_out; + } + if (stat != VOL_OK) { /* Not an ANSI/IBM label, so re-read */ + dev->rewind(dcr); + } else { + have_ansi_label = true; + } + } + + /* Read the Bacula Volume label block */ record = new_record(); + empty_block(block); + Dmsg0(90, "Big if statement in read_volume_label\n"); - if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) { - Mmsg(&jcr->errmsg, _("Requested Volume \"%s\" on %s is not a Bacula " - "labeled Volume, because: ERR=%s"), NPRT(VolName), dev_name(dev), - strerror_dev(dev)); - } else if (!read_record_from_block(block, record)) { - Mmsg(&jcr->errmsg, _("Could not read Volume label from block.\n")); + if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) { + Mmsg(jcr->errmsg, _("Requested Volume \"%s\" on %s is not a Bacula " + "labeled Volume, because: ERR=%s"), NPRT(VolName), + dev->print_name(), dev->print_errmsg()); + Dmsg1(30, "%s", jcr->errmsg); + } else if (!read_record_from_block(dcr, block, record)) { + Mmsg(jcr->errmsg, _("Could not read Volume label from block.\n")); + Dmsg1(30, "%s", jcr->errmsg); } else if (!unser_volume_label(dev, record)) { - Mmsg(&jcr->errmsg, _("Could not unserialize Volume label: ERR=%s\n"), - strerror_dev(dev)); - } else if (strcmp(dev->VolHdr.Id, BaculaId) != 0 && - strcmp(dev->VolHdr.Id, OldBaculaId) != 0) { - Mmsg(&jcr->errmsg, _("Volume Header Id bad: %s\n"), dev->VolHdr.Id); + Mmsg(jcr->errmsg, _("Could not unserialize Volume label: ERR=%s\n"), + dev->print_errmsg()); + Dmsg1(30, "%s", jcr->errmsg); + } else if (strcmp(dev->VolHdr.Id, BaculaId) != 0 && + strcmp(dev->VolHdr.Id, OldBaculaId) != 0) { + Mmsg(jcr->errmsg, _("Volume Header Id bad: %s\n"), dev->VolHdr.Id); + Dmsg1(30, "%s", jcr->errmsg); } else { - ok = 1; + ok = true; } + free_record(record); /* finished reading Volume record */ + if (!ok) { - free_record(record); if (forge_on || jcr->ignore_label_errors) { - dev->state |= ST_LABEL; /* set has Bacula label */ + dev->set_labeled(); /* set has Bacula label */ Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg); - return jcr->label_status = VOL_OK; + empty_block(block); + return VOL_OK; } - empty_block(block); - rewind_dev(dev); - return jcr->label_status = VOL_NO_LABEL; + Dmsg0(100, "No volume label - bailing out\n"); + stat = VOL_NO_LABEL; + goto bail_out; } - free_record(record); - /* If we are a streaming device, we only get one chance to read */ - if (!dev_cap(dev, CAP_STREAM)) { - empty_block(block); - rewind_dev(dev); - } + /* At this point, we have read the first Bacula block, and + * then read the Bacula Volume label. Now we need to + * make sure we have the right Volume. + */ - if (dev->VolHdr.VerNum != BaculaTapeVersion && - dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion1 && + + if (dev->VolHdr.VerNum != BaculaTapeVersion && + dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion1 && dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion2) { - Mmsg(&jcr->errmsg, _("Volume on %s has wrong Bacula version. Wanted %d got %d\n"), - dev_name(dev), BaculaTapeVersion, dev->VolHdr.VerNum); - return jcr->label_status = VOL_VERSION_ERROR; + Mmsg(jcr->errmsg, _("Volume on %s has wrong Bacula version. Wanted %d got %d\n"), + dev->print_name(), BaculaTapeVersion, dev->VolHdr.VerNum); + Dmsg1(30, "VOL_VERSION_ERROR: %s", jcr->errmsg); + stat = VOL_VERSION_ERROR; + goto bail_out; } /* We are looking for either an unused Bacula tape (PRE_LABEL) or * a Bacula volume label (VOL_LABEL) */ if (dev->VolHdr.LabelType != PRE_LABEL && dev->VolHdr.LabelType != VOL_LABEL) { - Mmsg(&jcr->errmsg, _("Volume on %s has bad Bacula label type: %x\n"), - dev_name(dev), dev->VolHdr.LabelType); - return jcr->label_status = VOL_LABEL_ERROR; + Mmsg(jcr->errmsg, _("Volume on %s has bad Bacula label type: %x\n"), + dev->print_name(), dev->VolHdr.LabelType); + Dmsg1(30, "%s", jcr->errmsg); + if (!dev->poll && jcr->label_errors++ > 100) { + Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg); + } + Dmsg0(150, "return VOL_LABEL_ERROR\n"); + stat = VOL_LABEL_ERROR; + goto bail_out; } - dev->state |= ST_LABEL; /* set has Bacula label */ + dev->set_labeled(); /* set has Bacula label */ + new_volume(dcr, dev->VolHdr.VolumeName); /* Compare Volume Names */ - Dmsg2(30, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolName); - if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolName, VolName) != 0) { - Mmsg(&jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"), - dev_name(dev), VolName, dev->VolHdr.VolName); + Dmsg2(30, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolumeName); + if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolumeName, VolName) != 0) { + Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"), + dev->print_name(), VolName, dev->VolHdr.VolumeName); + Dmsg1(30, "%s", jcr->errmsg); /* * Cancel Job if too many label errors * => we are in a loop */ - if (jcr->label_errors++ > 100) { - Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg); + if (!dev->poll && jcr->label_errors++ > 100) { + Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg); } - return jcr->label_status = VOL_NAME_ERROR; + Dmsg0(150, "return VOL_NAME_ERROR\n"); + stat = VOL_NAME_ERROR; + goto bail_out; } - Dmsg1(30, "Copy vol_name=%s\n", dev->VolHdr.VolName); + Dmsg1(30, "Copy vol_name=%s\n", dev->VolHdr.VolumeName); if (debug_level >= 10) { dump_volume_label(dev); } Dmsg0(30, "Leave read_volume_label() VOL_OK\n"); - return jcr->label_status = VOL_OK; + /* If we are a streaming device, we only get one chance to read */ + if (!dev->has_cap(CAP_STREAM)) { + dev->rewind(dcr); + if (have_ansi_label) { + stat = read_ansi_ibm_label(dcr); + /* If we want a label and didn't find it, return error */ + if (stat != VOL_OK) { + goto bail_out; + } + } + } + empty_block(block); + return VOL_OK; + +bail_out: + empty_block(block); + dev->rewind(dcr); + Dmsg1(150, "return %d\n", stat); + return stat; } -/* unser_volume_label - * - * Unserialize the Volume label into the device Volume_Label - * structure. - * - * Assumes that the record is already read. +/* + * Put a volume label into the block * - * Returns: 0 on error - * 1 on success -*/ + * Returns: false on failure + * true on success + */ +bool write_volume_label_to_block(DCR *dcr) +{ + DEV_RECORD rec; + DEVICE *dev = dcr->dev; + JCR *jcr = dcr->jcr; + DEV_BLOCK *block = dcr->block; + + Dmsg0(20, "write Label in write_volume_label_to_block()\n"); + memset(&rec, 0, sizeof(rec)); + rec.data = get_memory(SER_LENGTH_Volume_Label); + empty_block(block); /* Volume label always at beginning */ + + create_volume_label_record(dcr, &rec); -int unser_volume_label(DEVICE *dev, DEV_RECORD *rec) + block->BlockNumber = 0; + if (!write_record_to_block(block, &rec)) { + free_pool_memory(rec.data); + Jmsg1(jcr, M_FATAL, 0, _("Cannot write Volume label to block for device %s\n"), + dev->print_name()); + return false; + } else { + Dmsg1(90, "Wrote label of %d bytes to block\n", rec.data_len); + } + free_pool_memory(rec.data); + return true; +} + + +/* + * Write a Volume Label + * !!! Note, this is ONLY used for writing + * a fresh volume label. Any data + * after the label will be destroyed, + * in fact, we write the label 5 times !!!! + * + * This routine should be used only when labeling a blank tape. + */ +bool write_new_volume_label_to_dev(DCR *dcr, const char *VolName, + const char *PoolName, bool relabel, bool dvdnow) { - ser_declare; + DEVICE *dev = dcr->dev; - if (rec->FileIndex != VOL_LABEL && rec->FileIndex != PRE_LABEL) { - Mmsg3(&dev->errmsg, _("Expecting Volume Label, got FI=%s Stream=%s len=%d\n"), - FI_to_ascii(rec->FileIndex), - stream_to_ascii(rec->Stream, rec->FileIndex), - rec->data_len); + + Dmsg0(99, "write_volume_label()\n"); + empty_block(dcr->block); + + /* If relabeling, truncate the device */ + if (relabel && !dev->truncate(dcr)) { + goto bail_out; + } + + if (relabel) { + dev->close_part(dcr); /* make sure closed for rename */ + } + + /* Set the new filename for open, ... */ + bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName)); + bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName)); + Dmsg1(150, "New VolName=%s\n", VolName); + if (dev->open(dcr, OPEN_READ_WRITE) < 0) { + /* If device is not tape, attempt to create it */ + if (dev->is_tape() || dev->open(dcr, CREATE_READ_WRITE) < 0) { + goto bail_out; + } + } + Dmsg1(150, "Label type=%d\n", dev->label_type); + if (!dev->rewind(dcr)) { + free_volume(dev); + memset(&dev->VolHdr, 0, sizeof(dev->VolHdr)); + Dmsg2(30, "Bad status on %s from rewind: ERR=%s\n", dev->print_name(), dev->print_errmsg()); if (!forge_on) { - return 0; + goto bail_out; } } - dev->VolHdr.LabelType = rec->FileIndex; - dev->VolHdr.LabelSize = rec->data_len; + /* Create PRE_LABEL or VOL_LABEL if DVD */ + create_volume_label(dev, VolName, PoolName, dvdnow); + /* + * If we have already detected an ANSI label, re-read it + * to skip past it. Otherwise, we write a new one if + * so requested. + */ + if (dev->label_type != B_BACULA_LABEL) { + if (read_ansi_ibm_label(dcr) != VOL_OK) { + dev->rewind(dcr); + goto bail_out; + } + } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, VolName)) { + goto bail_out; + } - /* Unserialize the record into the Volume Header */ - rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label); - ser_begin(rec->data, SER_LENGTH_Volume_Label); - unser_string(dev->VolHdr.Id); - unser_uint32(dev->VolHdr.VerNum); + create_volume_label_record(dcr, dcr->rec); + dcr->rec->Stream = 0; - if (dev->VolHdr.VerNum >= 11) { - unser_btime(dev->VolHdr.label_btime); - unser_btime(dev->VolHdr.write_btime); - } else { /* old way */ - unser_float64(dev->VolHdr.label_date); - unser_float64(dev->VolHdr.label_time); + /* Temporarily mark in append state to enable writing */ + dev->set_append(); + if (!write_record_to_block(dcr->block, dcr->rec)) { + Dmsg2(30, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg()); + goto bail_out; + } else { + Dmsg2(30, "Wrote label of %d bytes to %s\n", dcr->rec->data_len, dev->print_name()); } - unser_float64(dev->VolHdr.write_date); /* Unused with VerNum >= 11 */ - unser_float64(dev->VolHdr.write_time); /* Unused with VerNum >= 11 */ - unser_string(dev->VolHdr.VolName); - unser_string(dev->VolHdr.PrevVolName); - unser_string(dev->VolHdr.PoolName); - unser_string(dev->VolHdr.PoolType); - unser_string(dev->VolHdr.MediaType); + Dmsg0(99, "Call write_block_to_dev()\n"); + if (!write_block_to_dev(dcr)) { + Dmsg2(30, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg()); + goto bail_out; + } - unser_string(dev->VolHdr.HostName); - unser_string(dev->VolHdr.LabelProg); - unser_string(dev->VolHdr.ProgVersion); - unser_string(dev->VolHdr.ProgDate); + /* Now commit block to DVD if we should write now */ + if (dev->is_dvd() && dvdnow) { + Dmsg1(150, "New VolName=%s\n", dev->VolCatInfo.VolCatName); + if (!dvd_write_part(dcr)) { + Dmsg2(30, "Bad DVD write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg()); + goto bail_out; + } + } - ser_end(rec->data, SER_LENGTH_Volume_Label); - Dmsg0(90, "ser_read_vol\n"); - if (debug_level >= 90) { - dump_volume_label(dev); + Dmsg0(99, " Wrote block to device\n"); + + if (dev->weof(1)) { + dev->set_labeled(); + write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName); } - return 1; + + if (debug_level >= 20) { + dump_volume_label(dev); + } + new_volume(dcr, VolName); + dev->clear_append(); /* remove append since this is PRE_LABEL */ + return true; + +bail_out: + free_volume(dev); + memset(&dev->VolHdr, 0, sizeof(dev->VolHdr)); + dev->clear_append(); /* remove append since this is PRE_LABEL */ + return false; } /* - * Put a volume label into the block - * - * Returns: false on failure - * true on success + * Write a volume label. This is ONLY called if we have a valid Bacula + * label of type PRE_LABEL; + * Returns: true if OK + * false if unable to write it */ -bool write_volume_label_to_block(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) +bool rewrite_volume_label(DCR *dcr, bool recycle) { - DEV_RECORD rec; + DEVICE *dev = dcr->dev; + JCR *jcr = dcr->jcr; - Dmsg0(20, "write Label in write_volume_label_to_block()\n"); - memset(&rec, 0, sizeof(rec)); - rec.data = get_memory(SER_LENGTH_Volume_Label); + if (dev->open(dcr, OPEN_READ_WRITE) < 0) { + return false; + } + Dmsg2(190, "set append found freshly labeled volume. fd=%d dev=%x\n", dev->fd, dev); + dev->VolHdr.LabelType = VOL_LABEL; /* set Volume label */ + dev->set_append(); + if (!write_volume_label_to_block(dcr)) { + Dmsg0(200, "Error from write volume label.\n"); + return false; + } - create_volume_label_record(jcr, dev, &rec); + dev->VolCatInfo.VolCatBytes = 0; /* reset byte count */ - empty_block(block); /* Volume label always at beginning */ - block->BlockNumber = 0; - if (!write_record_to_block(block, &rec)) { - free_pool_memory(rec.data); - Jmsg1(jcr, M_FATAL, 0, _("Cannot write Volume label to block for device %s\n"), - dev_name(dev)); + /* + * If we are not dealing with a streaming device, + * write the block now to ensure we have write permission. + * It is better to find out now rather than later. + * We do not write the block now if this is an ANSI label. This + * avoids re-writing the ANSI label, which we do not want to do. + */ + if (!dev->has_cap(CAP_STREAM)) { + if (!dev->rewind(dcr)) { + Jmsg2(jcr, M_FATAL, 0, _("Rewind error on device %s: ERR=%s\n"), + dev->print_name(), dev->print_errmsg()); + return false; + } + if (recycle) { + if (!dev->truncate(dcr)) { + Jmsg2(jcr, M_FATAL, 0, _("Truncate error on device %s: ERR=%s\n"), + dev->print_name(), dev->print_errmsg()); + return false; + } + if (dev->open(dcr, OPEN_READ_WRITE) < 0) { + Jmsg2(jcr, M_FATAL, 0, + _("Failed to re-open DVD after truncate on device %s: ERR=%s\n"), + dev->print_name(), dev->print_errmsg()); + return false; + } + } + + /* + * If we have already detected an ANSI label, re-read it + * to skip past it. Otherwise, we write a new one if + * so requested. + */ + if (dev->label_type != B_BACULA_LABEL) { + if (read_ansi_ibm_label(dcr) != VOL_OK) { + dev->rewind(dcr); + return false; + } + } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, dev->VolHdr.VolumeName)) { + return false; + } + + /* Attempt write to check write permission */ + Dmsg1(200, "Attempt to write to device fd=%d.\n", dev->fd); + if (!write_block_to_dev(dcr)) { + Jmsg2(jcr, M_ERROR, 0, _("Unable to write device %s: ERR=%s\n"), + dev->print_name(), dev->print_errmsg()); + Dmsg0(200, "===ERROR write block to dev\n"); + return false; + } + } + dev->set_labeled(); + /* Set or reset Volume statistics */ + dev->VolCatInfo.VolCatJobs = 0; + dev->VolCatInfo.VolCatFiles = 0; + dev->VolCatInfo.VolCatErrors = 0; + dev->VolCatInfo.VolCatBlocks = 0; + dev->VolCatInfo.VolCatRBytes = 0; + if (recycle) { + dev->VolCatInfo.VolCatMounts++; + dev->VolCatInfo.VolCatRecycles++; + } else { + dev->VolCatInfo.VolCatMounts = 1; + dev->VolCatInfo.VolCatRecycles = 0; + dev->VolCatInfo.VolCatWrites = 1; + dev->VolCatInfo.VolCatReads = 1; + } + Dmsg0(150, "dir_update_vol_info. Set Append\n"); + bstrncpy(dev->VolCatInfo.VolCatStatus, "Append", sizeof(dev->VolCatInfo.VolCatStatus)); + if (!dir_update_volume_info(dcr, true)) { /* indicate doing relabel */ return false; + } + if (recycle) { + Jmsg(jcr, M_INFO, 0, _("Recycled volume \"%s\" on device %s, all previous data lost.\n"), + dcr->VolumeName, dev->print_name()); } else { - Dmsg1(90, "Wrote label of %d bytes to block\n", rec.data_len); + Jmsg(jcr, M_INFO, 0, _("Wrote label to prelabeled Volume \"%s\" on device %s\n"), + dcr->VolumeName, dev->print_name()); } - free_pool_memory(rec.data); + /* + * End writing real Volume label (from pre-labeled tape), or recycling + * the volume. + */ + Dmsg0(200, "OK from rewrite vol label.\n"); return true; } -/* + +/* * create_volume_label_record * Serialize label (from dev->VolHdr structure) into device record. - * Assumes that the dev->VolHdr structure is properly + * Assumes that the dev->VolHdr structure is properly * initialized. */ -static void create_volume_label_record(JCR *jcr, DEVICE *dev, DEV_RECORD *rec) +static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec) { ser_declare; struct date_time dt; + DEVICE *dev = dcr->dev; + JCR *jcr = dcr->jcr; + char buf[100]; /* Serialize the label into the device record. */ @@ -299,10 +553,10 @@ static void create_volume_label_record(JCR *jcr, DEVICE *dev, DEV_RECORD *rec) dev->VolHdr.write_time = dt.julian_day_fraction; } ser_float64(dev->VolHdr.write_date); /* 0 if VerNum >= 11 */ - ser_float64(dev->VolHdr.write_time); /* 0 if VerNum >= 11 */ + ser_float64(dev->VolHdr.write_time); /* 0 if VerNum >= 11 */ - ser_string(dev->VolHdr.VolName); - ser_string(dev->VolHdr.PrevVolName); + ser_string(dev->VolHdr.VolumeName); + ser_string(dev->VolHdr.PrevVolumeName); ser_string(dev->VolHdr.PoolName); ser_string(dev->VolHdr.PoolType); ser_string(dev->VolHdr.MediaType); @@ -317,18 +571,17 @@ static void create_volume_label_record(JCR *jcr, DEVICE *dev, DEV_RECORD *rec) rec->FileIndex = dev->VolHdr.LabelType; rec->VolSessionId = jcr->VolSessionId; rec->VolSessionTime = jcr->VolSessionTime; - rec->Stream = jcr->NumVolumes; - Dmsg2(100, "Created Vol label rec: FI=%s len=%d\n", FI_to_ascii(rec->FileIndex), + rec->Stream = jcr->NumWriteVolumes; + Dmsg2(150, "Created Vol label rec: FI=%s len=%d\n", FI_to_ascii(buf, rec->FileIndex), rec->data_len); -} +} /* * Create a volume label in memory - * Returns: 0 on error - * 1 on success */ -void create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName) +void create_volume_label(DEVICE *dev, const char *VolName, + const char *PoolName, bool dvdnow) { DEVRES *device = (DEVRES *)dev->device; @@ -336,12 +589,18 @@ void create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName) ASSERT(dev != NULL); + free_volume(dev); /* release any old volume */ memset(&dev->VolHdr, 0, sizeof(dev->VolHdr)); bstrncpy(dev->VolHdr.Id, BaculaId, sizeof(dev->VolHdr.Id)); dev->VolHdr.VerNum = BaculaTapeVersion; - dev->VolHdr.LabelType = PRE_LABEL; /* Mark tape as unused */ - bstrncpy(dev->VolHdr.VolName, VolName, sizeof(dev->VolHdr.VolName)); + if (dev->is_dvd() && dvdnow) { + /* We do not want to re-label a DVD so write VOL_LABEL now */ + dev->VolHdr.LabelType = VOL_LABEL; + } else { + dev->VolHdr.LabelType = PRE_LABEL; /* Mark tape as unused */ + } + bstrncpy(dev->VolHdr.VolumeName, VolName, sizeof(dev->VolHdr.VolumeName)); bstrncpy(dev->VolHdr.PoolName, PoolName, sizeof(dev->VolHdr.PoolName)); bstrncpy(dev->VolHdr.MediaType, device->media_type, sizeof(dev->VolHdr.MediaType)); @@ -357,90 +616,24 @@ void create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName) bstrncpy(dev->VolHdr.LabelProg, my_name, sizeof(dev->VolHdr.LabelProg)); sprintf(dev->VolHdr.ProgVersion, "Ver. %s %s", VERSION, BDATE); sprintf(dev->VolHdr.ProgDate, "Build %s %s", __DATE__, __TIME__); - dev->state |= ST_LABEL; /* set has Bacula label */ + dev->set_labeled(); /* set has Bacula label */ if (debug_level >= 90) { dump_volume_label(dev); } } -/* - * Write a Volume Label - * !!! Note, this is ONLY used for writing - * a fresh volume label. Any data - * after the label will be destroyed, - * in fact, we write the label 5 times !!!! - * - * This routine expects that open_device() was previously called. - * - * This routine should be used only when labeling a blank tape. - */ -bool write_new_volume_label_to_dev(JCR *jcr, DEVICE *dev, const char *VolName, const char *PoolName) -{ - DEV_RECORD rec; - DEV_BLOCK *block; - bool stat = true; - - - Dmsg0(99, "write_volume_label()\n"); - create_volume_label(dev, VolName, PoolName); - - if (!rewind_dev(dev)) { - memset(&dev->VolHdr, 0, sizeof(dev->VolHdr)); - Dmsg2(30, "Bad status on %s from rewind. ERR=%s\n", dev_name(dev), strerror_dev(dev)); - if (!forge_on) { - return false; - } - } - - block = new_block(dev); - memset(&rec, 0, sizeof(rec)); - rec.data = get_memory(SER_LENGTH_Volume_Label); - create_volume_label_record(jcr, dev, &rec); - rec.Stream = 0; - - if (!write_record_to_block(block, &rec)) { - Dmsg2(30, "Bad Label write on %s. ERR=%s\n", dev_name(dev), strerror_dev(dev)); - memset(&dev->VolHdr, 0, sizeof(dev->VolHdr)); - free_block(block); - free_pool_memory(rec.data); - return false; - } else { - Dmsg2(30, "Wrote label of %d bytes to %s\n", rec.data_len, dev_name(dev)); - } - free_pool_memory(rec.data); - - Dmsg0(99, "Call write_block_to_dev()\n"); - if (!write_block_to_dev(jcr->dcr, block)) { - memset(&dev->VolHdr, 0, sizeof(dev->VolHdr)); - Dmsg2(30, "Bad Label write on %s. ERR=%s\n", dev_name(dev), strerror_dev(dev)); - stat = false; - } - Dmsg0(99, " Wrote block to device\n"); - - flush_dev(dev); - weof_dev(dev, 1); - dev->state |= ST_LABEL; - - if (debug_level >= 20) { - dump_volume_label(dev); - } - free_block(block); - return stat; -} - - /* * Create session label * The pool memory must be released by the calling program */ -void create_session_label(JCR *jcr, DEV_RECORD *rec, int label) +void create_session_label(DCR *dcr, DEV_RECORD *rec, int label) { - DCR *dcr = jcr->dcr; + JCR *jcr = dcr->jcr; ser_declare; rec->VolSessionId = jcr->VolSessionId; rec->VolSessionTime = jcr->VolSessionTime; - rec->Stream = jcr->JobId; + rec->Stream = jcr->JobId; rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label); ser_begin(rec->data, SER_LENGTH_Session_Label); @@ -453,13 +646,13 @@ void create_session_label(JCR *jcr, DEV_RECORD *rec, int label) ser_btime(get_current_btime()); ser_float64(0); - ser_string(jcr->pool_name); - ser_string(jcr->pool_type); - ser_string(jcr->job_name); /* base Job name */ + ser_string(dcr->pool_name); + ser_string(dcr->pool_type); + ser_string(jcr->job_name); /* base Job name */ ser_string(jcr->client_name); /* Added in VerNum 10 */ - ser_string(jcr->Job); /* Unique name of this Job */ + ser_string(jcr->Job); /* Unique name of this Job */ ser_string(jcr->fileset_name); ser_uint32(jcr->JobType); ser_uint32(jcr->JobLevel); @@ -483,44 +676,46 @@ void create_session_label(JCR *jcr, DEV_RECORD *rec, int label) } /* Write session label - * Returns: 0 on failure - * 1 on success + * Returns: false on failure + * true on success */ -int write_session_label(JCR *jcr, DEV_BLOCK *block, int label) +bool write_session_label(DCR *dcr, int label) { - DEVICE *dev = jcr->device->dev; - DCR *dcr = jcr->dcr; + JCR *jcr = dcr->jcr; + DEVICE *dev = dcr->dev; DEV_RECORD *rec; + DEV_BLOCK *block = dcr->block; + char buf1[100], buf2[100]; rec = new_record(); Dmsg1(90, "session_label record=%x\n", rec); switch (label) { case SOS_LABEL: - if (dev->state & ST_TAPE) { - dcr->StartBlock = dev->block_num; - dcr->StartFile = dev->file; + if (dev->is_tape()) { + dcr->StartBlock = dev->block_num; + dcr->StartFile = dev->file; } else { - dcr->StartBlock = (uint32_t)dev->file_addr; - dcr->StartFile = (uint32_t)(dev->file_addr >> 32); + dcr->StartBlock = (uint32_t)dev->file_addr; + dcr->StartFile = (uint32_t)(dev->file_addr >> 32); } break; case EOS_LABEL: - if (dev->state & ST_TAPE) { - dcr->EndBlock = dev->EndBlock; - dcr->EndFile = dev->EndFile; + if (dev->is_tape()) { + dcr->EndBlock = dev->EndBlock; + dcr->EndFile = dev->EndFile; } else { - dcr->EndBlock = (uint32_t)dev->file_addr; - dcr->EndFile = (uint32_t)(dev->file_addr >> 32); + dcr->EndBlock = (uint32_t)dev->file_addr; + dcr->EndFile = (uint32_t)(dev->file_addr >> 32); } break; default: Jmsg1(jcr, M_ABORT, 0, _("Bad session label = %d\n"), label); break; } - create_session_label(jcr, rec, label); + create_session_label(dcr, rec, label); rec->FileIndex = label; - /* + /* * We guarantee that the session record can totally fit * into a block. If not, write the block, and put it in * the next block. Having the sesssion record totally in @@ -528,107 +723,102 @@ int write_session_label(JCR *jcr, DEV_BLOCK *block, int label) * read the next block). */ if (!can_write_record_to_block(block, rec)) { - Dmsg0(100, "Cannot write session label to block.\n"); - if (!write_block_to_device(jcr->dcr, block)) { + Dmsg0(150, "Cannot write session label to block.\n"); + if (!write_block_to_device(dcr)) { Dmsg0(90, "Got session label write_block_to_dev error.\n"); - Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"), - dev_vol_name(dev), strerror(errno)); - free_record(rec); - return 0; + /* ****FIXME***** errno is not set here */ + Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"), + dev_vol_name(dev), strerror(errno)); + free_record(rec); + return false; } } if (!write_record_to_block(block, rec)) { - Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"), - dev_vol_name(dev), strerror(errno)); + Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"), + dev_vol_name(dev), strerror(errno)); free_record(rec); - return 0; + return false; } - Dmsg6(20, "Write sesson_label record JobId=%d FI=%s SessId=%d Strm=%s len=%d\n\ -remainder=%d\n", jcr->JobId, - FI_to_ascii(rec->FileIndex), rec->VolSessionId, - stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len, + Dmsg6(50, "Write sesson_label record JobId=%d FI=%s SessId=%d Strm=%s len=%d " + "remainder=%d\n", jcr->JobId, + FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, + stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len, rec->remainder); free_record(rec); - Dmsg2(20, "Leave write_session_label Block=%d File=%d\n", - dev->block_num, dev->file); - return 1; + Dmsg2(50, "Leave write_session_label Block=%ud File=%ud\n", + dev->get_block(), dev->get_file()); + return true; } -void dump_volume_label(DEVICE *dev) +/* unser_volume_label + * + * Unserialize the Bacula Volume label into the device Volume_Label + * structure. + * + * Assumes that the record is already read. + * + * Returns: false on error + * true on success +*/ + +bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec) { - int dbl = debug_level; - uint32_t File; - const char *LabelType; - char buf[30]; - struct tm tm; - struct date_time dt; + ser_declare; + char buf1[100], buf2[100]; - debug_level = 1; - File = dev->file; - switch (dev->VolHdr.LabelType) { - case PRE_LABEL: - LabelType = "PRE_LABEL"; - break; - case VOL_LABEL: - LabelType = "VOL_LABEL"; - break; - case EOM_LABEL: - LabelType = "EOM_LABEL"; - break; - case SOS_LABEL: - LabelType = "SOS_LABEL"; - break; - case EOS_LABEL: - LabelType = "EOS_LABEL"; - break; - case EOT_LABEL: - goto bail_out; - default: - LabelType = buf; - sprintf(buf, "Unknown %d", dev->VolHdr.LabelType); - break; - } - - - Pmsg11(-1, "\nVolume Label:\n\ -Id : %s\ -VerNo : %d\n\ -VolName : %s\n\ -PrevVolName : %s\n\ -VolFile : %d\n\ -LabelType : %s\n\ -LabelSize : %d\n\ -PoolName : %s\n\ -MediaType : %s\n\ -PoolType : %s\n\ -HostName : %s\n\ -", - dev->VolHdr.Id, dev->VolHdr.VerNum, - dev->VolHdr.VolName, dev->VolHdr.PrevVolName, - File, LabelType, dev->VolHdr.LabelSize, - dev->VolHdr.PoolName, dev->VolHdr.MediaType, - dev->VolHdr.PoolType, dev->VolHdr.HostName); + if (rec->FileIndex != VOL_LABEL && rec->FileIndex != PRE_LABEL) { + Mmsg3(dev->errmsg, _("Expecting Volume Label, got FI=%s Stream=%s len=%d\n"), + FI_to_ascii(buf1, rec->FileIndex), + stream_to_ascii(buf2, rec->Stream, rec->FileIndex), + rec->data_len); + if (!forge_on) { + return false; + } + } + + dev->VolHdr.LabelType = rec->FileIndex; + dev->VolHdr.LabelSize = rec->data_len; + + + /* Unserialize the record into the Volume Header */ + rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label); + ser_begin(rec->data, SER_LENGTH_Volume_Label); + unser_string(dev->VolHdr.Id); + unser_uint32(dev->VolHdr.VerNum); if (dev->VolHdr.VerNum >= 11) { - char dt[50]; - bstrftime(dt, sizeof(dt), btime_to_unix(dev->VolHdr.label_btime)); - Pmsg1(-1, "Date label written: %s\n", dt); - } else { - dt.julian_day_number = dev->VolHdr.label_date; - dt.julian_day_fraction = dev->VolHdr.label_time; - tm_decode(&dt, &tm); - Pmsg5(-1, "\ -Date label written: %04d-%02d-%02d at %02d:%02d\n", - tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min); + unser_btime(dev->VolHdr.label_btime); + unser_btime(dev->VolHdr.write_btime); + } else { /* old way */ + unser_float64(dev->VolHdr.label_date); + unser_float64(dev->VolHdr.label_time); } + unser_float64(dev->VolHdr.write_date); /* Unused with VerNum >= 11 */ + unser_float64(dev->VolHdr.write_time); /* Unused with VerNum >= 11 */ -bail_out: - debug_level = dbl; + unser_string(dev->VolHdr.VolumeName); + unser_string(dev->VolHdr.PrevVolumeName); + unser_string(dev->VolHdr.PoolName); + unser_string(dev->VolHdr.PoolType); + unser_string(dev->VolHdr.MediaType); + + unser_string(dev->VolHdr.HostName); + unser_string(dev->VolHdr.LabelProg); + unser_string(dev->VolHdr.ProgVersion); + unser_string(dev->VolHdr.ProgDate); + + ser_end(rec->data, SER_LENGTH_Volume_Label); + Dmsg0(190, "unser_vol_label\n"); + if (debug_level >= 190) { + dump_volume_label(dev); + } + return true; } -int unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec) + +bool unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec) { ser_declare; @@ -648,7 +838,7 @@ int unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec) unser_string(label->JobName); unser_string(label->ClientName); if (label->VerNum >= 10) { - unser_string(label->Job); /* Unique name of this Job */ + unser_string(label->Job); /* Unique name of this Job */ unser_string(label->FileSetName); unser_uint32(label->JobType); unser_uint32(label->JobLevel); @@ -667,12 +857,83 @@ int unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec) unser_uint32(label->EndFile); unser_uint32(label->JobErrors); if (label->VerNum >= 11) { - unser_uint32(label->JobStatus); + unser_uint32(label->JobStatus); } else { - label->JobStatus = JS_Terminated; /* kludge */ + label->JobStatus = JS_Terminated; /* kludge */ } - } - return 1; + } + return true; +} + +void dump_volume_label(DEVICE *dev) +{ + int dbl = debug_level; + uint32_t File; + const char *LabelType; + char buf[30]; + struct tm tm; + struct date_time dt; + + debug_level = 1; + File = dev->file; + switch (dev->VolHdr.LabelType) { + case PRE_LABEL: + LabelType = "PRE_LABEL"; + break; + case VOL_LABEL: + LabelType = "VOL_LABEL"; + break; + case EOM_LABEL: + LabelType = "EOM_LABEL"; + break; + case SOS_LABEL: + LabelType = "SOS_LABEL"; + break; + case EOS_LABEL: + LabelType = "EOS_LABEL"; + break; + case EOT_LABEL: + goto bail_out; + default: + LabelType = buf; + sprintf(buf, _("Unknown %d"), dev->VolHdr.LabelType); + break; + } + + Pmsg11(-1, _("\nVolume Label:\n" +"Id : %s" +"VerNo : %d\n" +"VolName : %s\n" +"PrevVolName : %s\n" +"VolFile : %d\n" +"LabelType : %s\n" +"LabelSize : %d\n" +"PoolName : %s\n" +"MediaType : %s\n" +"PoolType : %s\n" +"HostName : %s\n" +""), + dev->VolHdr.Id, dev->VolHdr.VerNum, + dev->VolHdr.VolumeName, dev->VolHdr.PrevVolumeName, + File, LabelType, dev->VolHdr.LabelSize, + dev->VolHdr.PoolName, dev->VolHdr.MediaType, + dev->VolHdr.PoolType, dev->VolHdr.HostName); + + if (dev->VolHdr.VerNum >= 11) { + char dt[50]; + bstrftime(dt, sizeof(dt), btime_to_unix(dev->VolHdr.label_btime)); + Pmsg1(-1, _("Date label written: %s\n"), dt); + } else { + dt.julian_day_number = dev->VolHdr.label_date; + dt.julian_day_fraction = dev->VolHdr.label_time; + tm_decode(&dt, &tm); + Pmsg5(-1, +_("Date label written: %04d-%02d-%02d at %02d:%02d\n"), + tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min); + } + +bail_out: + debug_level = dbl; } @@ -687,45 +948,45 @@ static void dump_session_label(DEV_RECORD *rec, const char *type) unser_session_label(&label, rec); dbl = debug_level; debug_level = 1; - Pmsg7(-1, "\n%s Record:\n\ -JobId : %d\n\ -VerNum : %d\n\ -PoolName : %s\n\ -PoolType : %s\n\ -JobName : %s\n\ -ClientName : %s\n\ -", type, label.JobId, label.VerNum, + Pmsg7(-1, _("\n%s Record:\n" +"JobId : %d\n" +"VerNum : %d\n" +"PoolName : %s\n" +"PoolType : %s\n" +"JobName : %s\n" +"ClientName : %s\n" +""), type, label.JobId, label.VerNum, label.PoolName, label.PoolType, label.JobName, label.ClientName); if (label.VerNum >= 10) { - Pmsg4(-1, "\ -Job (unique name) : %s\n\ -FileSet : %s\n\ -JobType : %c\n\ -JobLevel : %c\n\ -", label.Job, label.FileSetName, label.JobType, label.JobLevel); + Pmsg4(-1, _( +"Job (unique name) : %s\n" +"FileSet : %s\n" +"JobType : %c\n" +"JobLevel : %c\n" +""), label.Job, label.FileSetName, label.JobType, label.JobLevel); } if (rec->FileIndex == EOS_LABEL) { - Pmsg8(-1, "\ -JobFiles : %s\n\ -JobBytes : %s\n\ -StartBlock : %s\n\ -EndBlock : %s\n\ -StartFile : %s\n\ -EndFile : %s\n\ -JobErrors : %s\n\ -JobStatus : %c\n\ -", - edit_uint64_with_commas(label.JobFiles, ec1), - edit_uint64_with_commas(label.JobBytes, ec2), - edit_uint64_with_commas(label.StartBlock, ec3), - edit_uint64_with_commas(label.EndBlock, ec4), - edit_uint64_with_commas(label.StartFile, ec5), - edit_uint64_with_commas(label.EndFile, ec6), - edit_uint64_with_commas(label.JobErrors, ec7), - label.JobStatus); + Pmsg8(-1, _( +"JobFiles : %s\n" +"JobBytes : %s\n" +"StartBlock : %s\n" +"EndBlock : %s\n" +"StartFile : %s\n" +"EndFile : %s\n" +"JobErrors : %s\n" +"JobStatus : %c\n" +""), + edit_uint64_with_commas(label.JobFiles, ec1), + edit_uint64_with_commas(label.JobBytes, ec2), + edit_uint64_with_commas(label.StartBlock, ec3), + edit_uint64_with_commas(label.EndBlock, ec4), + edit_uint64_with_commas(label.StartFile, ec5), + edit_uint64_with_commas(label.EndFile, ec6), + edit_uint64_with_commas(label.JobErrors, ec7), + label.JobStatus); } if (label.VerNum >= 11) { char dt[50]; @@ -735,8 +996,7 @@ JobStatus : %c\n\ dt.julian_day_number = label.write_date; dt.julian_day_fraction = label.write_time; tm_decode(&dt, &tm); - Pmsg5(-1, _("\ -Date written : %04d-%02d-%02d at %02d:%02d\n"), + Pmsg5(-1, _("Date written : %04d-%02d-%02d at %02d:%02d\n"), tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min); } @@ -748,76 +1008,95 @@ void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose) const char *type; int dbl; + if (rec->FileIndex == 0 && rec->VolSessionId == 0 && rec->VolSessionTime == 0) { + return; + } dbl = debug_level; debug_level = 1; switch (rec->FileIndex) { + case PRE_LABEL: + type = _("Fresh Volume"); + break; + case VOL_LABEL: + type = _("Volume"); + break; + case SOS_LABEL: + type = _("Begin Job Session"); + break; + case EOS_LABEL: + type = _("End Job Session"); + break; + case EOM_LABEL: + type = _("End of Media"); + break; + case EOT_LABEL: + type = _("End of Tape"); + break; + default: + type = _("Unknown"); + break; + } + if (verbose) { + switch (rec->FileIndex) { case PRE_LABEL: - type = _("Fresh Volume"); - break; case VOL_LABEL: - type = _("Volume"); - break; + unser_volume_label(dev, rec); + dump_volume_label(dev); + break; case SOS_LABEL: - type = _("Begin Session"); - break; + dump_session_label(rec, type); + break; case EOS_LABEL: - type = _("End Session"); - break; + dump_session_label(rec, type); + break; case EOM_LABEL: - type = _("End of Media"); - break; + Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"), + type, dev->file, dev->block_num, rec->VolSessionId, + rec->VolSessionTime, rec->Stream, rec->data_len); + break; case EOT_LABEL: - type = ("End of Tape"); - break; + Pmsg0(-1, _("End of physical tape.\n")); + break; default: - type = _("Unknown"); - break; - } - if (verbose) { - switch (rec->FileIndex) { - case PRE_LABEL: - case VOL_LABEL: - unser_volume_label(dev, rec); - dump_volume_label(dev); - break; - case SOS_LABEL: - dump_session_label(rec, type); - break; - case EOS_LABEL: - dump_session_label(rec, type); - break; - case EOM_LABEL: - Pmsg5(-1, "%s Record: SessId=%d SessTime=%d JobId=%d DataLen=%d\n", - type, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len); - break; - case EOT_LABEL: - Pmsg0(-1, _("End of physical tape.\n")); - break; - default: - Pmsg5(-1, "%s Record: SessId=%d SessTime=%d JobId=%d DataLen=%d\n", - type, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len); - break; + Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"), + type, dev->file, dev->block_num, rec->VolSessionId, + rec->VolSessionTime, rec->Stream, rec->data_len); + break; } } else { + SESSION_LABEL label; + char dt[50]; switch (rec->FileIndex) { - case SOS_LABEL: - case EOS_LABEL: - SESSION_LABEL label; - unser_session_label(&label, rec); - Pmsg6(-1, "%s Record: SessId=%d SessTime=%d JobId=%d Level=%c \ -Type=%c\n", - type, rec->VolSessionId, rec->VolSessionTime, rec->Stream, - label.JobLevel, label.JobType); - break; - case EOM_LABEL: - case PRE_LABEL: - case VOL_LABEL: - default: - Pmsg5(-1, "%s Record: SessId=%d SessTime=%d JobId=%d DataLen=%d\n", - type, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len); - break; - case EOT_LABEL: - break; + case SOS_LABEL: + unser_session_label(&label, rec); + bstrftimes(dt, sizeof(dt), btime_to_unix(label.write_btime)); + Pmsg6(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d\n"), + type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, label.JobId); + Pmsg4(-1, _(" Job=%s Date=%s Level=%c Type=%c\n"), + label.Job, dt, label.JobLevel, label.JobType); + break; + case EOS_LABEL: + char ed1[30], ed2[30]; + unser_session_label(&label, rec); + bstrftimes(dt, sizeof(dt), btime_to_unix(label.write_btime)); + Pmsg6(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d\n"), + type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, label.JobId); + Pmsg7(-1, _(" Date=%s Level=%c Type=%c Files=%s Bytes=%s Errors=%d Status=%c\n"), + dt, label.JobLevel, label.JobType, + edit_uint64_with_commas(label.JobFiles, ed1), + edit_uint64_with_commas(label.JobBytes, ed2), + label.JobErrors, (char)label.JobStatus); + break; + case EOM_LABEL: + case PRE_LABEL: + case VOL_LABEL: + default: + Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"), + type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, + rec->Stream, rec->data_len); + break; + case EOT_LABEL: + break; } } debug_level = dbl;