X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Flabel.c;h=236cc70067618f58169f55a32e5c4f80cfc2b70e;hb=f22306c4aa11062bf4fad4eb09b7c88c045efe66;hp=d997f234610abe28be33f70b5847daef5166ed53;hpb=93355f35e2993c6af637cc7ec8004b05ad91f942;p=bacula%2Fbacula diff --git a/bacula/src/stored/label.c b/bacula/src/stored/label.c index d997f23461..236cc70067 100644 --- a/bacula/src/stored/label.c +++ b/bacula/src/stored/label.c @@ -1,45 +1,36 @@ +/* + Bacula(R) - The Network Backup Solution + + Copyright (C) 2000-2017 Kern Sibbald + + The original author of Bacula is Kern Sibbald, with contributions + from many others, a complete list can be found in the file AUTHORS. + + You may use this file and others of this release according to the + license defined in the LICENSE file, which includes the Affero General + Public License, v3.0 ("AGPLv3") and some additional permissions and + terms pursuant to its AGPLv3 Section 7. + + This notice must be preserved when any source code is + conveyed and/or propagated. + + Bacula(R) is a registered trademark of Kern Sibbald. +*/ /* * * label.c Bacula routines to handle labels * * Kern Sibbald, MM * - * - * Version $Id$ */ -/* - Bacula® - The Network Backup Solution - - Copyright (C) 2000-2006 Free Software Foundation Europe e.V. - - 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 - 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., 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 */ +static const int dbglvl = 100; + /* Forward referenced functions */ -static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec); +static void create_volume_label_record(DCR *dcr, DEVICE *dev, DEV_RECORD *rec, bool adata); /* * Read the volume label @@ -60,14 +51,16 @@ static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec); * VOL_VERSION_ERROR label has wrong version * VOL_LABEL_ERROR bad label type * VOL_NO_MEDIA no media in drive + * VOL_TYPE_ERROR aligned/non-aligned/dedup error * * The dcr block is emptied on return, and the Volume is * rewound. + * + * Handle both the ameta and adata volumes. */ -int read_dev_volume_label(DCR *dcr) +int DEVICE::read_dev_volume_label(DCR *dcr) { JCR *jcr = dcr->jcr; - DEVICE *dev = dcr->dev; char *VolName = dcr->VolumeName; DEV_RECORD *record; bool ok = false; @@ -76,107 +69,103 @@ int read_dev_volume_label(DCR *dcr) 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*"); + Enter(dbglvl); + Dmsg5(dbglvl, "Enter read_volume_label adata=%d res=%d device=%s vol=%s dev_Vol=%s\n", + block->adata, num_reserved(), print_name(), VolName, + VolHdr.VolumeName[0]?VolHdr.VolumeName:"*NULL*"); - if (!dev->is_open()) { - if (dev->open(dcr, OPEN_READ_ONLY) < 0) { + if (!is_open()) { + if (!open_device(dcr, OPEN_READ_ONLY)) { + Leave(dbglvl); 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.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 VOL_OK; /* label already read */ - } - dev->clear_labeled(); - dev->clear_append(); - dev->clear_read(); - dev->label_type = B_BACULA_LABEL; + clear_labeled(); + clear_append(); + clear_read(); + label_type = B_BACULA_LABEL; - 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); + if (!rewind(dcr)) { + Mmsg(jcr->errmsg, _("Couldn't rewind %s device %s: ERR=%s\n"), + print_type(), print_name(), print_errmsg()); + Dmsg1(dbglvl, "return VOL_NO_MEDIA: %s", jcr->errmsg); + Leave(dbglvl); return VOL_NO_MEDIA; } - bstrncpy(dev->VolHdr.Id, "**error**", sizeof(dev->VolHdr.Id)); + bstrncpy(VolHdr.Id, "**error**", sizeof(VolHdr.Id)); /* 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_cap(dev, CAP_CHECKLABELS)) { - stat = read_ansi_ibm_label(dcr); + if (want_ansi_label || 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) { + Mmsg(jcr->errmsg, _("Wrong Volume mounted on %s device %s: Wanted %s have %s\n"), + print_type(), print_name(), VolName, VolHdr.VolumeName); + if (!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); + 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(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(block, record)) { + Dmsg0(130, "Big if statement in read_volume_label\n"); + dcr->reading_label = true; + if (!dcr->read_block_from_dev(NO_BLOCK_NUMBER_CHECK)) { + Mmsg(jcr->errmsg, _("Read label block failed: requested Volume \"%s\" on %s device %s is not a Bacula " + "labeled Volume, because: ERR=%s"), NPRT(VolName), + print_type(), print_name(), print_errmsg()); + Dmsg1(dbglvl, "%s", jcr->errmsg); + } else if (!read_record_from_block(dcr, record)) { Mmsg(jcr->errmsg, _("Could not read Volume label from block.\n")); - Dmsg1(30, "%s", jcr->errmsg); - } else if (!unser_volume_label(dev, record)) { + Dmsg1(dbglvl, "%s", jcr->errmsg); + } else if (!unser_volume_label(this, record)) { 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); + print_errmsg()); + Dmsg1(dbglvl, "%s", jcr->errmsg); + } else if (strcmp(VolHdr.Id, BaculaId) != 0 && + strcmp(VolHdr.Id, OldBaculaId) != 0 && + strcmp(VolHdr.Id, BaculaMetaDataId) != 0 && + strcmp(VolHdr.Id, BaculaAlignedDataId) != 0 && + strcmp(VolHdr.Id, BaculaS3CloudId) != 0) { + Mmsg(jcr->errmsg, _("Volume Header Id bad: %s\n"), VolHdr.Id); + Dmsg1(dbglvl, "%s", jcr->errmsg); } else { ok = true; + Dmsg1(dbglvl, "VolHdr.Id OK: %s\n", VolHdr.Id); } + dcr->reading_label = false; free_record(record); /* finished reading Volume record */ + if (!is_volume_to_unload()) { + clear_unload(); + } + if (!ok) { - if (forge_on || jcr->ignore_label_errors) { - dev->set_labeled(); /* set has Bacula label */ - Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg); + if (jcr->ignore_label_errors) { + set_labeled(); /* set has Bacula label */ + if (jcr->errmsg[0]) { + Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg); + } empty_block(block); + Leave(dbglvl); return VOL_OK; } - Dmsg0(100, "No volume label - bailing out\n"); + Dmsg0(dbglvl, "No volume label - bailing out\n"); stat = VOL_NO_LABEL; goto bail_out; } @@ -185,113 +174,172 @@ int read_dev_volume_label(DCR *dcr) * 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 && - dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion2) { - 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); + if (VolHdr.VerNum != BaculaTapeVersion && + VolHdr.VerNum != BaculaMetaDataVersion && + VolHdr.VerNum != BaculaS3CloudVersion && + VolHdr.VerNum != OldCompatibleBaculaTapeVersion1 && + VolHdr.VerNum != OldCompatibleBaculaTapeVersion2) { + Mmsg(jcr->errmsg, _("Volume on %s device %s has wrong Bacula version. Wanted %d got %d\n"), + print_type(), print_name(), BaculaTapeVersion, VolHdr.VerNum); + Dmsg1(dbglvl, "VOL_VERSION_ERROR: %s", jcr->errmsg); stat = VOL_VERSION_ERROR; goto bail_out; } + Dmsg1(dbglvl, "VolHdr.VerNum=%ld OK.\n", VolHdr.VerNum); /* 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->print_name(), dev->VolHdr.LabelType); - Dmsg1(30, "%s", jcr->errmsg); - if (!dev->poll && jcr->label_errors++ > 100) { + if (VolHdr.LabelType != PRE_LABEL && VolHdr.LabelType != VOL_LABEL) { + Mmsg(jcr->errmsg, _("Volume on %s device %s has bad Bacula label type: %ld\n"), + print_type(), print_name(), VolHdr.LabelType); + Dmsg1(dbglvl, "%s", jcr->errmsg); + if (!poll && jcr->label_errors++ > 100) { Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg); } - Dmsg0(150, "return VOL_LABEL_ERROR\n"); + Dmsg0(dbglvl, "return VOL_LABEL_ERROR\n"); stat = VOL_LABEL_ERROR; goto bail_out; } - dev->set_labeled(); /* set has Bacula label */ - new_volume(dcr, dev->VolHdr.VolumeName); + set_labeled(); /* set has Bacula label */ /* Compare Volume Names */ - 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); + Dmsg2(130, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", VolHdr.VolumeName); + if (VolName && *VolName && *VolName != '*' && strcmp(VolHdr.VolumeName, VolName) != 0) { + Mmsg(jcr->errmsg, _("Wrong Volume mounted on %s device %s: Wanted %s have %s\n"), + print_type(), print_name(), VolName, VolHdr.VolumeName); + Dmsg1(dbglvl, "%s", jcr->errmsg); /* * Cancel Job if too many label errors * => we are in a loop */ - if (!dev->poll && jcr->label_errors++ > 100) { + if (!poll && jcr->label_errors++ > 100) { Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg); } - Dmsg0(150, "return VOL_NAME_ERROR\n"); + Dmsg0(dbglvl, "return VOL_NAME_ERROR\n"); stat = VOL_NAME_ERROR; goto bail_out; } - Dmsg1(30, "Copy vol_name=%s\n", dev->VolHdr.VolumeName); - if (debug_level >= 10) { - dump_volume_label(dev); + /* Compare VolType to Device Type */ + switch (dev_type) { + case B_FILE_DEV: + if (strcmp(VolHdr.Id, BaculaId) != 0) { + Mmsg(jcr->errmsg, _("Wrong Volume Type. Wanted a File or Tape Volume %s on device %s, but got: %s\n"), + VolHdr.VolumeName, print_name(), VolHdr.Id); + stat = VOL_TYPE_ERROR; + goto bail_out; + } + break; + case B_ALIGNED_DEV: + case B_ADATA_DEV: + if (strcmp(VolHdr.Id, BaculaMetaDataId) != 0) { + Mmsg(jcr->errmsg, _("Wrong Volume Type. Wanted an Aligned Volume %s on device %s, but got: %s\n"), + VolHdr.VolumeName, print_name(), VolHdr.Id); + stat = VOL_TYPE_ERROR; + goto bail_out; + } + break; + case B_CLOUD_DEV: + if (strcmp(VolHdr.Id, BaculaS3CloudId) != 0) { + Mmsg(jcr->errmsg, _("Wrong Volume Type. Wanted a Cloud Volume %s on device %s, but got: %s\n"), + VolHdr.VolumeName, print_name(), VolHdr.Id); + stat = VOL_TYPE_ERROR; + goto bail_out; + } + default: + break; } - Dmsg0(30, "Leave read_volume_label() VOL_OK\n"); + + if (chk_dbglvl(100)) { + dump_volume_label(); + } + Dmsg0(dbglvl, "Leave read_volume_label() VOL_OK\n"); /* If we are a streaming device, we only get one chance to read */ - if (!dev_cap(dev, CAP_STREAM)) { - dev->rewind(dcr); + if (!has_cap(CAP_STREAM)) { + rewind(dcr); if (have_ansi_label) { - stat = read_ansi_ibm_label(dcr); + 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); + + Dmsg1(100, "Call reserve_volume=%s\n", VolHdr.VolumeName); + if (reserve_volume(dcr, VolHdr.VolumeName) == NULL) { + if (!jcr->errmsg[0]) { + Mmsg3(jcr->errmsg, _("Could not reserve volume %s on %s device %s\n"), + VolHdr.VolumeName, print_type(), print_name()); + } + Dmsg2(dbglvl, "Could not reserve volume %s on %s\n", VolHdr.VolumeName, print_name()); + stat = VOL_NAME_ERROR; + goto bail_out; + } + + if (dcr->is_writing()) { + empty_block(block); + } + + Leave(dbglvl); return VOL_OK; bail_out: empty_block(block); - dev->rewind(dcr); - Dmsg1(150, "return %d\n", stat); + rewind(dcr); + Dmsg2(dbglvl, "return stat=%d %s", stat, jcr->errmsg); + Leave(dbglvl); return stat; } + /* - * Put a volume label into the block + * Create and put a volume label into the block * * Returns: false on failure * true on success + * + * Handle both the ameta and adata volumes. */ -bool write_volume_label_to_block(DCR *dcr) +bool DEVICE::write_volume_label_to_block(DCR *dcr) { + DEVICE *dev; + DEV_BLOCK *block; DEV_RECORD rec; - DEVICE *dev = dcr->dev; JCR *jcr = dcr->jcr; - DEV_BLOCK *block = dcr->block; + bool ok = true; - Dmsg0(20, "write Label in write_volume_label_to_block()\n"); + Enter(100); + dev = dcr->dev; + block = dcr->block; memset(&rec, 0, sizeof(rec)); rec.data = get_memory(SER_LENGTH_Volume_Label); + memset(rec.data, 0, SER_LENGTH_Volume_Label); empty_block(block); /* Volume label always at beginning */ - create_volume_label_record(dcr, &rec); + create_volume_label_record(dcr, dcr->dev, &rec, dcr->block->adata); block->BlockNumber = 0; - if (!write_record_to_block(block, &rec)) { + /* Note for adata this also writes to disk */ + Dmsg1(100, "write_record_to_block adata=%d\n", dcr->dev->adata); + if (!write_record_to_block(dcr, &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; + Jmsg2(jcr, M_FATAL, 0, _("Cannot write Volume label to block for %s device %s\n"), + dev->print_type(), dev->print_name()); + ok = false; + goto get_out; } else { - Dmsg1(90, "Wrote label of %d bytes to block\n", rec.data_len); + Dmsg4(100, "Wrote fd=%d adata=%d label of %d bytes to block. Vol=%s\n", + dev->fd(), block->adata, rec.data_len, dcr->VolumeName); } free_pool_memory(rec.data); - return true; -} +get_out: + Leave(100); + return ok; +} /* * Write a Volume Label @@ -300,134 +348,240 @@ bool write_volume_label_to_block(DCR *dcr) * 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. + * This routine should be used only when labeling a blank tape or + * when recylcing a volume. + * + * Handle both the ameta and adata volumes. */ -bool write_new_volume_label_to_dev(DCR *dcr, const char *VolName, - const char *PoolName, bool relabel, bool dvdnow) +bool DEVICE::write_volume_label(DCR *dcr, const char *VolName, + const char *PoolName, bool relabel, bool no_prelabel) { - DEVICE *dev = dcr->dev; - - - Dmsg0(99, "write_volume_label()\n"); - empty_block(dcr->block); - - /* If relabeling, truncate the device */ - if (relabel && !dev->truncate(dcr)) { + DEVICE *dev; + + Enter(100); + Dmsg4(230, "Write: block=%p ameta=%p dev=%p ameta_dev=%p\n", + dcr->block, dcr->ameta_block, dcr->dev, dcr->ameta_dev); + dcr->set_ameta(); + dev = dcr->dev; + + Dmsg0(150, "write_volume_label()\n"); + if (*VolName == 0) { + if (dcr->jcr) { + Mmsg(dcr->jcr->errmsg, "ERROR: new_volume_label_to_dev called with NULL VolName\n"); + } + Pmsg0(0, "=== ERROR: write_volume_label called with NULL VolName\n"); goto bail_out; } if (relabel) { - dev->close_part(dcr); /* make sure closed for rename */ + volume_unused(dcr); /* mark current volume unused */ + /* Truncate device */ + if (!dev->truncate(dcr)) { + goto bail_out; + } + 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) { + dev->setVolCatName(VolName); + dcr->setVolCatName(VolName); + dev->clearVolCatBytes(); + + Dmsg1(100, "New VolName=%s\n", VolName); + if (!dev->open_device(dcr, OPEN_READ_WRITE)) { /* If device is not tape, attempt to create it */ - if (dev->is_tape() || dev->open(dcr, CREATE_READ_WRITE) < 0) { + if (dev->is_tape() || !dev->open_device(dcr, CREATE_READ_WRITE)) { + Jmsg4(dcr->jcr, M_WARNING, 0, _("Open %s device %s Volume \"%s\" failed: ERR=%s"), + dev->print_type(), dev->print_name(), dcr->VolumeName, dev->bstrerror()); 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) { - goto bail_out; - } + + if (!write_volume_label_to_dev(dcr, VolName, PoolName, relabel, no_prelabel)) { + goto bail_out; } - /* Create PRE_LABEL or VOL_LABEL if DVD */ - create_volume_label(dev, VolName, PoolName, dvdnow); + if (!dev->is_aligned()) { + /* Not aligned data */ + if (dev->weof(dcr, 1)) { + dev->set_labeled(); + } - /* - * 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); + if (chk_dbglvl(100)) { + dev->dump_volume_label(); + } + Dmsg0(50, "Call reserve_volume\n"); + /**** ***FIXME*** if dev changes, dcr must be updated */ + if (reserve_volume(dcr, VolName) == NULL) { + if (!dcr->jcr->errmsg[0]) { + Mmsg3(dcr->jcr->errmsg, _("Could not reserve volume %s on %s device %s\n"), + dev->VolHdr.VolumeName, dev->print_type(), dev->print_name()); + } + Dmsg1(50, "%s", dcr->jcr->errmsg); goto bail_out; } - } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, VolName)) { - goto bail_out; + dev = dcr->dev; /* may have changed in reserve_volume */ } + dev->clear_append(); /* remove append since this is PRE_LABEL */ + Leave(100); + return true; - create_volume_label_record(dcr, dcr->rec); - dcr->rec->Stream = 0; +bail_out: + dcr->adata_label = false; + dcr->set_ameta(); + volume_unused(dcr); + dcr->dev->clear_append(); /* remove append since this is PRE_LABEL */ + Leave(100); + return false; +} - /* 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()); - } +bool DEVICE::write_volume_label_to_dev(DCR *dcr, const char *VolName, + const char *PoolName, bool relabel, bool no_prelabel) +{ + DEVICE *dev, *ameta_dev; + DEV_BLOCK *block; + DEV_RECORD *rec = new_record(); + bool rtn = false; - 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()); + Enter(100); + dev = dcr->dev; + ameta_dev = dcr->ameta_dev; + block = dcr->block; + + empty_block(block); + if (!dev->rewind(dcr)) { + Dmsg2(130, "Bad status on %s from rewind: ERR=%s\n", dev->print_name(), dev->print_errmsg()); goto bail_out; } - /* 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()); + /* Temporarily mark in append state to enable writing */ + dev->set_append(); + + /* Create PRE_LABEL or VOL_LABEL */ + create_volume_header(dev, VolName, PoolName, no_prelabel); + + /* + * 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 (!block->adata) { + 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; } } - Dmsg0(99, " Wrote block to device\n"); + create_volume_label_record(dcr, dev, rec, block->adata); + rec->Stream = 0; + rec->maskedStream = 0; + + Dmsg2(100, "write_record_to_block adata=%d FI=%d\n", dcr->dev->adata, + rec->FileIndex); - if (dev->weof(1)) { - dev->set_labeled(); - write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName); + /* For adata label this also writes to disk */ + if (!write_record_to_block(dcr, rec)) { + Dmsg2(40, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg()); + goto bail_out; + } else { + Dmsg3(100, "Wrote label=%d bytes adata=%d block: %s\n", rec->data_len, block->adata, dev->print_name()); } + Dmsg3(100, "New label adata=%d VolCatBytes=%lld VolCatStatus=%s\n", + dev->adata, ameta_dev->VolCatInfo.VolCatBytes, ameta_dev->VolCatInfo.VolCatStatus); - if (debug_level >= 20) { - dump_volume_label(dev); + if (block->adata) { + /* Empty block and set data start address */ + empty_block(dcr->adata_block); + } else { + Dmsg4(130, "Call write_block_to_dev() fd=%d adata=%d block=%p Addr=%lld\n", + dcr->dev->fd(), dcr->block->adata, dcr->block, block->dev->lseek(dcr, 0, SEEK_CUR)); + Dmsg1(100, "write_record_to_dev adata=%d\n", dcr->dev->adata); + /* Write ameta block to device */ + if (!dcr->write_block_to_dev()) { + Dmsg2(40, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg()); + goto bail_out; + } } - new_volume(dcr, VolName); - dev->clear_append(); /* remove append since this is PRE_LABEL */ - return true; + Dmsg3(100, "Wrote new Vol label adata=%d VolCatBytes=%lld VolCatStatus=%s\n", + dev->adata, ameta_dev->VolCatInfo.VolCatBytes, ameta_dev->VolCatInfo.VolCatStatus); + rtn = 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; + free_record(rec); + Leave(100); + return rtn; } /* * Write a volume label. This is ONLY called if we have a valid Bacula - * label of type PRE_LABEL; + * label of type PRE_LABEL or we are recyling an existing Volume. + * + * By calling write_volume_label_to_block, both ameta and adata + * are updated. + * * Returns: true if OK * false if unable to write it */ -bool rewrite_volume_label(DCR *dcr, bool recycle) +bool DEVICE::rewrite_volume_label(DCR *dcr, bool recycle) { - DEVICE *dev = dcr->dev; + char ed1[50]; JCR *jcr = dcr->jcr; - if (dev->open(dcr, OPEN_READ_WRITE) < 0) { + Enter(100); + ASSERT2(dcr->VolumeName[0], "Empty Volume name"); + ASSERT(!dcr->block->adata); + if (!open_device(dcr, OPEN_READ_WRITE)) { + Jmsg4(jcr, M_WARNING, 0, _("Open %s device %s Volume \"%s\" failed: ERR=%s\n"), + print_type(), print_name(), dcr->VolumeName, bstrerror()); + Leave(100); 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(); + Dmsg2(190, "set append found freshly labeled volume. fd=%d dev=%x\n", fd(), this); + VolHdr.LabelType = VOL_LABEL; /* set Volume label */ + set_append(); + Dmsg0(100, "Rewrite_volume_label set volcatbytes=0\n"); + clearVolCatBytes(); /* resets both ameta and adata byte counts */ + setVolCatStatus("Append"); /* set append status */ + + if (!has_cap(CAP_STREAM)) { + if (!rewind(dcr)) { + Jmsg3(jcr, M_FATAL, 0, _("Rewind error on %s device %s: ERR=%s\n"), + print_type(), print_name(), print_errmsg()); + Leave(100); + return false; + } + if (recycle) { + Dmsg1(150, "Doing recycle. Vol=%s\n", dcr->VolumeName); + if (!truncate(dcr)) { + Jmsg3(jcr, M_FATAL, 0, _("Truncate error on %s device %s: ERR=%s\n"), + print_type(), print_name(), print_errmsg()); + Leave(100); + return false; + } + if (!open_device(dcr, OPEN_READ_WRITE)) { + Jmsg3(jcr, M_FATAL, 0, + _("Failed to re-open device after truncate on %s device %s: ERR=%s"), + print_type(), print_name(), print_errmsg()); + Leave(100); + return false; + } + } + } + if (!write_volume_label_to_block(dcr)) { - Dmsg0(200, "Error from write volume label.\n"); + Dmsg0(150, "Error from write volume label.\n"); + Leave(100); return false; } + Dmsg2(100, "wrote vol label to block. adata=%d Vol=%s\n", dcr->block->adata, dcr->VolumeName); - dev->VolCatInfo.VolCatBytes = 0; /* reset byte count */ + ASSERT2(dcr->VolumeName[0], "Empty Volume name"); + setVolCatInfo(false); /* * If we are not dealing with a streaming device, @@ -436,103 +590,106 @@ bool rewrite_volume_label(DCR *dcr, bool recycle) * 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_cap(dev, 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 (!has_cap(CAP_STREAM)) { /* * If we have already detected an ANSI label, re-read it - * to skip past it. Otherwise, we write a new one if - * so requested. + * to skip past it. Otherwise, we write a new one if + * so requested. */ - if (dev->label_type != B_BACULA_LABEL) { + if (label_type != B_BACULA_LABEL) { if (read_ansi_ibm_label(dcr) != VOL_OK) { - dev->rewind(dcr); + rewind(dcr); + Leave(100); return false; } - } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, dev->VolHdr.VolumeName)) { + } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, VolHdr.VolumeName)) { + Leave(100); 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()); + Dmsg1(200, "Attempt to write to device fd=%d.\n", fd()); + if (!dcr->write_block_to_dev()) { + Jmsg3(jcr, M_ERROR, 0, _("Unable to write %s device %s: ERR=%s\n"), + print_type(), print_name(), print_errmsg()); Dmsg0(200, "===ERROR write block to dev\n"); + Leave(100); return false; } } - dev->set_labeled(); + ASSERT2(dcr->VolumeName[0], "Empty Volume name"); + setVolCatName(dcr->VolumeName); + if (!dir_get_volume_info(dcr, dcr->VolumeName, GET_VOL_INFO_FOR_WRITE)) { + Leave(100); + return false; + } + 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; + VolCatInfo.VolCatJobs = 0; + VolCatInfo.VolCatFiles = 0; + VolCatInfo.VolCatErrors = 0; + VolCatInfo.VolCatBlocks = 0; + VolCatInfo.VolCatRBytes = 0; + VolCatInfo.VolCatCloudParts = 0; + VolCatInfo.VolLastPartBytes = 0; + VolCatInfo.VolCatType = 0; /* Will be set by dir_update_volume_info() */ if (recycle) { - dev->VolCatInfo.VolCatMounts++; - dev->VolCatInfo.VolCatRecycles++; + VolCatInfo.VolCatMounts++; + VolCatInfo.VolCatRecycles++; } else { - dev->VolCatInfo.VolCatMounts = 1; - dev->VolCatInfo.VolCatRecycles = 0; - dev->VolCatInfo.VolCatWrites = 1; - dev->VolCatInfo.VolCatReads = 1; + VolCatInfo.VolCatMounts = 1; + VolCatInfo.VolCatRecycles = 0; + VolCatInfo.VolCatWrites = 1; + 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 */ + dcr->VolMediaId = dcr->VolCatInfo.VolMediaId; /* make create_jobmedia work */ + dir_create_jobmedia_record(dcr, true); + Dmsg1(100, "dir_update_vol_info. Set Append vol=%s\n", dcr->VolumeName); + VolCatInfo.VolFirstWritten = time(NULL); + setVolCatStatus("Append"); + if (!dir_update_volume_info(dcr, true, true)) { /* indicate relabel */ + Leave(100); 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()); + Jmsg(jcr, M_INFO, 0, _("Recycled volume \"%s\" on %s device %s, all previous data lost.\n"), + dcr->VolumeName, print_type(), print_name()); } else { - Jmsg(jcr, M_INFO, 0, _("Wrote label to prelabeled Volume \"%s\" on device %s\n"), - dcr->VolumeName, dev->print_name()); + Jmsg(jcr, M_INFO, 0, _("Wrote label to prelabeled Volume \"%s\" on %s device %s\n"), + dcr->VolumeName, print_type(), print_name()); } /* * End writing real Volume label (from pre-labeled tape), or recycling * the volume. */ - Dmsg0(200, "OK from rewrite vol label.\n"); + Dmsg4(100, "OK rewrite vol label. Addr=%s adata=%d slot=%d Vol=%s\n", + print_addr(ed1, sizeof(ed1)), dcr->block->adata, VolCatInfo.Slot, dcr->VolumeName); + Leave(100); return true; } /* * create_volume_label_record + * Note: it is assumed that you have created the volume_header + * (label) prior to calling this subroutine. * Serialize label (from dev->VolHdr structure) into device record. * Assumes that the dev->VolHdr structure is properly * initialized. */ -static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec) +static void create_volume_label_record(DCR *dcr, DEVICE *dev, + DEV_RECORD *rec, bool adata) { ser_declare; struct date_time dt; - DEVICE *dev = dcr->dev; JCR *jcr = dcr->jcr; char buf[100]; /* Serialize the label into the device record. */ + Enter(100); rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label); + memset(rec->data, 0, SER_LENGTH_Volume_Label); ser_begin(rec->data, SER_LENGTH_Volume_Label); ser_string(dev->VolHdr.Id); @@ -565,40 +722,79 @@ static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec) ser_string(dev->VolHdr.LabelProg); ser_string(dev->VolHdr.ProgVersion); ser_string(dev->VolHdr.ProgDate); + /* ***FIXME*** */ + dev->VolHdr.AlignedVolumeName[0] = 0; + ser_string(dev->VolHdr.AlignedVolumeName); + + /* This is adata Volume information */ + ser_uint64(dev->VolHdr.FirstData); + ser_uint32(dev->VolHdr.FileAlignment); + ser_uint32(dev->VolHdr.PaddingSize); + /* adata and dedup volumes */ + ser_uint32(dev->VolHdr.BlockSize); ser_end(rec->data, SER_LENGTH_Volume_Label); + if (!adata) { + bstrncpy(dcr->VolumeName, dev->VolHdr.VolumeName, sizeof(dcr->VolumeName)); + } + ASSERT2(dcr->VolumeName[0], "Empty Volume name"); rec->data_len = ser_length(rec->data); rec->FileIndex = dev->VolHdr.LabelType; + Dmsg2(100, "LabelType=%d adata=%d\n", dev->VolHdr.LabelType, dev->adata); rec->VolSessionId = jcr->VolSessionId; rec->VolSessionTime = jcr->VolSessionTime; - rec->Stream = jcr->NumVolumes; - Dmsg2(150, "Created Vol label rec: FI=%s len=%d\n", FI_to_ascii(buf, rec->FileIndex), + rec->Stream = jcr->NumWriteVolumes; + rec->maskedStream = jcr->NumWriteVolumes; + Dmsg3(100, "Created adata=%d Vol label rec: FI=%s len=%d\n", adata, FI_to_ascii(buf, rec->FileIndex), rec->data_len); + Dmsg2(100, "reclen=%d recdata=%s", rec->data_len, rec->data); + Leave(100); } /* - * Create a volume label in memory + * Create a volume header (label) in memory + * The volume record is created after this header (label) + * is created. */ -void create_volume_label(DEVICE *dev, const char *VolName, - const char *PoolName, bool dvdnow) +void create_volume_header(DEVICE *dev, const char *VolName, + const char *PoolName, bool no_prelabel) { DEVRES *device = (DEVRES *)dev->device; - Dmsg0(90, "Start create_volume_label()\n"); - - ASSERT(dev != NULL); - - free_volume(dev); /* release any old volume */ - memset(&dev->VolHdr, 0, sizeof(dev->VolHdr)); + Enter(130); + + ASSERT2(dev != NULL, "dev ptr is NULL"); + + if (dev->is_aligned()) { + bstrncpy(dev->VolHdr.Id, BaculaMetaDataId, sizeof(dev->VolHdr.Id)); + dev->VolHdr.VerNum = BaculaMetaDataVersion; + dev->VolHdr.FirstData = dev->file_alignment; + dev->VolHdr.FileAlignment = dev->file_alignment; + dev->VolHdr.PaddingSize = dev->padding_size; + dev->VolHdr.BlockSize = dev->adata_size; + } else if (dev->is_adata()) { + bstrncpy(dev->VolHdr.Id, BaculaAlignedDataId, sizeof(dev->VolHdr.Id)); + dev->VolHdr.VerNum = BaculaAlignedDataVersion; + dev->VolHdr.FirstData = dev->file_alignment; + dev->VolHdr.FileAlignment = dev->file_alignment; + dev->VolHdr.PaddingSize = dev->padding_size; + dev->VolHdr.BlockSize = dev->adata_size; + } else if (dev->is_cloud()) { + bstrncpy(dev->VolHdr.Id, BaculaS3CloudId, sizeof(dev->VolHdr.Id)); + dev->VolHdr.VerNum = BaculaS3CloudVersion; + dev->VolHdr.BlockSize = dev->max_block_size; + } else { + bstrncpy(dev->VolHdr.Id, BaculaId, sizeof(dev->VolHdr.Id)); + dev->VolHdr.VerNum = BaculaTapeVersion; + dev->VolHdr.BlockSize = dev->max_block_size; + } - bstrncpy(dev->VolHdr.Id, BaculaId, sizeof(dev->VolHdr.Id)); - dev->VolHdr.VerNum = BaculaTapeVersion; - if (dev->is_dvd() && dvdnow) { - /* We do not want to re-label a DVD so write VOL_LABEL now */ + if (dev->has_cap(CAP_STREAM) && no_prelabel) { + /* We do not want to re-label so write VOL_LABEL now */ dev->VolHdr.LabelType = VOL_LABEL; } else { - dev->VolHdr.LabelType = PRE_LABEL; /* Mark tape as unused */ + dev->VolHdr.LabelType = PRE_LABEL; /* Mark Volume as unused */ } bstrncpy(dev->VolHdr.VolumeName, VolName, sizeof(dev->VolHdr.VolumeName)); bstrncpy(dev->VolHdr.PoolName, PoolName, sizeof(dev->VolHdr.PoolName)); @@ -614,16 +810,16 @@ void create_volume_label(DEVICE *dev, const char *VolName, dev->VolHdr.HostName[0] = 0; } 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__); + sprintf(dev->VolHdr.ProgVersion, "Ver. %s %s ", VERSION, BDATE); + sprintf(dev->VolHdr.ProgDate, "Build %s %s ", __DATE__, __TIME__); dev->set_labeled(); /* set has Bacula label */ - if (debug_level >= 90) { - dump_volume_label(dev); + if (chk_dbglvl(100)) { + dev->dump_volume_label(); } } /* - * Create session label + * Create session (Job) label * The pool memory must be released by the calling program */ void create_session_label(DCR *dcr, DEV_RECORD *rec, int label) @@ -631,9 +827,11 @@ void create_session_label(DCR *dcr, DEV_RECORD *rec, int label) JCR *jcr = dcr->jcr; ser_declare; + Enter(100); rec->VolSessionId = jcr->VolSessionId; rec->VolSessionTime = jcr->VolSessionTime; rec->Stream = jcr->JobId; + rec->maskedStream = jcr->JobId; rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label); ser_begin(rec->data, SER_LENGTH_Session_Label); @@ -654,18 +852,18 @@ void create_session_label(DCR *dcr, DEV_RECORD *rec, int label) /* Added in VerNum 10 */ ser_string(jcr->Job); /* Unique name of this Job */ ser_string(jcr->fileset_name); - ser_uint32(jcr->JobType); - ser_uint32(jcr->JobLevel); + ser_uint32(jcr->getJobType()); + ser_uint32(jcr->getJobLevel()); /* Added in VerNum 11 */ ser_string(jcr->fileset_md5); if (label == EOS_LABEL) { ser_uint32(jcr->JobFiles); ser_uint64(jcr->JobBytes); - ser_uint32(dcr->StartBlock); - ser_uint32(dcr->EndBlock); - ser_uint32(dcr->StartFile); - ser_uint32(dcr->EndFile); + ser_uint32((uint32_t)dcr->StartAddr); /* Start Block */ + ser_uint32((uint32_t)dcr->EndAddr); /* End Block */ + ser_uint32((uint32_t)(dcr->StartAddr>>32)); /* Start File */ + ser_uint32((uint32_t)(dcr->EndAddr>>32)); /* End File */ ser_uint32(jcr->JobErrors); /* Added in VerNum 11 */ @@ -673,9 +871,10 @@ void create_session_label(DCR *dcr, DEV_RECORD *rec, int label) } ser_end(rec->data, SER_LENGTH_Session_Label); rec->data_len = ser_length(rec->data); + Leave(100); } -/* Write session label +/* Write session (Job) label * Returns: false on failure * true on success */ @@ -687,33 +886,32 @@ bool write_session_label(DCR *dcr, int label) DEV_BLOCK *block = dcr->block; char buf1[100], buf2[100]; + Enter(100); + dev->Lock(); + Dmsg2(140, "=== write_session_label label=%d Vol=%s.\n", label, dev->getVolCatName()); + if (!check_for_newvol_or_newfile(dcr)) { + Pmsg0(000, "ERR: !check_for_new_vol_or_newfile\n"); + dev->Unlock(); + return false; + } + rec = new_record(); - Dmsg1(90, "session_label record=%x\n", rec); + Dmsg1(130, "session_label record=%x\n", rec); switch (label) { case SOS_LABEL: - 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); - } + set_start_vol_position(dcr); break; case EOS_LABEL: - 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->EndAddr = dev->get_full_addr(); break; default: - Jmsg1(jcr, M_ABORT, 0, _("Bad session label = %d\n"), label); + Jmsg1(jcr, M_ABORT, 0, _("Bad Volume session label request=%d\n"), label); break; } + create_session_label(dcr, rec, label); rec->FileIndex = label; + dev->Unlock(); /* * We guarantee that the session record can totally fit @@ -724,31 +922,34 @@ bool write_session_label(DCR *dcr, int label) */ if (!can_write_record_to_block(block, rec)) { 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"); - /* ****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)); + if (!dcr->write_block_to_device()) { + Dmsg0(130, "Got session label write_block_to_dev error.\n"); free_record(rec); + Leave(100); 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)); + /* + * We use write_record() because it handles the case that + * the maximum user size has been reached. + */ + if (!dcr->write_record(rec)) { + Dmsg0(150, "Bad return from write_record\n"); free_record(rec); + Leave(100); return false; } - Dmsg6(50, "Write sesson_label record JobId=%d FI=%s SessId=%d Strm=%s len=%d " + Dmsg6(150, "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(50, "Leave write_session_label Block=%ud File=%ud\n", - dev->get_block(), dev->get_file()); + Dmsg2(150, "Leave write_session_label Block=%u File=%u\n", + dev->get_block_num(), dev->get_file()); + Leave(100); return true; } @@ -768,12 +969,14 @@ bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec) ser_declare; char buf1[100], buf2[100]; + Enter(100); 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) { + Leave(100); return false; } } @@ -783,7 +986,9 @@ bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec) /* Unserialize the record into the Volume Header */ + Dmsg2(100, "reclen=%d recdata=%s", rec->data_len, rec->data); rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label); + Dmsg2(100, "reclen=%d recdata=%s", rec->data_len, rec->data); ser_begin(rec->data, SER_LENGTH_Volume_Label); unser_string(dev->VolHdr.Id); unser_uint32(dev->VolHdr.VerNum); @@ -809,11 +1014,19 @@ bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec) unser_string(dev->VolHdr.ProgVersion); unser_string(dev->VolHdr.ProgDate); +// unser_string(dev->VolHdr.AlignedVolumeName); + dev->VolHdr.AlignedVolumeName[0] = 0; + unser_uint64(dev->VolHdr.FirstData); + unser_uint32(dev->VolHdr.FileAlignment); + unser_uint32(dev->VolHdr.PaddingSize); + unser_uint32(dev->VolHdr.BlockSize); + ser_end(rec->data, SER_LENGTH_Volume_Label); Dmsg0(190, "unser_vol_label\n"); - if (debug_level >= 190) { - dump_volume_label(dev); + if (chk_dbglvl(100)) { + dev->dump_volume_label(); } + Leave(100); return true; } @@ -822,6 +1035,7 @@ bool unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec) { ser_declare; + Enter(100); rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label); unser_begin(rec->data, SER_LENGTH_Session_Label); unser_string(label->Id); @@ -862,12 +1076,13 @@ bool unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec) label->JobStatus = JS_Terminated; /* kludge */ } } + Leave(100); return true; } -void dump_volume_label(DEVICE *dev) +void DEVICE::dump_volume_label() { - int dbl = debug_level; + int64_t dbl = debug_level; uint32_t File; const char *LabelType; char buf[30]; @@ -875,8 +1090,8 @@ void dump_volume_label(DEVICE *dev) struct date_time dt; debug_level = 1; - File = dev->file; - switch (dev->VolHdr.LabelType) { + File = file; + switch (VolHdr.LabelType) { case PRE_LABEL: LabelType = "PRE_LABEL"; break; @@ -896,11 +1111,12 @@ void dump_volume_label(DEVICE *dev) goto bail_out; default: LabelType = buf; - sprintf(buf, _("Unknown %d"), dev->VolHdr.LabelType); + sprintf(buf, _("Unknown %d"), VolHdr.LabelType); break; } - Pmsg11(-1, _("\nVolume Label:\n" + Pmsg12(-1, _("\nVolume Label:\n" +"Adata : %d\n" "Id : %s" "VerNo : %d\n" "VolName : %s\n" @@ -913,23 +1129,24 @@ void dump_volume_label(DEVICE *dev) "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) { + adata, + VolHdr.Id, VolHdr.VerNum, + VolHdr.VolumeName, VolHdr.PrevVolumeName, + File, LabelType, VolHdr.LabelSize, + VolHdr.PoolName, VolHdr.MediaType, + VolHdr.PoolType, VolHdr.HostName); + + if (VolHdr.VerNum >= 11) { char dt[50]; - bstrftime(dt, sizeof(dt), btime_to_unix(dev->VolHdr.label_btime)); + bstrftime(dt, sizeof(dt), btime_to_utime(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); + dt.julian_day_number = VolHdr.label_date; + dt.julian_day_fraction = 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: @@ -939,7 +1156,7 @@ bail_out: static void dump_session_label(DEV_RECORD *rec, const char *type) { - int dbl; + int64_t dbl; struct date_time dt; struct tm tm; SESSION_LABEL label; @@ -990,7 +1207,7 @@ static void dump_session_label(DEV_RECORD *rec, const char *type) } if (label.VerNum >= 11) { char dt[50]; - bstrftime(dt, sizeof(dt), btime_to_unix(label.write_btime)); + bstrftime(dt, sizeof(dt), btime_to_utime(label.write_btime)); Pmsg1(-1, _("Date written : %s\n"), dt); } else { dt.julian_day_number = label.write_date; @@ -1003,13 +1220,74 @@ static void dump_session_label(DEV_RECORD *rec, const char *type) debug_level = dbl; } -void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose) +static int check_label(SESSION_LABEL *label) +{ + int errors = 0; + + if (label->JobId > 10000000 || label->JobId < 0) { + Pmsg0(-1, _("***** ERROR ****** : Found error with the JobId\n")); + errors++; + } + + if (!errors) { + switch (label->JobLevel) { + case L_FULL: + case L_INCREMENTAL: + case L_DIFFERENTIAL: + case L_SINCE: + case L_VERIFY_CATALOG: + case L_VERIFY_INIT: + case L_VERIFY_VOLUME_TO_CATALOG: + case L_VERIFY_DISK_TO_CATALOG: + case L_VERIFY_DATA: + case L_BASE: + case L_NONE: + case L_VIRTUAL_FULL: + break; + default: + Pmsg0(-1, _("***** ERROR ****** : Found error with the JobLevel\n")); + errors++; + } + } + if (!errors) { + switch (label->JobType) { + case JT_BACKUP: + case JT_MIGRATED_JOB: + case JT_VERIFY: + case JT_RESTORE: + case JT_CONSOLE: + case JT_SYSTEM: + case JT_ADMIN: + case JT_ARCHIVE: + case JT_JOB_COPY: + case JT_COPY: + case JT_MIGRATE: + case JT_SCAN: + break; + default: + Pmsg0(-1, _("***** ERROR ****** : Found error with the JobType\n")); + errors++; + } + } + if (!errors) { + POOLMEM *err = get_pool_memory(PM_EMSG); + if (!is_name_valid(label->Job, &err)) { + Pmsg1(-1, _("***** ERROR ****** : Found error with the Job name %s\n"), err); + errors++; + } + free_pool_memory(err); + } + return errors; +} + +int dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose, bool check_err) { const char *type; - int dbl; + int64_t dbl; + int errors = 0; if (rec->FileIndex == 0 && rec->VolSessionId == 0 && rec->VolSessionTime == 0) { - return; + return 0; } dbl = debug_level; debug_level = 1; @@ -1041,25 +1319,24 @@ void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose) case PRE_LABEL: case VOL_LABEL: unser_volume_label(dev, rec); - dump_volume_label(dev); - break; - case SOS_LABEL: - dump_session_label(rec, type); + dev->dump_volume_label(); break; + case EOS_LABEL: + case SOS_LABEL: dump_session_label(rec, type); break; case EOM_LABEL: 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, + type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len); break; case EOT_LABEL: - Pmsg0(-1, _("End of physical tape.\n")); + Pmsg0(-1, _("Bacula \"End of Tape\" label found.\n")); break; 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, + type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len); break; } @@ -1069,16 +1346,19 @@ void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose) switch (rec->FileIndex) { case SOS_LABEL: unser_session_label(&label, rec); - bstrftimes(dt, sizeof(dt), btime_to_unix(label.write_btime)); + bstrftimes(dt, sizeof(dt), btime_to_utime(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); + if (check_err) { + errors += check_label(&label); + } break; case EOS_LABEL: char ed1[30], ed2[30]; unser_session_label(&label, rec); - bstrftimes(dt, sizeof(dt), btime_to_unix(label.write_btime)); + bstrftimes(dt, sizeof(dt), btime_to_utime(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"), @@ -1086,13 +1366,16 @@ void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose) edit_uint64_with_commas(label.JobFiles, ed1), edit_uint64_with_commas(label.JobBytes, ed2), label.JobErrors, (char)label.JobStatus); + if (check_err) { + errors += check_label(&label); + } 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, + type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len); break; case EOT_LABEL: @@ -1100,4 +1383,5 @@ void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose) } } debug_level = dbl; + return errors; }