3 * label.c Bacula routines to handle labels
11 Copyright (C) 2000-2006 Kern Sibbald
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License
15 version 2 as amended with additional clauses defined in the
16 file LICENSE in the main source directory.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 the file LICENSE for additional details.
25 #include "bacula.h" /* pull in global headers */
26 #include "stored.h" /* pull in Storage Deamon headers */
28 /* Forward referenced functions */
29 static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec);
32 * Read the volume label
34 * If dcr->VolumeName == NULL, we accept any Bacula Volume
35 * If dcr->VolumeName[0] == 0, we accept any Bacula Volume
36 * otherwise dcr->VolumeName must match the Volume.
38 * If VolName given, ensure that it matches
40 * Returns VOL_ code as defined in record.h
42 * VOL_OK good label found
43 * VOL_NO_LABEL volume not labeled
44 * VOL_IO_ERROR I/O error reading tape
45 * VOL_NAME_ERROR label has wrong name
46 * VOL_CREATE_ERROR Error creating label
47 * VOL_VERSION_ERROR label has wrong version
48 * VOL_LABEL_ERROR bad label type
49 * VOL_NO_MEDIA no media in drive
51 * The dcr block is emptied on return, and the Volume is
54 int read_dev_volume_label(DCR *dcr)
57 DEVICE *dev = dcr->dev;
58 char *VolName = dcr->VolumeName;
61 DEV_BLOCK *block = dcr->block;
64 bool have_ansi_label = false;
66 Dmsg4(100, "Enter read_volume_label res=%d device=%s vol=%s dev_Vol=%s\n",
67 dev->reserved_device, dev->print_name(), VolName,
68 dev->VolHdr.VolumeName[0]?dev->VolHdr.VolumeName:"*NULL*");
70 if (!dev->is_open()) {
71 if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
75 if (dev->is_labeled()) { /* did we already read label? */
76 /* Compare Volume Names allow special wild card */
77 if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolumeName, VolName) != 0) {
78 Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
79 dev->print_name(), VolName, dev->VolHdr.VolumeName);
81 * Cancel Job if too many label errors
84 if (!dev->poll && jcr->label_errors++ > 100) {
85 Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg);
87 Dmsg0(150, "return VOL_NAME_ERROR\n");
88 stat = VOL_NAME_ERROR;
91 Dmsg0(30, "Leave read_volume_label() VOL_OK\n");
92 return VOL_OK; /* label already read */
98 dev->label_type = B_BACULA_LABEL;
100 if (!dev->rewind(dcr)) {
101 Mmsg(jcr->errmsg, _("Couldn't rewind device %s: ERR=%s\n"),
102 dev->print_name(), dev->bstrerror());
103 Dmsg1(30, "return VOL_NO_MEDIA: %s", jcr->errmsg);
106 bstrncpy(dev->VolHdr.Id, "**error**", sizeof(dev->VolHdr.Id));
108 /* Read ANSI/IBM label if so requested */
110 want_ansi_label = dcr->VolCatInfo.LabelType != B_BACULA_LABEL ||
111 dcr->device->label_type != B_BACULA_LABEL;
112 if (want_ansi_label || dev_cap(dev, CAP_CHECKLABELS)) {
113 stat = read_ansi_ibm_label(dcr);
114 /* If we want a label and didn't find it, return error */
115 if (want_ansi_label && stat != VOL_OK) {
118 if (stat == VOL_NAME_ERROR || stat == VOL_LABEL_ERROR) {
119 Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
120 dev->print_name(), VolName, dev->VolHdr.VolumeName);
121 if (!dev->poll && jcr->label_errors++ > 100) {
122 Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg);
126 if (stat != VOL_OK) { /* Not an ANSI/IBM label, so re-read */
129 have_ansi_label = true;
133 /* Read the Bacula Volume label block */
134 record = new_record();
137 Dmsg0(90, "Big if statement in read_volume_label\n");
138 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
139 Mmsg(jcr->errmsg, _("Requested Volume \"%s\" on %s is not a Bacula "
140 "labeled Volume, because: ERR=%s"), NPRT(VolName),
141 dev->print_name(), dev->bstrerror());
142 Dmsg1(30, "%s", jcr->errmsg);
143 } else if (!read_record_from_block(block, record)) {
144 Mmsg(jcr->errmsg, _("Could not read Volume label from block.\n"));
145 Dmsg1(30, "%s", jcr->errmsg);
146 } else if (!unser_volume_label(dev, record)) {
147 Mmsg(jcr->errmsg, _("Could not unserialize Volume label: ERR=%s\n"),
149 Dmsg1(30, "%s", jcr->errmsg);
150 } else if (strcmp(dev->VolHdr.Id, BaculaId) != 0 &&
151 strcmp(dev->VolHdr.Id, OldBaculaId) != 0) {
152 Mmsg(jcr->errmsg, _("Volume Header Id bad: %s\n"), dev->VolHdr.Id);
153 Dmsg1(30, "%s", jcr->errmsg);
157 free_record(record); /* finished reading Volume record */
160 if (forge_on || jcr->ignore_label_errors) {
161 dev->set_labeled(); /* set has Bacula label */
162 Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg);
166 Dmsg0(100, "No volume label - bailing out\n");
171 /* At this point, we have read the first Bacula block, and
172 * then read the Bacula Volume label. Now we need to
173 * make sure we have the right Volume.
177 if (dev->VolHdr.VerNum != BaculaTapeVersion &&
178 dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion1 &&
179 dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion2) {
180 Mmsg(jcr->errmsg, _("Volume on %s has wrong Bacula version. Wanted %d got %d\n"),
181 dev->print_name(), BaculaTapeVersion, dev->VolHdr.VerNum);
182 Dmsg1(30, "VOL_VERSION_ERROR: %s", jcr->errmsg);
183 stat = VOL_VERSION_ERROR;
187 /* We are looking for either an unused Bacula tape (PRE_LABEL) or
188 * a Bacula volume label (VOL_LABEL)
190 if (dev->VolHdr.LabelType != PRE_LABEL && dev->VolHdr.LabelType != VOL_LABEL) {
191 Mmsg(jcr->errmsg, _("Volume on %s has bad Bacula label type: %x\n"),
192 dev->print_name(), dev->VolHdr.LabelType);
193 Dmsg1(30, "%s", jcr->errmsg);
194 if (!dev->poll && jcr->label_errors++ > 100) {
195 Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg);
197 Dmsg0(150, "return VOL_LABEL_ERROR\n");
198 stat = VOL_LABEL_ERROR;
202 dev->set_labeled(); /* set has Bacula label */
203 new_volume(dcr, dev->VolHdr.VolumeName);
205 /* Compare Volume Names */
206 Dmsg2(30, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolumeName);
207 if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolumeName, VolName) != 0) {
208 Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
209 dev->print_name(), VolName, dev->VolHdr.VolumeName);
210 Dmsg1(30, "%s", jcr->errmsg);
212 * Cancel Job if too many label errors
213 * => we are in a loop
215 if (!dev->poll && jcr->label_errors++ > 100) {
216 Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg);
218 Dmsg0(150, "return VOL_NAME_ERROR\n");
219 stat = VOL_NAME_ERROR;
222 Dmsg1(30, "Copy vol_name=%s\n", dev->VolHdr.VolumeName);
224 if (debug_level >= 10) {
225 dump_volume_label(dev);
227 Dmsg0(30, "Leave read_volume_label() VOL_OK\n");
228 /* If we are a streaming device, we only get one chance to read */
229 if (!dev_cap(dev, CAP_STREAM)) {
231 if (have_ansi_label) {
232 stat = read_ansi_ibm_label(dcr);
233 /* If we want a label and didn't find it, return error */
234 if (stat != VOL_OK) {
245 Dmsg1(150, "return %d\n", stat);
250 * Put a volume label into the block
252 * Returns: false on failure
255 bool write_volume_label_to_block(DCR *dcr)
258 DEVICE *dev = dcr->dev;
260 DEV_BLOCK *block = dcr->block;
262 Dmsg0(20, "write Label in write_volume_label_to_block()\n");
263 memset(&rec, 0, sizeof(rec));
264 rec.data = get_memory(SER_LENGTH_Volume_Label);
265 empty_block(block); /* Volume label always at beginning */
267 create_volume_label_record(dcr, &rec);
269 block->BlockNumber = 0;
270 if (!write_record_to_block(block, &rec)) {
271 free_pool_memory(rec.data);
272 Jmsg1(jcr, M_FATAL, 0, _("Cannot write Volume label to block for device %s\n"),
276 Dmsg1(90, "Wrote label of %d bytes to block\n", rec.data_len);
278 free_pool_memory(rec.data);
284 * Write a Volume Label
285 * !!! Note, this is ONLY used for writing
286 * a fresh volume label. Any data
287 * after the label will be destroyed,
288 * in fact, we write the label 5 times !!!!
290 * This routine should be used only when labeling a blank tape.
292 bool write_new_volume_label_to_dev(DCR *dcr, const char *VolName,
293 const char *PoolName, bool relabel, bool dvdnow)
295 DEVICE *dev = dcr->dev;
298 Dmsg0(99, "write_volume_label()\n");
299 empty_block(dcr->block);
301 /* If relabeling, truncate the device */
302 if (relabel && !dev->truncate(dcr)) {
307 dev->close_part(dcr); /* make sure closed for rename */
310 /* Set the new filename for open, ... */
311 bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
312 bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
313 Dmsg1(150, "New VolName=%s\n", VolName);
314 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
315 /* If device is not tape, attempt to create it */
316 if (dev->is_tape() || dev->open(dcr, CREATE_READ_WRITE) < 0) {
320 Dmsg1(150, "Label type=%d\n", dev->label_type);
321 if (!dev->rewind(dcr)) {
323 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
324 Dmsg2(30, "Bad status on %s from rewind: ERR=%s\n", dev->print_name(), dev->bstrerror());
330 /* Create PRE_LABEL or VOL_LABEL if DVD */
331 create_volume_label(dev, VolName, PoolName, dvdnow);
334 * If we have already detected an ANSI label, re-read it
335 * to skip past it. Otherwise, we write a new one if
338 if (dev->label_type != B_BACULA_LABEL) {
339 if (read_ansi_ibm_label(dcr) != VOL_OK) {
343 } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, VolName)) {
347 create_volume_label_record(dcr, dcr->rec);
348 dcr->rec->Stream = 0;
350 /* Temporarily mark in append state to enable writing */
352 if (!write_record_to_block(dcr->block, dcr->rec)) {
353 Dmsg2(30, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->bstrerror());
356 Dmsg2(30, "Wrote label of %d bytes to %s\n", dcr->rec->data_len, dev->print_name());
359 Dmsg0(99, "Call write_block_to_dev()\n");
360 if (!write_block_to_dev(dcr)) {
361 Dmsg2(30, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->bstrerror());
365 /* Now commit block to DVD if we should write now */
366 if (dev->is_dvd() && dvdnow) {
367 Dmsg1(150, "New VolName=%s\n", dev->VolCatInfo.VolCatName);
368 if (!dvd_write_part(dcr)) {
369 Dmsg2(30, "Bad DVD write on %s: ERR=%s\n", dev->print_name(), dev->bstrerror());
374 Dmsg0(99, " Wrote block to device\n");
378 write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName);
381 if (debug_level >= 20) {
382 dump_volume_label(dev);
384 new_volume(dcr, VolName);
385 dev->clear_append(); /* remove append since this is PRE_LABEL */
390 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
391 dev->clear_append(); /* remove append since this is PRE_LABEL */
396 * Write a volume label. This is ONLY called if we have a valid Bacula
397 * label of type PRE_LABEL;
398 * Returns: true if OK
399 * false if unable to write it
401 bool rewrite_volume_label(DCR *dcr, bool recycle)
403 DEVICE *dev = dcr->dev;
406 if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
409 Dmsg2(190, "set append found freshly labeled volume. fd=%d dev=%x\n", dev->fd, dev);
410 dev->VolHdr.LabelType = VOL_LABEL; /* set Volume label */
412 if (!write_volume_label_to_block(dcr)) {
413 Dmsg0(200, "Error from write volume label.\n");
417 dev->VolCatInfo.VolCatBytes = 0; /* reset byte count */
420 * If we are not dealing with a streaming device,
421 * write the block now to ensure we have write permission.
422 * It is better to find out now rather than later.
423 * We do not write the block now if this is an ANSI label. This
424 * avoids re-writing the ANSI label, which we do not want to do.
426 if (!dev_cap(dev, CAP_STREAM)) {
427 if (!dev->rewind(dcr)) {
428 Jmsg2(jcr, M_FATAL, 0, _("Rewind error on device %s: ERR=%s\n"),
429 dev->print_name(), dev->bstrerror());
433 if (!dev->truncate(dcr)) {
434 Jmsg2(jcr, M_FATAL, 0, _("Truncate error on device %s: ERR=%s\n"),
435 dev->print_name(), dev->bstrerror());
441 * If we have already detected an ANSI label, re-read it
442 * to skip past it. Otherwise, we write a new one if
445 if (dev->label_type != B_BACULA_LABEL) {
446 if (read_ansi_ibm_label(dcr) != VOL_OK) {
450 } else if (!write_ansi_ibm_labels(dcr, ANSI_VOL_LABEL, dev->VolHdr.VolumeName)) {
454 /* Attempt write to check write permission */
455 Dmsg1(200, "Attempt to write to device fd=%d.\n", dev->fd);
456 if (!write_block_to_dev(dcr)) {
457 Jmsg2(jcr, M_ERROR, 0, _("Unable to write device %s: ERR=%s\n"),
458 dev->print_name(), dev->bstrerror());
459 Dmsg0(200, "===ERROR write block to dev\n");
463 /* Set or reset Volume statistics */
464 dev->VolCatInfo.VolCatJobs = 0;
465 dev->VolCatInfo.VolCatFiles = 0;
466 dev->VolCatInfo.VolCatErrors = 0;
467 dev->VolCatInfo.VolCatBlocks = 0;
468 dev->VolCatInfo.VolCatRBytes = 0;
470 dev->VolCatInfo.VolCatMounts++;
471 dev->VolCatInfo.VolCatRecycles++;
473 dev->VolCatInfo.VolCatMounts = 1;
474 dev->VolCatInfo.VolCatRecycles = 0;
475 dev->VolCatInfo.VolCatWrites = 1;
476 dev->VolCatInfo.VolCatReads = 1;
478 Dmsg0(150, "dir_update_vol_info. Set Append\n");
479 bstrncpy(dev->VolCatInfo.VolCatStatus, "Append", sizeof(dev->VolCatInfo.VolCatStatus));
480 if (!dir_update_volume_info(dcr, true)) { /* indicate doing relabel */
484 Jmsg(jcr, M_INFO, 0, _("Recycled volume \"%s\" on device %s, all previous data lost.\n"),
485 dcr->VolumeName, dev->print_name());
487 Jmsg(jcr, M_INFO, 0, _("Wrote label to prelabeled Volume \"%s\" on device %s\n"),
488 dcr->VolumeName, dev->print_name());
491 * End writing real Volume label (from pre-labeled tape), or recycling
494 Dmsg0(200, "OK from rewrite vol label.\n");
500 * create_volume_label_record
501 * Serialize label (from dev->VolHdr structure) into device record.
502 * Assumes that the dev->VolHdr structure is properly
505 static void create_volume_label_record(DCR *dcr, DEV_RECORD *rec)
509 DEVICE *dev = dcr->dev;
513 /* Serialize the label into the device record. */
515 rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label);
516 ser_begin(rec->data, SER_LENGTH_Volume_Label);
517 ser_string(dev->VolHdr.Id);
519 ser_uint32(dev->VolHdr.VerNum);
521 if (dev->VolHdr.VerNum >= 11) {
522 ser_btime(dev->VolHdr.label_btime);
523 dev->VolHdr.write_btime = get_current_btime();
524 ser_btime(dev->VolHdr.write_btime);
525 dev->VolHdr.write_date = 0;
526 dev->VolHdr.write_time = 0;
528 /* OLD WAY DEPRECATED */
529 ser_float64(dev->VolHdr.label_date);
530 ser_float64(dev->VolHdr.label_time);
531 get_current_time(&dt);
532 dev->VolHdr.write_date = dt.julian_day_number;
533 dev->VolHdr.write_time = dt.julian_day_fraction;
535 ser_float64(dev->VolHdr.write_date); /* 0 if VerNum >= 11 */
536 ser_float64(dev->VolHdr.write_time); /* 0 if VerNum >= 11 */
538 ser_string(dev->VolHdr.VolumeName);
539 ser_string(dev->VolHdr.PrevVolumeName);
540 ser_string(dev->VolHdr.PoolName);
541 ser_string(dev->VolHdr.PoolType);
542 ser_string(dev->VolHdr.MediaType);
544 ser_string(dev->VolHdr.HostName);
545 ser_string(dev->VolHdr.LabelProg);
546 ser_string(dev->VolHdr.ProgVersion);
547 ser_string(dev->VolHdr.ProgDate);
549 ser_end(rec->data, SER_LENGTH_Volume_Label);
550 rec->data_len = ser_length(rec->data);
551 rec->FileIndex = dev->VolHdr.LabelType;
552 rec->VolSessionId = jcr->VolSessionId;
553 rec->VolSessionTime = jcr->VolSessionTime;
554 rec->Stream = jcr->NumVolumes;
555 Dmsg2(150, "Created Vol label rec: FI=%s len=%d\n", FI_to_ascii(buf, rec->FileIndex),
561 * Create a volume label in memory
563 void create_volume_label(DEVICE *dev, const char *VolName,
564 const char *PoolName, bool dvdnow)
566 DEVRES *device = (DEVRES *)dev->device;
568 Dmsg0(90, "Start create_volume_label()\n");
572 free_volume(dev); /* release any old volume */
573 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
575 bstrncpy(dev->VolHdr.Id, BaculaId, sizeof(dev->VolHdr.Id));
576 dev->VolHdr.VerNum = BaculaTapeVersion;
577 if (dev->is_dvd() && dvdnow) {
578 /* We do not want to re-label a DVD so write VOL_LABEL now */
579 dev->VolHdr.LabelType = VOL_LABEL;
581 dev->VolHdr.LabelType = PRE_LABEL; /* Mark tape as unused */
583 bstrncpy(dev->VolHdr.VolumeName, VolName, sizeof(dev->VolHdr.VolumeName));
584 bstrncpy(dev->VolHdr.PoolName, PoolName, sizeof(dev->VolHdr.PoolName));
585 bstrncpy(dev->VolHdr.MediaType, device->media_type, sizeof(dev->VolHdr.MediaType));
587 bstrncpy(dev->VolHdr.PoolType, "Backup", sizeof(dev->VolHdr.PoolType));
589 dev->VolHdr.label_btime = get_current_btime();
590 dev->VolHdr.label_date = 0;
591 dev->VolHdr.label_time = 0;
593 if (gethostname(dev->VolHdr.HostName, sizeof(dev->VolHdr.HostName)) != 0) {
594 dev->VolHdr.HostName[0] = 0;
596 bstrncpy(dev->VolHdr.LabelProg, my_name, sizeof(dev->VolHdr.LabelProg));
597 sprintf(dev->VolHdr.ProgVersion, "Ver. %s %s", VERSION, BDATE);
598 sprintf(dev->VolHdr.ProgDate, "Build %s %s", __DATE__, __TIME__);
599 dev->set_labeled(); /* set has Bacula label */
600 if (debug_level >= 90) {
601 dump_volume_label(dev);
606 * Create session label
607 * The pool memory must be released by the calling program
609 void create_session_label(DCR *dcr, DEV_RECORD *rec, int label)
614 rec->VolSessionId = jcr->VolSessionId;
615 rec->VolSessionTime = jcr->VolSessionTime;
616 rec->Stream = jcr->JobId;
618 rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label);
619 ser_begin(rec->data, SER_LENGTH_Session_Label);
620 ser_string(BaculaId);
621 ser_uint32(BaculaTapeVersion);
623 ser_uint32(jcr->JobId);
625 /* Changed in VerNum 11 */
626 ser_btime(get_current_btime());
629 ser_string(dcr->pool_name);
630 ser_string(dcr->pool_type);
631 ser_string(jcr->job_name); /* base Job name */
632 ser_string(jcr->client_name);
634 /* Added in VerNum 10 */
635 ser_string(jcr->Job); /* Unique name of this Job */
636 ser_string(jcr->fileset_name);
637 ser_uint32(jcr->JobType);
638 ser_uint32(jcr->JobLevel);
639 /* Added in VerNum 11 */
640 ser_string(jcr->fileset_md5);
642 if (label == EOS_LABEL) {
643 ser_uint32(jcr->JobFiles);
644 ser_uint64(jcr->JobBytes);
645 ser_uint32(dcr->StartBlock);
646 ser_uint32(dcr->EndBlock);
647 ser_uint32(dcr->StartFile);
648 ser_uint32(dcr->EndFile);
649 ser_uint32(jcr->JobErrors);
651 /* Added in VerNum 11 */
652 ser_uint32(jcr->JobStatus);
654 ser_end(rec->data, SER_LENGTH_Session_Label);
655 rec->data_len = ser_length(rec->data);
658 /* Write session label
659 * Returns: false on failure
662 bool write_session_label(DCR *dcr, int label)
665 DEVICE *dev = dcr->dev;
667 DEV_BLOCK *block = dcr->block;
668 char buf1[100], buf2[100];
671 Dmsg1(90, "session_label record=%x\n", rec);
674 if (dev->is_tape()) {
675 dcr->StartBlock = dev->block_num;
676 dcr->StartFile = dev->file;
678 dcr->StartBlock = (uint32_t)dev->file_addr;
679 dcr->StartFile = (uint32_t)(dev->file_addr >> 32);
683 if (dev->is_tape()) {
684 dcr->EndBlock = dev->EndBlock;
685 dcr->EndFile = dev->EndFile;
687 dcr->EndBlock = (uint32_t)dev->file_addr;
688 dcr->EndFile = (uint32_t)(dev->file_addr >> 32);
692 Jmsg1(jcr, M_ABORT, 0, _("Bad session label = %d\n"), label);
695 create_session_label(dcr, rec, label);
696 rec->FileIndex = label;
699 * We guarantee that the session record can totally fit
700 * into a block. If not, write the block, and put it in
701 * the next block. Having the sesssion record totally in
702 * one block makes reading them much easier (no need to
703 * read the next block).
705 if (!can_write_record_to_block(block, rec)) {
706 Dmsg0(150, "Cannot write session label to block.\n");
707 if (!write_block_to_device(dcr)) {
708 Dmsg0(90, "Got session label write_block_to_dev error.\n");
709 /* ****FIXME***** errno is not set here */
710 Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"),
711 dev_vol_name(dev), strerror(errno));
716 if (!write_record_to_block(block, rec)) {
717 Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"),
718 dev_vol_name(dev), strerror(errno));
723 Dmsg6(50, "Write sesson_label record JobId=%d FI=%s SessId=%d Strm=%s len=%d "
724 "remainder=%d\n", jcr->JobId,
725 FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
726 stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
730 Dmsg2(50, "Leave write_session_label Block=%ud File=%ud\n",
731 dev->get_block(), dev->get_file());
735 /* unser_volume_label
737 * Unserialize the Bacula Volume label into the device Volume_Label
740 * Assumes that the record is already read.
742 * Returns: false on error
746 bool unser_volume_label(DEVICE *dev, DEV_RECORD *rec)
749 char buf1[100], buf2[100];
751 if (rec->FileIndex != VOL_LABEL && rec->FileIndex != PRE_LABEL) {
752 Mmsg3(dev->errmsg, _("Expecting Volume Label, got FI=%s Stream=%s len=%d\n"),
753 FI_to_ascii(buf1, rec->FileIndex),
754 stream_to_ascii(buf2, rec->Stream, rec->FileIndex),
761 dev->VolHdr.LabelType = rec->FileIndex;
762 dev->VolHdr.LabelSize = rec->data_len;
765 /* Unserialize the record into the Volume Header */
766 rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label);
767 ser_begin(rec->data, SER_LENGTH_Volume_Label);
768 unser_string(dev->VolHdr.Id);
769 unser_uint32(dev->VolHdr.VerNum);
771 if (dev->VolHdr.VerNum >= 11) {
772 unser_btime(dev->VolHdr.label_btime);
773 unser_btime(dev->VolHdr.write_btime);
774 } else { /* old way */
775 unser_float64(dev->VolHdr.label_date);
776 unser_float64(dev->VolHdr.label_time);
778 unser_float64(dev->VolHdr.write_date); /* Unused with VerNum >= 11 */
779 unser_float64(dev->VolHdr.write_time); /* Unused with VerNum >= 11 */
781 unser_string(dev->VolHdr.VolumeName);
782 unser_string(dev->VolHdr.PrevVolumeName);
783 unser_string(dev->VolHdr.PoolName);
784 unser_string(dev->VolHdr.PoolType);
785 unser_string(dev->VolHdr.MediaType);
787 unser_string(dev->VolHdr.HostName);
788 unser_string(dev->VolHdr.LabelProg);
789 unser_string(dev->VolHdr.ProgVersion);
790 unser_string(dev->VolHdr.ProgDate);
792 ser_end(rec->data, SER_LENGTH_Volume_Label);
793 Dmsg0(190, "unser_vol_label\n");
794 if (debug_level >= 190) {
795 dump_volume_label(dev);
801 bool unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec)
805 rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label);
806 unser_begin(rec->data, SER_LENGTH_Session_Label);
807 unser_string(label->Id);
808 unser_uint32(label->VerNum);
809 unser_uint32(label->JobId);
810 if (label->VerNum >= 11) {
811 unser_btime(label->write_btime);
813 unser_float64(label->write_date);
815 unser_float64(label->write_time);
816 unser_string(label->PoolName);
817 unser_string(label->PoolType);
818 unser_string(label->JobName);
819 unser_string(label->ClientName);
820 if (label->VerNum >= 10) {
821 unser_string(label->Job); /* Unique name of this Job */
822 unser_string(label->FileSetName);
823 unser_uint32(label->JobType);
824 unser_uint32(label->JobLevel);
826 if (label->VerNum >= 11) {
827 unser_string(label->FileSetMD5);
829 label->FileSetMD5[0] = 0;
831 if (rec->FileIndex == EOS_LABEL) {
832 unser_uint32(label->JobFiles);
833 unser_uint64(label->JobBytes);
834 unser_uint32(label->StartBlock);
835 unser_uint32(label->EndBlock);
836 unser_uint32(label->StartFile);
837 unser_uint32(label->EndFile);
838 unser_uint32(label->JobErrors);
839 if (label->VerNum >= 11) {
840 unser_uint32(label->JobStatus);
842 label->JobStatus = JS_Terminated; /* kludge */
848 void dump_volume_label(DEVICE *dev)
850 int dbl = debug_level;
852 const char *LabelType;
859 switch (dev->VolHdr.LabelType) {
861 LabelType = "PRE_LABEL";
864 LabelType = "VOL_LABEL";
867 LabelType = "EOM_LABEL";
870 LabelType = "SOS_LABEL";
873 LabelType = "EOS_LABEL";
879 sprintf(buf, _("Unknown %d"), dev->VolHdr.LabelType);
883 Pmsg11(-1, _("\nVolume Label:\n"
896 dev->VolHdr.Id, dev->VolHdr.VerNum,
897 dev->VolHdr.VolumeName, dev->VolHdr.PrevVolumeName,
898 File, LabelType, dev->VolHdr.LabelSize,
899 dev->VolHdr.PoolName, dev->VolHdr.MediaType,
900 dev->VolHdr.PoolType, dev->VolHdr.HostName);
902 if (dev->VolHdr.VerNum >= 11) {
904 bstrftime(dt, sizeof(dt), btime_to_unix(dev->VolHdr.label_btime));
905 Pmsg1(-1, _("Date label written: %s\n"), dt);
907 dt.julian_day_number = dev->VolHdr.label_date;
908 dt.julian_day_fraction = dev->VolHdr.label_time;
911 _("Date label written: %04d-%02d-%02d at %02d:%02d\n"),
912 tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min);
920 static void dump_session_label(DEV_RECORD *rec, const char *type)
926 char ec1[30], ec2[30], ec3[30], ec4[30], ec5[30], ec6[30], ec7[30];
928 unser_session_label(&label, rec);
931 Pmsg7(-1, _("\n%s Record:\n"
938 ""), type, label.JobId, label.VerNum,
939 label.PoolName, label.PoolType,
940 label.JobName, label.ClientName);
942 if (label.VerNum >= 10) {
944 "Job (unique name) : %s\n"
948 ""), label.Job, label.FileSetName, label.JobType, label.JobLevel);
951 if (rec->FileIndex == EOS_LABEL) {
962 edit_uint64_with_commas(label.JobFiles, ec1),
963 edit_uint64_with_commas(label.JobBytes, ec2),
964 edit_uint64_with_commas(label.StartBlock, ec3),
965 edit_uint64_with_commas(label.EndBlock, ec4),
966 edit_uint64_with_commas(label.StartFile, ec5),
967 edit_uint64_with_commas(label.EndFile, ec6),
968 edit_uint64_with_commas(label.JobErrors, ec7),
971 if (label.VerNum >= 11) {
973 bstrftime(dt, sizeof(dt), btime_to_unix(label.write_btime));
974 Pmsg1(-1, _("Date written : %s\n"), dt);
976 dt.julian_day_number = label.write_date;
977 dt.julian_day_fraction = label.write_time;
979 Pmsg5(-1, _("Date written : %04d-%02d-%02d at %02d:%02d\n"),
980 tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min);
986 void dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose)
991 if (rec->FileIndex == 0 && rec->VolSessionId == 0 && rec->VolSessionTime == 0) {
996 switch (rec->FileIndex) {
998 type = _("Fresh Volume");
1004 type = _("Begin Job Session");
1007 type = _("End Job Session");
1010 type = _("End of Media");
1013 type = _("End of Tape");
1016 type = _("Unknown");
1020 switch (rec->FileIndex) {
1023 unser_volume_label(dev, rec);
1024 dump_volume_label(dev);
1027 dump_session_label(rec, type);
1030 dump_session_label(rec, type);
1033 Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
1034 type, dev->file, dev->block_num, rec->VolSessionId,
1035 rec->VolSessionTime, rec->Stream, rec->data_len);
1038 Pmsg0(-1, _("End of physical tape.\n"));
1041 Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
1042 type, dev->file, dev->block_num, rec->VolSessionId,
1043 rec->VolSessionTime, rec->Stream, rec->data_len);
1047 SESSION_LABEL label;
1049 switch (rec->FileIndex) {
1051 unser_session_label(&label, rec);
1052 bstrftimes(dt, sizeof(dt), btime_to_unix(label.write_btime));
1053 Pmsg6(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d\n"),
1054 type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, label.JobId);
1055 Pmsg4(-1, _(" Job=%s Date=%s Level=%c Type=%c\n"),
1056 label.Job, dt, label.JobLevel, label.JobType);
1059 char ed1[30], ed2[30];
1060 unser_session_label(&label, rec);
1061 bstrftimes(dt, sizeof(dt), btime_to_unix(label.write_btime));
1062 Pmsg6(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d\n"),
1063 type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime, label.JobId);
1064 Pmsg7(-1, _(" Date=%s Level=%c Type=%c Files=%s Bytes=%s Errors=%d Status=%c\n"),
1065 dt, label.JobLevel, label.JobType,
1066 edit_uint64_with_commas(label.JobFiles, ed1),
1067 edit_uint64_with_commas(label.JobBytes, ed2),
1068 label.JobErrors, (char)label.JobStatus);
1074 Pmsg7(-1, _("%s Record: File:blk=%u:%u SessId=%d SessTime=%d JobId=%d DataLen=%d\n"),
1075 type, dev->file, dev->block_num, rec->VolSessionId, rec->VolSessionTime,
1076 rec->Stream, rec->data_len);