git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/label.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *
  30  *  label.c  Bacula routines to handle labels
  31  *
  32  *   Kern Sibbald, MM
  33  *
  34  *
  35  *   Version $Id$
  36  */
  37
  38 #include "bacula.h"                   /* pull in global headers */
  39 #include "stored.h"                   /* pull in Storage Deamon headers */
  40
  41 /* Forward referenced functions */
  42 static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec);
  43
  44 /*
  45  * Read the volume label
  46  *
  47  *  If dcr->VolumeName == NULL, we accept any Bacula Volume
  48  *  If dcr->VolumeName[0] == 0, we accept any Bacula Volume
  49  *  otherwise dcr->VolumeName must match the Volume.
  50  *
  51  *  If VolName given, ensure that it matches
  52  *
  53  *  Returns VOL_  code as defined in record.h
  54  *    VOL_NOT_READ
  55  *    VOL_OK                          good label found
  56  *    VOL_NO_LABEL                    volume not labeled
  57  *    VOL_IO_ERROR                    I/O error reading tape
  58  *    VOL_NAME_ERROR                  label has wrong name
  59  *    VOL_CREATE_ERROR                Error creating label
  60  *    VOL_VERSION_ERROR               label has wrong version
  61  *    VOL_LABEL_ERROR                 bad label type
  62  *    VOL_NO_MEDIA                    no media in drive
  63  *
  64  *  The dcr block is emptied on return, and the Volume is
  65  *    rewound.
  66  */
  67 int read_dev_volume_label(DCR *dcr)
  68 {
  69    JCR *jcr = dcr->jcr;
  70    DEVICE * volatile dev = dcr->dev;
  71    char *VolName = dcr->VolumeName;
  72    DEV_RECORD *record;
  73    bool ok = false;
  74    DEV_BLOCK *block = dcr->block;
  75    int stat;
  76    bool want_ansi_label;
  77    bool have_ansi_label = false;
  78
  79    Dmsg4(100, "Enter read_volume_label res=%d device=%s vol=%s dev_Vol=%s\n",
  80       dev->num_reserved(), dev->print_name(), VolName,
  81       dev->VolHdr.VolumeName[0]?dev->VolHdr.VolumeName:"*NULL*");
  82
  83    if (!dev->is_open()) {
  84       if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
  85          return VOL_IO_ERROR;
  86       }
  87    }
  88
  89    dev->clear_labeled();
  90    dev->clear_append();
  91    dev->clear_read();
  92    dev->label_type = B_BACULA_LABEL;
  93
  94    if (!dev->rewind(dcr)) {
  95       Mmsg(jcr->errmsg, _("Couldn't rewind device %s: ERR=%s\n"),
  96          dev->print_name(), dev->print_errmsg());
  97       Dmsg1(130, "return VOL_NO_MEDIA: %s", jcr->errmsg);
  98       return VOL_NO_MEDIA;
  99    }
 100    bstrncpy(dev->VolHdr.Id, "**error**", sizeof(dev->VolHdr.Id));
 101
 102   /* Read ANSI/IBM label if so requested */
 103   want_ansi_label = dcr->VolCatInfo.LabelType != B_BACULA_LABEL ||
 104                     dcr->device->label_type != B_BACULA_LABEL;
 105   if (want_ansi_label || dev->has_cap(CAP_CHECKLABELS)) {
 106       stat = read_ansi_ibm_label(dcr);
 107       /* If we want a label and didn't find it, return error */
 108       if (want_ansi_label && stat != VOL_OK) {
 109          goto bail_out;
 110       }
 111       if (stat == VOL_NAME_ERROR || stat == VOL_LABEL_ERROR) {
 112          Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
 113               dev->print_name(), VolName, dev->VolHdr.VolumeName);
 114          if (!dev->poll && jcr->label_errors++ > 100) {
 115             Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg);
 116          }
 117          goto bail_out;
 118       }
 119       if (stat != VOL_OK) {           /* Not an ANSI/IBM label, so re-read */
 120          dev->rewind(dcr);
 121       } else {
 122          have_ansi_label = true;
 123       }
 124    }
 125
 126    /* Read the Bacula Volume label block */
 127    record = new_record();
 128    empty_block(block);
 129
 130    Dmsg0(130, "Big if statement in read_volume_label\n");
 131    if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 132       Mmsg(jcr->errmsg, _("Requested Volume \"%s\" on %s is not a Bacula "
 133            "labeled Volume, because: ERR=%s"), NPRT(VolName),
 134            dev->print_name(), dev->print_errmsg());
 135       Dmsg1(130, "%s", jcr->errmsg);
 136    } else if (!read_record_from_block(dcr, block, record)) {
 137       Mmsg(jcr->errmsg, _("Could not read Volume label from block.\n"));
 138       Dmsg1(130, "%s", jcr->errmsg);
 139    } else if (!unser_volume_label(dev, record)) {
 140       Mmsg(jcr->errmsg, _("Could not unserialize Volume label: ERR=%s\n"),
 141          dev->print_errmsg());
 142       Dmsg1(130, "%s", jcr->errmsg);
 143    } else if (strcmp(dev->VolHdr.Id, BaculaId) != 0 &&
 144               strcmp(dev->VolHdr.Id, OldBaculaId) != 0) {
 145       Mmsg(jcr->errmsg, _("Volume Header Id bad: %s\n"), dev->VolHdr.Id);
 146       Dmsg1(130, "%s", jcr->errmsg);
 147    } else {
 148       ok = true;
 149    }
 150    free_record(record);               /* finished reading Volume record */
 151
 152    if (!dev->is_volume_to_unload()) {
 153       dev->clear_unload();
 154    }
 155
 156    if (!ok) {
 157       if (forge_on || jcr->ignore_label_errors) {
 158          dev->set_labeled();         /* set has Bacula label */
 159          Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg);
 160          empty_block(block);
 161          return VOL_OK;
 162       }
 163       Dmsg0(100, "No volume label - bailing out\n");
 164       stat = VOL_NO_LABEL;
 165       goto bail_out;
 166    }
 167
 168    /* At this point, we have read the first Bacula block, and
 169     * then read the Bacula Volume label. Now we need to
 170     * make sure we have the right Volume.
 171     */
 172
 173
 174    if (dev->VolHdr.VerNum != BaculaTapeVersion &&
 175        dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion1 &&
 176        dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion2) {
 177       Mmsg(jcr->errmsg, _("Volume on %s has wrong Bacula version. Wanted %d got %d\n"),
 178          dev->print_name(), BaculaTapeVersion, dev->VolHdr.VerNum);
 179       Dmsg1(130, "VOL_VERSION_ERROR: %s", jcr->errmsg);
 180       stat = VOL_VERSION_ERROR;
 181       goto bail_out;
 182    }
 183
 184    /* We are looking for either an unused Bacula tape (PRE_LABEL) or
 185     * a Bacula volume label (VOL_LABEL)
 186     */
 187    if (dev->VolHdr.LabelType != PRE_LABEL && dev->VolHdr.LabelType != VOL_LABEL) {
 188       Mmsg(jcr->errmsg, _("Volume on %s has bad Bacula label type: %x\n"),
 189           dev->print_name(), dev->VolHdr.LabelType);
 190       Dmsg1(130, "%s", jcr->errmsg);
 191       if (!dev->poll && jcr->label_errors++ > 100) {
 192          Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg);
 193       }
 194       Dmsg0(150, "return VOL_LABEL_ERROR\n");
 195       stat = VOL_LABEL_ERROR;
 196       goto bail_out;
 197    }
 198
 199    dev->set_labeled();               /* set has Bacula label */
 200
 201    /* Compare Volume Names */
 202    Dmsg2(130, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolumeName);
 203    if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolumeName, VolName) != 0) {
 204       Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
 205            dev->print_name(), VolName, dev->VolHdr.VolumeName);
 206       Dmsg1(130, "%s", jcr->errmsg);
 207       /*
 208        * Cancel Job if too many label errors
 209        *  => we are in a loop
 210        */
 211       if (!dev->poll && jcr->label_errors++ > 100) {
 212          Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg);
 213       }
 214       Dmsg0(150, "return VOL_NAME_ERROR\n");
 215       stat = VOL_NAME_ERROR;
 216       goto bail_out;
 217    }
 218
 219
 220    if (debug_level >= 10) {
 221       dump_volume_label(dev);
 222    }
 223    Dmsg0(130, "Leave read_volume_label() VOL_OK\n");
 224    /* If we are a streaming device, we only get one chance to read */
 225    if (!dev->has_cap(CAP_STREAM)) {
 226       dev->rewind(dcr);
 227       if (have_ansi_label) {
 228          stat = read_ansi_ibm_label(dcr);
 229          /* If we want a label and didn't find it, return error */
 230          if (stat != VOL_OK) {
 231             goto bail_out;
 232          }
 233       }
 234    }
 235
 236    Dmsg1(100, "Call reserve_volume=%s\n", dev->VolHdr.VolumeName);
 237    if (reserve_volume(dcr, dev->VolHdr.VolumeName) == NULL) {
 238       Mmsg2(jcr->errmsg, _("Could not reserve volume %s on %s\n"),
 239            dev->VolHdr.VolumeName, dev->print_name());
 240       stat = VOL_NAME_ERROR;
 241       goto bail_out;
 242    }
 243
 244    empty_block(block);
 245    return VOL_OK;
 246
 247 bail_out:
 248    empty_block(block);
 249    dev->rewind(dcr);
 250    Dmsg1(150, "return %d\n", stat);
 251    return stat;
 252 }
 253
 254 /*
 255  * Put a volume label into the block
 256  *
 257  *  Returns: false on failure
 258  *           true  on success
 259  */
 260 bool write_volume_label_to_block(DCR *dcr)
 261 {
 262    DEV_RECORD rec;
 263    DEVICE *dev = dcr->dev;
 264    JCR *jcr = dcr->jcr;
 265    DEV_BLOCK *block = dcr->block;
 266
 267    Dmsg0(130, "write Label in write_volume_label_to_block()\n");
 268    memset(&rec, 0, sizeof(rec));
 269    rec.data = get_memory(SER_LENGTH_Volume_Label);
 270    empty_block(block);                /* Volume label always at beginning */
 271
 272    create_volume_label_record(dcr, &rec);
 273
 274    block->BlockNumber = 0;
 275    if (!write_record_to_block(block, &rec)) {
 276       free_pool_memory(rec.data);
 277       Jmsg1(jcr, M_FATAL, 0, _("Cannot write Volume label to block for device %s\n"),
 278          dev->print_name());
 279       return false;
 280    } else {
 281       Dmsg2(130, "Wrote label of %d bytes to block. Vol=%s\n", rec.data_len,
 282             dcr->VolumeName);
 283    }
 284    free_pool_memory(rec.data);
 285    return true;
 286 }
 287
 288
 289 /*
 290  * Write a Volume Label
 291  *  !!! Note, this is ONLY used for writing
 292  *            a fresh volume label.  Any data
 293  *            after the label will be destroyed,
 294  *            in fact, we write the label 5 times !!!!
 295  *
 296  *  This routine should be used only when labeling a blank tape.
 297  */
 298 bool write_new_volume_label_to_dev(DCR *dcr, const char *VolName,
 299                                    const char *PoolName, bool relabel, bool dvdnow)
 300 {
 301    DEVICE * volatile dev = dcr->dev;
 302
 303
 304    Dmsg0(150, "write_volume_label()\n");
 305    empty_block(dcr->block);
 306    if (*VolName == 0) {
 307       Pmsg0(0, "=== ERROR: write_new_volume_label_to_dev called with NULL VolName\n");
 308       goto bail_out;
 309    }
 310
 311    if (relabel) {
 312       volume_unused(dcr);             /* mark current volume unused */
 313       /* Truncate device */
 314       if (!dev->truncate(dcr)) {
 315          goto bail_out;
 316       }
 317       if (!dev->is_tape()) {
 318          dev->close_part(dcr);        /* make sure DVD/file closed for rename */
 319       }
 320    }
 321
 322    /* Set the new filename for open, ... */
 323    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
 324    bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
 325    Dmsg1(150, "New VolName=%s\n", VolName);
 326    if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
 327       /* If device is not tape, attempt to create it */
 328       if (dev->is_tape() || dev->open(dcr, CREATE_READ_WRITE) < 0) {
 329          Jmsg3(dcr->jcr, M_WARNING, 0, _("Open device %s Volume \"%s\" failed: ERR=%s\n"),
 330                dev->print_name(), dcr->VolumeName, dev->bstrerror());
 331          goto bail_out;
 332       }
 333    }
 334    Dmsg1(150, "Label type=%d\n", dev->label_type);
 335    if (!dev->rewind(dcr)) {
 336       Dmsg2(130, "Bad status on %s from rewind: ERR=%s\n", dev->print_name(), dev->print_errmsg());
 337       if (!forge_on) {
 338          goto bail_out;
 339       }
 340    }
 341
 342    /* Temporarily mark in append state to enable writing */
 343    dev->set_append();
 344
 345    /* Create PRE_LABEL or VOL_LABEL if DVD */
 346    create_volume_label(dev, VolName, PoolName, dvdnow);
 347
 348    /*
 349     * If we have already detected an ANSI label, re-read it
 350     *   to skip past it. Otherwise, we write a new one if
 351     *   so requested.
 352     */
 353    if (dev->label_type != B_BACULA_LABEL) {
 354       if (read_ansi_ibm_label(dcr) != VOL_OK) {
 355          dev->rewind(dcr);
 356          goto bail_out;
 357       }
 358    } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, VolName)) {
 359       goto bail_out;
 360    }
 361
 362    create_volume_label_record(dcr, dcr->rec);
 363    dcr->rec->Stream = 0;
 364
 365    if (!write_record_to_block(dcr->block, dcr->rec)) {
 366       Dmsg2(130, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
 367       goto bail_out;
 368    } else {
 369       Dmsg2(130, "Wrote label of %d bytes to %s\n", dcr->rec->data_len, dev->print_name());
 370    }
 371
 372    Dmsg0(130, "Call write_block_to_dev()\n");
 373    if (!write_block_to_dev(dcr)) {
 374       Dmsg2(130, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
 375       goto bail_out;
 376    }
 377
 378    /* Now commit block to DVD if we should write now */
 379    if (dev->is_dvd() && dvdnow) {
 380       Dmsg1(150, "New VolName=%s\n", dev->VolCatInfo.VolCatName);
 381       if (!dvd_write_part(dcr)) {
 382          Dmsg2(130, "Bad DVD write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
 383          goto bail_out;
 384       }
 385    }
 386
 387    Dmsg0(130, " Wrote block to device\n");
 388
 389    if (dev->weof(1)) {
 390       dev->set_labeled();
 391       write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName);
 392    }
 393
 394    if (debug_level >= 20)  {
 395       dump_volume_label(dev);
 396    }
 397    Dmsg0(100, "Call reserve_volume\n");
 398    if (reserve_volume(dcr, VolName) == NULL) {
 399       Mmsg2(dcr->jcr->errmsg, _("Could not reserve volume %s on %s\n"),
 400            dev->VolHdr.VolumeName, dev->print_name());
 401       goto bail_out;
 402    }
 403    dev = dcr->dev;                    /* may have changed in reserve_volume */
 404
 405    dev->clear_append();               /* remove append since this is PRE_LABEL */
 406    return true;
 407
 408 bail_out:
 409    volume_unused(dcr);
 410    dev->clear_volhdr();
 411    dev->clear_append();               /* remove append since this is PRE_LABEL */
 412    return false;
 413 }
 414
 415 /*
 416  * Write a volume label. This is ONLY called if we have a valid Bacula
 417  *   label of type PRE_LABEL or we are recyling an existing Volume.
 418  *
 419  *  Returns: true if OK
 420  *           false if unable to write it
 421  */
 422 bool rewrite_volume_label(DCR *dcr, bool recycle)
 423 {
 424    DEVICE *dev = dcr->dev;
 425    JCR *jcr = dcr->jcr;
 426
 427    if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
 428        Jmsg3(jcr, M_WARNING, 0, _("Open device %s Volume \"%s\" failed: ERR=%s\n"),
 429              dev->print_name(), dcr->VolumeName, dev->bstrerror());
 430       return false;
 431    }
 432    Dmsg2(190, "set append found freshly labeled volume. fd=%d dev=%x\n", dev->fd(), dev);
 433    dev->VolHdr.LabelType = VOL_LABEL; /* set Volume label */
 434    dev->set_append();
 435    if (!write_volume_label_to_block(dcr)) {
 436       Dmsg0(200, "Error from write volume label.\n");
 437       return false;
 438    }
 439    Dmsg1(150, "wrote vol label to block. Vol=%s\n", dcr->VolumeName);
 440
 441    dev->VolCatInfo.VolCatBytes = 0;        /* reset byte count */
 442
 443    /*
 444     * If we are not dealing with a streaming device,
 445     *  write the block now to ensure we have write permission.
 446     *  It is better to find out now rather than later.
 447     * We do not write the block now if this is an ANSI label. This
 448     *  avoids re-writing the ANSI label, which we do not want to do.
 449     */
 450    if (!dev->has_cap(CAP_STREAM)) {
 451       if (!dev->rewind(dcr)) {
 452          Jmsg2(jcr, M_FATAL, 0, _("Rewind error on device %s: ERR=%s\n"),
 453                dev->print_name(), dev->print_errmsg());
 454          return false;
 455       }
 456       if (recycle) {
 457          Dmsg1(150, "Doing recycle. Vol=%s\n", dcr->VolumeName);
 458 //       volume_unused(dcr);             /* mark volume unused */
 459          if (!dev->truncate(dcr)) {
 460             Jmsg2(jcr, M_FATAL, 0, _("Truncate error on device %s: ERR=%s\n"),
 461                   dev->print_name(), dev->print_errmsg());
 462             return false;
 463          }
 464          if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
 465             Jmsg2(jcr, M_FATAL, 0,
 466                _("Failed to re-open DVD after truncate on device %s: ERR=%s\n"),
 467                dev->print_name(), dev->print_errmsg());
 468             return false;
 469          }
 470       }
 471
 472       /*
 473        * If we have already detected an ANSI label, re-read it
 474        *   to skip past it. Otherwise, we write a new one if
 475        *   so requested.
 476        */
 477       if (dev->label_type != B_BACULA_LABEL) {
 478          if (read_ansi_ibm_label(dcr) != VOL_OK) {
 479             dev->rewind(dcr);
 480             return false;
 481          }
 482       } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, dev->VolHdr.VolumeName)) {
 483          return false;
 484       }
 485
 486       /* Attempt write to check write permission */
 487       Dmsg1(200, "Attempt to write to device fd=%d.\n", dev->fd());
 488       if (!write_block_to_dev(dcr)) {
 489          Jmsg2(jcr, M_ERROR, 0, _("Unable to write device %s: ERR=%s\n"),
 490             dev->print_name(), dev->print_errmsg());
 491          Dmsg0(200, "===ERROR write block to dev\n");
 492          return false;
 493       }
 494    }
 495    dev->set_labeled();
 496    /* Set or reset Volume statistics */
 497    dev->VolCatInfo.VolCatJobs = 0;
 498    dev->VolCatInfo.VolCatFiles = 0;
 499    dev->VolCatInfo.VolCatErrors = 0;
 500    dev->VolCatInfo.VolCatBlocks = 0;
 501    dev->VolCatInfo.VolCatRBytes = 0;
 502    if (recycle) {
 503       dev->VolCatInfo.VolCatMounts++;
 504       dev->VolCatInfo.VolCatRecycles++;
 505       dir_create_jobmedia_record(dcr, true);
 506    } else {
 507       dev->VolCatInfo.VolCatMounts = 1;
 508       dev->VolCatInfo.VolCatRecycles = 0;
 509       dev->VolCatInfo.VolCatWrites = 1;
 510       dev->VolCatInfo.VolCatReads = 1;
 511    }
 512    Dmsg1(150, "dir_update_vol_info. Set Append vol=%s\n", dcr->VolumeName);
 513    bstrncpy(dev->VolCatInfo.VolCatStatus, "Append", sizeof(dev->VolCatInfo.VolCatStatus));
 514    bstrncpy(dev->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dev->VolCatInfo.VolCatName));
 515    if (!dir_update_volume_info(dcr, true, true)) {  /* indicate doing relabel */
 516       return false;
 517    }
 518    if (recycle) {
 519       Jmsg(jcr, M_INFO, 0, _("Recycled volume \"%s\" on device %s, all previous data lost.\n"),
 520          dcr->VolumeName, dev->print_name());
 521    } else {
 522       Jmsg(jcr, M_INFO, 0, _("Wrote label to prelabeled Volume \"%s\" on device %s\n"),
 523          dcr->VolumeName, dev->print_name());
 524    }
 525    /*
 526     * End writing real Volume label (from pre-labeled tape), or recycling
 527     *  the volume.
 528     */
 529    Dmsg1(150, "OK from rewrite vol label. Vol=%s\n", dcr->VolumeName);
 530    return true;
 531 }
 532
 533
 534 /*
 535  *  create_volume_label_record
 536  *   Serialize label (from dev->VolHdr structure) into device record.
 537  *   Assumes that the dev->VolHdr structure is properly
 538  *   initialized.
 539 */
 540 static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec)
 541 {
 542    ser_declare;
 543    struct date_time dt;
 544    DEVICE *dev = dcr->dev;
 545    JCR *jcr = dcr->jcr;
 546    char buf[100];
 547
 548    /* Serialize the label into the device record. */
 549
 550    rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label);
 551    ser_begin(rec->data, SER_LENGTH_Volume_Label);
 552    ser_string(dev->VolHdr.Id);
 553
 554    ser_uint32(dev->VolHdr.VerNum);
 555
 556    if (dev->VolHdr.VerNum >= 11) {
 557       ser_btime(dev->VolHdr.label_btime);
 558       dev->VolHdr.write_btime = get_current_btime();
 559       ser_btime(dev->VolHdr.write_btime);
 560       dev->VolHdr.write_date = 0;
 561       dev->VolHdr.write_time = 0;
 562    } else {
 563       /* OLD WAY DEPRECATED */
 564       ser_float64(dev->VolHdr.label_date);
 565       ser_float64(dev->VolHdr.label_time);
 566       get_current_time(&dt);
 567       dev->VolHdr.write_date = dt.julian_day_number;
 568       dev->VolHdr.write_time = dt.julian_day_fraction;
 569    }
 570    ser_float64(dev->VolHdr.write_date);   /* 0 if VerNum >= 11 */
 571    ser_float64(dev->VolHdr.write_time);   /* 0  if VerNum >= 11 */
 572
 573    ser_string(dev->VolHdr.VolumeName);
 574    ser_string(dev->VolHdr.PrevVolumeName);
 575    ser_string(dev->VolHdr.PoolName);
 576    ser_string(dev->VolHdr.PoolType);
 577    ser_string(dev->VolHdr.MediaType);
 578
 579    ser_string(dev->VolHdr.HostName);
 580    ser_string(dev->VolHdr.LabelProg);
 581    ser_string(dev->VolHdr.ProgVersion);
 582    ser_string(dev->VolHdr.ProgDate);
 583
 584    ser_end(rec->data, SER_LENGTH_Volume_Label);
 585    bstrncpy(dcr->VolumeName, dev->VolHdr.VolumeName, sizeof(dcr->VolumeName));
 586    rec->data_len = ser_length(rec->data);
 587    rec->FileIndex = dev->VolHdr.LabelType;
 588    rec->VolSessionId = jcr->VolSessionId;
 589    rec->VolSessionTime = jcr->VolSessionTime;
 590    rec->Stream = jcr->NumWriteVolumes;
 591    Dmsg2(150, "Created Vol label rec: FI=%s len=%d\n", FI_to_ascii(buf, rec->FileIndex),
 592       rec->data_len);
 593 }
 594
 595
 596 /*
 597  * Create a volume label in memory
 598  */
 599 void create_volume_label(DEVICE *dev, const char *VolName,
 600                          const char *PoolName, bool dvdnow)
 601 {
 602    DEVRES *device = (DEVRES *)dev->device;
 603
 604    Dmsg0(130, "Start create_volume_label()\n");
 605
 606    ASSERT(dev != NULL);
 607
 608    dev->clear_volhdr();          /* clear any old volume info */
 609
 610    bstrncpy(dev->VolHdr.Id, BaculaId, sizeof(dev->VolHdr.Id));
 611    dev->VolHdr.VerNum = BaculaTapeVersion;
 612    if (dev->is_dvd() && dvdnow) {
 613       /* We do not want to re-label a DVD so write VOL_LABEL now */
 614       dev->VolHdr.LabelType = VOL_LABEL;
 615    } else {
 616       dev->VolHdr.LabelType = PRE_LABEL;  /* Mark tape as unused */
 617    }
 618    bstrncpy(dev->VolHdr.VolumeName, VolName, sizeof(dev->VolHdr.VolumeName));
 619    bstrncpy(dev->VolHdr.PoolName, PoolName, sizeof(dev->VolHdr.PoolName));
 620    bstrncpy(dev->VolHdr.MediaType, device->media_type, sizeof(dev->VolHdr.MediaType));
 621
 622    bstrncpy(dev->VolHdr.PoolType, "Backup", sizeof(dev->VolHdr.PoolType));
 623
 624    dev->VolHdr.label_btime = get_current_btime();
 625    dev->VolHdr.label_date = 0;
 626    dev->VolHdr.label_time = 0;
 627
 628    if (gethostname(dev->VolHdr.HostName, sizeof(dev->VolHdr.HostName)) != 0) {
 629       dev->VolHdr.HostName[0] = 0;
 630    }
 631    bstrncpy(dev->VolHdr.LabelProg, my_name, sizeof(dev->VolHdr.LabelProg));
 632    sprintf(dev->VolHdr.ProgVersion, "Ver. %s %s", VERSION, BDATE);
 633    sprintf(dev->VolHdr.ProgDate, "Build %s %s", __DATE__, __TIME__);
 634    dev->set_labeled();               /* set has Bacula label */
 635    if (debug_level >= 90) {
 636       dump_volume_label(dev);
 637    }
 638 }
 639
 640 /*
 641  * Create session label
 642  *  The pool memory must be released by the calling program
 643  */
 644 void create_session_label(DCR *dcr, DEV_RECORD *rec, int label)
 645 {
 646    JCR *jcr = dcr->jcr;
 647    ser_declare;
 648
 649    rec->VolSessionId   = jcr->VolSessionId;
 650    rec->VolSessionTime = jcr->VolSessionTime;
 651    rec->Stream         = jcr->JobId;
 652
 653    rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label);
 654    ser_begin(rec->data, SER_LENGTH_Session_Label);
 655    ser_string(BaculaId);
 656    ser_uint32(BaculaTapeVersion);
 657
 658    ser_uint32(jcr->JobId);
 659
 660    /* Changed in VerNum 11 */
 661    ser_btime(get_current_btime());
 662    ser_float64(0);
 663
 664    ser_string(dcr->pool_name);
 665    ser_string(dcr->pool_type);
 666    ser_string(jcr->job_name);         /* base Job name */
 667    ser_string(jcr->client_name);
 668
 669    /* Added in VerNum 10 */
 670    ser_string(jcr->Job);              /* Unique name of this Job */
 671    ser_string(jcr->fileset_name);
 672    ser_uint32(jcr->get_JobType());
 673    ser_uint32(jcr->get_JobLevel());
 674    /* Added in VerNum 11 */
 675    ser_string(jcr->fileset_md5);
 676
 677    if (label == EOS_LABEL) {
 678       ser_uint32(jcr->JobFiles);
 679       ser_uint64(jcr->JobBytes);
 680       ser_uint32(dcr->StartBlock);
 681       ser_uint32(dcr->EndBlock);
 682       ser_uint32(dcr->StartFile);
 683       ser_uint32(dcr->EndFile);
 684       ser_uint32(jcr->JobErrors);
 685
 686       /* Added in VerNum 11 */
 687       ser_uint32(jcr->JobStatus);
 688    }
 689    ser_end(rec->data, SER_LENGTH_Session_Label);
 690    rec->data_len = ser_length(rec->data);
 691 }
 692
 693 /* Write session label
 694  *  Returns: false on failure
 695  *           true  on success
 696  */
 697 bool write_session_label(DCR *dcr, int label)
 698 {
 699    JCR *jcr = dcr->jcr;
 700    DEVICE *dev = dcr->dev;
 701    DEV_RECORD *rec;
 702    DEV_BLOCK *block = dcr->block;
 703    char buf1[100], buf2[100];
 704
 705    rec = new_record();
 706    Dmsg1(130, "session_label record=%x\n", rec);
 707    switch (label) {
 708    case SOS_LABEL:
 709       set_start_vol_position(dcr);
 710       break;
 711    case EOS_LABEL:
 712       if (dev->is_tape()) {
 713          dcr->EndBlock = dev->EndBlock;
 714          dcr->EndFile  = dev->EndFile;
 715       } else {
 716          dcr->EndBlock = (uint32_t)dev->file_addr;
 717          dcr->EndFile = (uint32_t)(dev->file_addr >> 32);
 718       }
 719       break;
 720    default:
 721       Jmsg1(jcr, M_ABORT, 0, _("Bad Volume session label = %d\n"), label);
 722       break;
 723    }
 724    create_session_label(dcr, rec, label);
 725    rec->FileIndex = label;
 726
 727    /*
 728     * We guarantee that the session record can totally fit
 729     *  into a block. If not, write the block, and put it in
 730     *  the next block. Having the sesssion record totally in
 731     *  one block makes reading them much easier (no need to
 732     *  read the next block).
 733     */
 734    if (!can_write_record_to_block(block, rec)) {
 735       Dmsg0(150, "Cannot write session label to block.\n");
 736       if (!write_block_to_device(dcr)) {
 737          Dmsg0(130, "Got session label write_block_to_dev error.\n");
 738          free_record(rec);
 739          return false;
 740       }
 741    }
 742    if (!write_record_to_block(block, rec)) {
 743       free_record(rec);
 744       return false;
 745    }
 746
 747    Dmsg6(150, "Write sesson_label record JobId=%d FI=%s SessId=%d Strm=%s len=%d "
 748              "remainder=%d\n", jcr->JobId,
 749       FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
 750       stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
 751       rec->remainder);
 752
 753    free_record(rec);
 754    Dmsg2(150, "Leave write_session_label Block=%ud File=%ud\n",
 755       dev->get_block_num(), dev->get_file());
 756    return true;
 757 }
 758
 759 /*  unser_volume_label
 760  *
 761  * Unserialize the Bacula Volume label into the device Volume_Label
 762  * structure.
 763  *
 764  * Assumes that the record is already read.
 765  *
 766  * Returns: false on error
 767  *          true  on success
 768 */
 769
 770 bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec)
 771 {
 772    ser_declare;
 773    char buf1[100], buf2[100];
 774
 775    if (rec->FileIndex != VOL_LABEL && rec->FileIndex != PRE_LABEL) {
 776       Mmsg3(dev->errmsg, _("Expecting Volume Label, got FI=%s Stream=%s len=%d\n"),
 777               FI_to_ascii(buf1, rec->FileIndex),
 778               stream_to_ascii(buf2, rec->Stream, rec->FileIndex),
 779               rec->data_len);
 780       if (!forge_on) {
 781          return false;
 782       }
 783    }
 784
 785    dev->VolHdr.LabelType = rec->FileIndex;
 786    dev->VolHdr.LabelSize = rec->data_len;
 787
 788
 789    /* Unserialize the record into the Volume Header */
 790    rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label);
 791    ser_begin(rec->data, SER_LENGTH_Volume_Label);
 792    unser_string(dev->VolHdr.Id);
 793    unser_uint32(dev->VolHdr.VerNum);
 794
 795    if (dev->VolHdr.VerNum >= 11) {
 796       unser_btime(dev->VolHdr.label_btime);
 797       unser_btime(dev->VolHdr.write_btime);
 798    } else { /* old way */
 799       unser_float64(dev->VolHdr.label_date);
 800       unser_float64(dev->VolHdr.label_time);
 801    }
 802    unser_float64(dev->VolHdr.write_date);    /* Unused with VerNum >= 11 */
 803    unser_float64(dev->VolHdr.write_time);    /* Unused with VerNum >= 11 */
 804
 805    unser_string(dev->VolHdr.VolumeName);
 806    unser_string(dev->VolHdr.PrevVolumeName);
 807    unser_string(dev->VolHdr.PoolName);
 808    unser_string(dev->VolHdr.PoolType);
 809    unser_string(dev->VolHdr.MediaType);
 810
 811    unser_string(dev->VolHdr.HostName);
 812    unser_string(dev->VolHdr.LabelProg);
 813    unser_string(dev->VolHdr.ProgVersion);
 814    unser_string(dev->VolHdr.ProgDate);
 815
 816    ser_end(rec->data, SER_LENGTH_Volume_Label);
 817    Dmsg0(190, "unser_vol_label\n");
 818    if (debug_level >= 190) {
 819       dump_volume_label(dev);
 820    }
 821    return true;
 822 }
 823
 824
 825 bool unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec)
 826 {
 827    ser_declare;
 828
 829    rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label);
 830    unser_begin(rec->data, SER_LENGTH_Session_Label);
 831    unser_string(label->Id);
 832    unser_uint32(label->VerNum);
 833    unser_uint32(label->JobId);
 834    if (label->VerNum >= 11) {
 835       unser_btime(label->write_btime);
 836    } else {
 837       unser_float64(label->write_date);
 838    }
 839    unser_float64(label->write_time);
 840    unser_string(label->PoolName);
 841    unser_string(label->PoolType);
 842    unser_string(label->JobName);
 843    unser_string(label->ClientName);
 844    if (label->VerNum >= 10) {
 845       unser_string(label->Job);          /* Unique name of this Job */
 846       unser_string(label->FileSetName);
 847       unser_uint32(label->JobType);
 848       unser_uint32(label->JobLevel);
 849    }
 850    if (label->VerNum >= 11) {
 851       unser_string(label->FileSetMD5);
 852    } else {
 853       label->FileSetMD5[0] = 0;
 854    }
 855    if (rec->FileIndex == EOS_LABEL) {
 856       unser_uint32(label->JobFiles);
 857       unser_uint64(label->JobBytes);
 858       unser_uint32(label->StartBlock);
 859       unser_uint32(label->EndBlock);
 860       unser_uint32(label->StartFile);
 861       unser_uint32(label->EndFile);
 862       unser_uint32(label->JobErrors);
 863       if (label->VerNum >= 11) {
 864          unser_uint32(label->JobStatus);
 865       } else {
 866          label->JobStatus = JS_Terminated; /* kludge */
 867       }
 868    }
 869    return true;
 870 }
 871
 872 void dump_volume_label(DEVICE *dev)
 873 {
 874    int dbl = debug_level;
 875    uint32_t File;
 876    const char *LabelType;
 877    char buf[30];
 878    struct tm tm;
 879    struct date_time dt;
 880
 881    debug_level = 1;
 882    File = dev->file;
 883    switch (dev->VolHdr.LabelType) {
 884    case PRE_LABEL:
 885       LabelType = "PRE_LABEL";
 886       break;
 887    case VOL_LABEL:
 888       LabelType = "VOL_LABEL";
 889       break;
 890    case EOM_LABEL:
 891       LabelType = "EOM_LABEL";
 892       break;
 893    case SOS_LABEL:
 894       LabelType = "SOS_LABEL";
 895       break;
 896    case EOS_LABEL:
 897       LabelType = "EOS_LABEL";
 898       break;
 899    case EOT_LABEL:
 900       goto bail_out;
 901    default:
 902       LabelType = buf;
 903       sprintf(buf, _("Unknown %d"), dev->VolHdr.LabelType);
 904       break;
 905    }
 906
 907    Pmsg11(-1, _("\nVolume Label:\n"
 908 "Id                : %s"
 909 "VerNo             : %d\n"
 910 "VolName           : %s\n"
 911 "PrevVolName       : %s\n"
 912 "VolFile           : %d\n"
 913 "LabelType         : %s\n"
 914 "LabelSize         : %d\n"
 915 "PoolName          : %s\n"
 916 "MediaType         : %s\n"
 917 "PoolType          : %s\n"
 918 "HostName          : %s\n"
 919 ""),
 920              dev->VolHdr.Id, dev->VolHdr.VerNum,
 921              dev->VolHdr.VolumeName, dev->VolHdr.PrevVolumeName,
 922              File, LabelType, dev->VolHdr.LabelSize,
 923              dev->VolHdr.PoolName, dev->VolHdr.MediaType,
 924              dev->VolHdr.PoolType, dev->VolHdr.HostName);
 925
 926    if (dev->VolHdr.VerNum >= 11) {
 927       char dt[50];
 928       bstrftime(dt, sizeof(dt), btime_to_utime(dev->VolHdr.label_btime));
 929       Pmsg1(-1, _("Date label written: %s\n"), dt);
 930    } else {
 931       dt.julian_day_number   = dev->VolHdr.label_date;
 932       dt.julian_day_fraction = dev->VolHdr.label_time;
 933       tm_decode(&dt, &tm);
 934       Pmsg5(-1,
 935             _("Date label written: %04d-%02d-%02d at %02d:%02d\n"),
 936               tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min);
 937    }
 938
 939 bail_out:
 940    debug_level = dbl;
 941 }
 942
 943
 944 static void dump_session_label(DEV_RECORD *rec, const char *type)
 945 {
 946    int dbl;
 947    struct date_time dt;
 948    struct tm tm;
 949    SESSION_LABEL label;
 950    char ec1[30], ec2[30], ec3[30], ec4[30], ec5[30], ec6[30], ec7[30];
 951
 952    unser_session_label(&label, rec);
 953    dbl = debug_level;
 954    debug_level = 1;
 955    Pmsg7(-1, _("\n%s Record:\n"
 956 "JobId             : %d\n"
 957 "VerNum            : %d\n"
 958 "PoolName          : %s\n"
 959 "PoolType          : %s\n"
 960 "JobName           : %s\n"
 961 "ClientName        : %s\n"
 962 ""),    type, label.JobId, label.VerNum,
 963       label.PoolName, label.PoolType,
 964       label.JobName, label.ClientName);
 965
 966    if (label.VerNum >= 10) {
 967       Pmsg4(-1, _(
 968 "Job (unique name) : %s\n"
 969 "FileSet           : %s\n"
 970 "JobType           : %c\n"
 971 "JobLevel          : %c\n"
 972 ""), label.Job, label.FileSetName, label.JobType, label.JobLevel);
 973    }
 974
 975    if (rec->FileIndex == EOS_LABEL) {
 976       Pmsg8(-1, _(
 977 "JobFiles          : %s\n"
 978 "JobBytes          : %s\n"
 979 "StartBlock        : %s\n"
 980 "EndBlock          : %s\n"
 981 "StartFile         : %s\n"
 982 "EndFile           : %s\n"
 983 "JobErrors         : %s\n"
 984 "JobStatus         : %c\n"
 985 ""),
 986          edit_uint64_with_commas(label.JobFiles, ec1),
 987          edit_uint64_with_commas(label.JobBytes, ec2),
 988          edit_uint64_with_commas(label.StartBlock, ec3),
 989          edit_uint64_with_commas(label.EndBlock, ec4),
 990          edit_uint64_with_commas(label.StartFile, ec5),
 991          edit_uint64_with_commas(label.EndFile, ec6),
 992          edit_uint64_with_commas(label.JobErrors, ec7),
 993          label.JobStatus);
 994    }
 995    if (label.VerNum >= 11) {
 996       char dt[50];
 997       bstrftime(dt, sizeof(dt), btime_to_utime(label.write_btime));
 998       Pmsg1(-1, _("Date written      : %s\n"), dt);
 999    } else {
1000       dt.julian_day_number   = label.write_date;
1001       dt.julian_day_fraction = label.write_time;
1002       tm_decode(&dt, &tm);
1003       Pmsg5(-1, _("Date written      : %04d-%02d-%02d at %02d:%02d\n"),
1004       tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min);
1005    }
1006
1007    debug_level = dbl;
1008 }
1009
1010 void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose)
1011 {
1012    const char *type;
1013    int dbl;
1014
1015    if (rec->FileIndex == 0 && rec->VolSessionId == 0 && rec->VolSessionTime == 0) {
1016       return;
1017    }
1018    dbl = debug_level;
1019    debug_level = 1;
1020    switch (rec->FileIndex) {
1021    case PRE_LABEL:
1022       type = _("Fresh Volume");
1023       break;
1024    case VOL_LABEL:
1025       type = _("Volume");
1026       break;
1027    case SOS_LABEL:
1028       type = _("Begin Job Session");
1029       break;
1030    case EOS_LABEL:
1031       type = _("End Job Session");
1032       break;
1033    case EOM_LABEL:
1034       type = _("End of Media");
1035       break;
1036    case EOT_LABEL:
1037       type = _("End of Tape");
1038       break;
1039    default:
1040       type = _("Unknown");
1041       break;
1042    }
1043    if (verbose) {
1044       switch (rec->FileIndex) {
1045       case PRE_LABEL:
1046       case VOL_LABEL:
1047          unser_volume_label(dev, rec);
1048          dump_volume_label(dev);
1049          break;
1050       case SOS_LABEL:
1051          dump_session_label(rec, type);
1052          break;
1053       case EOS_LABEL:
1054          dump_session_label(rec, type);
1055          break;
1056       case EOM_LABEL:
1057          Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
1058             type, dev->file, dev->block_num, rec->VolSessionId,
1059             rec->VolSessionTime, rec->Stream, rec->data_len);
1060          break;
1061       case EOT_LABEL:
1062          Pmsg0(-1, _("End of physical tape.\n"));
1063          break;
1064       default:
1065          Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
1066             type, dev->file, dev->block_num, rec->VolSessionId,
1067             rec->VolSessionTime, rec->Stream, rec->data_len);
1068          break;
1069       }
1070    } else {
1071       SESSION_LABEL label;
1072       char dt[50];
1073       switch (rec->FileIndex) {
1074       case SOS_LABEL:
1075          unser_session_label(&label, rec);
1076          bstrftimes(dt, sizeof(dt), btime_to_utime(label.write_btime));
1077          Pmsg6(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d\n"),
1078             type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, label.JobId);
1079          Pmsg4(-1, _("   Job=%s Date=%s Level=%c Type=%c\n"),
1080             label.Job, dt, label.JobLevel, label.JobType);
1081          break;
1082       case EOS_LABEL:
1083          char ed1[30], ed2[30];
1084          unser_session_label(&label, rec);
1085          bstrftimes(dt, sizeof(dt), btime_to_utime(label.write_btime));
1086          Pmsg6(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d\n"),
1087             type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, label.JobId);
1088          Pmsg7(-1, _("   Date=%s Level=%c Type=%c Files=%s Bytes=%s Errors=%d Status=%c\n"),
1089             dt, label.JobLevel, label.JobType,
1090             edit_uint64_with_commas(label.JobFiles, ed1),
1091             edit_uint64_with_commas(label.JobBytes, ed2),
1092             label.JobErrors, (char)label.JobStatus);
1093          break;
1094       case EOM_LABEL:
1095       case PRE_LABEL:
1096       case VOL_LABEL:
1097       default:
1098          Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
1099             type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime,
1100             rec->Stream, rec->data_len);
1101          break;
1102       case EOT_LABEL:
1103          break;
1104       }
1105    }
1106    debug_level = dbl;
1107 }